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

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

@@ -3,7 +3,7 @@ using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
 using Hotline.Application.Exam.Constants.ApiRoutes;
 using Hotline.Application.Exam.Interface.ExamManages;
-using Hotline.Repository.SqlSugar.Entitys;
+using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Requests.Exam;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;

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

@@ -1,6 +1,7 @@
 using Exam.Application.Interface.Exam;
 using Exam.Infrastructure.Data.Entity;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.ExamManages;
 using Hotline.Share.Dtos.ExamManages;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.ViewResponses.Exam;

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

@@ -2,7 +2,8 @@
 using Exam.Infrastructure.Data.Entity;
 using Exam.Share.ViewResponses.Exam;
 using Hotline.Application.Exam.Constants.ApiRoutes;
-using Hotline.Repository.SqlSugar.Entitys;
+using Hotline.Application.Exam.Interface.ExamManages;
+using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.ViewResponses.Exam;

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

@@ -1,8 +1,8 @@
 using Amazon.Runtime.Internal;
-using Exam.Application.Interface.Practices;
 using Exam.Share;
 using Exam.Share.ViewResponses.Practices;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Practices;
 using Hotline.Share.Dtos.Practices;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.TestPaper;

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

@@ -1,8 +1,8 @@
-using Exam.Application.Interface.Questions;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Share.ViewResponses.Question;
 using Hotline.Application.Exam.Constants.ApiRoutes;
-using Hotline.Repository.SqlSugar.Entitys;
+using Hotline.Application.Exam.Interface.Questions;
+using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
 using MapsterMapper;

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

@@ -2,6 +2,7 @@
 using Exam.Infrastructure.Data.Entity;
 using Exam.Share.ViewResponses.Sourceware;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Sourcewares;
 using Hotline.Share.Dtos.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
 using Microsoft.AspNetCore.Mvc;

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

@@ -1,6 +1,6 @@
-using Exam.Application.Interface.Sourcewares;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Sourcewares;
 using Hotline.Share.Dtos.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
 using Hotline.Share.ViewResponses.Sourcewares;

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

@@ -1,11 +1,11 @@
 using Exam.Application.Interface.Exam;
-using Exam.Application.Interface.TestPapers;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Share.ViewResponses.Exam;
 using Exam.Share.ViewResponses.TestPaper;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.TestPapers;
 using Hotline.Application.Exam.Service.ExamManages;
-using Hotline.Repository.SqlSugar.Entitys;
+using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Requests.Exam;

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

@@ -1,8 +1,8 @@
-using Exam.Application.Interface.Train;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Share;
 using Exam.Share.ViewResponses.Train;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
 using Microsoft.AspNetCore.Mvc;

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

@@ -3,6 +3,7 @@ using Exam.Infrastructure.Data.Entity;
 using Exam.Share.Dtos.Trains;
 using Exam.Share.ViewResponses.Train;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.Train;

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

@@ -1,7 +1,7 @@
-using Exam.Application.Interface.Train;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Share.ViewResponses.Train;
 using Hotline.Application.Exam.Constants.ApiRoutes;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
 using Microsoft.AspNetCore.Mvc;

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

@@ -9,6 +9,7 @@ using Hotline.Share.ViewResponses.Exam;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using System.ComponentModel;
+using Hotline.Application.Exam.Interface.ExamManages;
 
 namespace Hotline.Api.Controllers.Exam
 {

src/Hotline.Api/config/appsettings.Development.json

@@ -68,14 +68,13 @@
     }
   },
     "ConnectionStrings": {
-        "Hotline": "PORT=5432;DATABASE=hotline;HOST=110.188.24.182;PASSWORD=fengwo11!!;USER ID=dev;",
-        "CAP": "PORT=5432;DATABASE=fwmq;HOST=110.188.24.182;PASSWORD=fengwo11!!;USER ID=dev;Search Path=cap"
+        "Hotline": "PORT=5432;DATABASE=hotline;HOST=110.188.24.182;PASSWORD=fengwo11!!;USER ID=dev;"
     },
   "Cache": {
     "Host": "110.188.24.182",
     "Port": 50179,
     "Password": "fengwo123!$!$",
-    "Database": 5 //hl:3, dev:5, test:2, demo:4
+    "Database": 3 //hl:3, dev:5, test:2, demo:4
   },
   "Swagger": true,
   "AccLog":  false,
@@ -111,7 +110,7 @@
     }
   },
   "DatabaseConfiguration": {
-    "ApplyDbMigrations": true,
+    "ApplyDbMigrations": false,
     "ApplySeed": false
   },
   "MqConfiguration": {

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

@@ -1,6 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
-
-namespace Hotline.Application.Exam.Constants.ApiRoutes
+namespace Hotline.Application.Exam.Constants.ApiRoutes
 {
     public class ExamManageApiRoute:GenerateApiRoute
     {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 using Microsoft.Identity.Client;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,5 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
-using Quartz.Impl.Triggers;
+using Quartz.Impl.Triggers;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,4 +1,4 @@
-using Exam.Infrastructure.Web.Constants;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

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

@@ -1,10 +1,10 @@
-using Exam.Infrastructure.Web.Constants;
-using Org.BouncyCastle.Asn1.Mozilla;
+using Org.BouncyCastle.Asn1.Mozilla;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Hotline.Application.Exam.Core.Constants;
 
 namespace Hotline.Application.Exam.Constants.ApiRoutes
 {

src/Hotline.Application/Exam/Constants/Messages/BusinessErrorMessage.cs → src/Hotline.Application/Exam/Constants/Messages/BusinessExamErrorMessage.cs

@@ -1,8 +1,9 @@
 using Exam.Infrastructure.Validation.Validation;
+using Hotline.Exams.Validate;
 
 namespace Hotline.Application.Exam.Constants.Messages
 {
-    public class BusinessErrorMessage: ErrorMessage
+    public class BusinessExamErrorMessage: ExamErrorMessage
     {
         public const string HasChild = "{0}拥有下级，不可删除";
     }

src/Hotline.Application/Exam/Constants/Messages/SystemConstants.cs → src/Hotline.Application/Exam/Constants/Messages/ExamSystemConstants.cs

@@ -1,6 +1,6 @@
 namespace Hotline.Application.Exam.Constants.Messages
 {
-    public class SystemConstants
+    public class ExamSystemConstants
     {
         public static string[] Labels = ["A", "B", "C", "D", "E", "F", "G", "H","I","J"];
 

src/Hotline.Application/Exam/Core/Constants/ApiRoute.cs

@@ -1,4 +1,4 @@
-namespace Exam.Infrastructure.Web.Constants
+namespace Hotline.Application.Exam.Core.Constants
 {
     public class ApiRoute
     {

src/Hotline.Application/Exam/Core/Constants/BusiConstants.cs → src/Hotline.Application/Exam/Core/Constants/ExamBusiConstants.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace Hotline.Application.Exam.Core.Constants
 {
-    public  class BusiConstants
+    public  class ExamBusiConstants
     {
         public const string TrainCode = "PX";
 

src/Hotline.Application/Exam/Core/Extensions/ExpressionableExtensions.cs

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Entities;
 
-namespace Exam.Infrastructure.Web.Extensions
+namespace Hotline.Application.Exam.Core.Extensions
 {
     public static class ExpressionableExtensions
     {

src/Hotline.Application/Exam/Core/Utilities/CodeUtility.cs

@@ -1,5 +1,4 @@
 using Exam.Infrastructure.Extensions;
-using Exam.Trains;
 using System;
 using System.Collections.Generic;
 using System.Linq;

src/Hotline.Application/Exam/Core/Utilities/ExpressionableUtility.cs

@@ -1,7 +1,7 @@
 using SqlSugar;
 using XF.Domain.Entities;
 
-namespace Exam.Infrastructure.Web.Utilities
+namespace Hotline.Application.Exam.Core.Utilities
 {
     public static class ExpressionableUtility
     {

src/Hotline.Application/Exam/Core/Utilities/TypeAdapterConfigUtility.cs

@@ -1,26 +1,26 @@
-using Exam.Infrastructure.Data.Entity;
-using Mapster;
-using XF.Domain.Repository;
+//using Exam.Infrastructure.Data.Entity;
+//using Mapster;
+//using XF.Domain.Repository;
 
-namespace Exam.Infrastructure.Web.Utilities
-{
-    public class TypeAdapterConfigUtility
-    {
-        public static TypeAdapterConfig ForUpdate<TActionRequest, TEntity>()
-            where TActionRequest : ActionRequest
-            where TEntity : FullStateEntity
-        {
-            TypeAdapterConfig.GlobalSettings.ForType<TActionRequest, TEntity>()
-    .Ignore(x => x.CreationTime)
-                .Ignore(x => x.CreatorId)
-                .Ignore(x => x.CreatorName)
-                .Ignore(x => x.CreatorOrgId)
-                .Ignore(x => x.CreatorOrgLevel)
-                .Ignore(x => x.CreatorOrgName)
-                .Ignore(x => x.AreaId)
-                .Ignore(x => x.Id);
+//namespace Hotline.Application.Exam.Core.Utilities
+//{
+//    public class TypeAdapterConfigUtility
+//    {
+//        public static TypeAdapterConfig ForUpdate<TActionRequest, TEntity>()
+//            where TActionRequest : ActionRequest
+//            where TEntity : FullStateEntity
+//        {
+//            TypeAdapterConfig.GlobalSettings.ForType<TActionRequest, TEntity>()
+//    .Ignore(x => x.CreationTime)
+//                .Ignore(x => x.CreatorId)
+//                .Ignore(x => x.CreatorName)
+//                .Ignore(x => x.CreatorOrgId)
+//                .Ignore(x => x.CreatorOrgLevel)
+//                .Ignore(x => x.CreatorOrgName)
+//                .Ignore(x => x.AreaId)
+//                .Ignore(x => x.Id);
 
-            return TypeAdapterConfig.GlobalSettings;
-        }
-    }
-}
+//            return TypeAdapterConfig.GlobalSettings;
+//        }
+//    }
+//}

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

@@ -1,7 +1,6 @@
-using Exam.ExamManages;
-
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Requests.Exam;
 using Microsoft.AspNetCore.Http;

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

@@ -1,12 +1,10 @@
-using Exam.ExamManages;
-using Exam.Share.ViewResponses.Sourceware;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.ExamManages;
 using Hotline.Share.Requests.Exam;
-using Hotline.Share.Requests.Sourceware;
 using Hotline.Share.ViewResponses.Exam;
 
-namespace Exam.Application.Interface.Exam
+namespace Hotline.Application.Exam.Interface.ExamManages
 {
     public interface IExamTagService:IQueryService<ExamTagViewResponse,ExamTagDto,ExamTagRequest>,IApiService<AddExamTagDto,UpdateExamTagDto,ExamTag>
     {

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

@@ -1,14 +1,13 @@
-using Exam.ExamManages;
-
-using Exam.Share.ViewResponses.Exam;
+using Exam.Share.ViewResponses.Exam;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.ViewResponses.Exam;
 
-namespace Exam.Application.Interface.Exam
+namespace Hotline.Application.Exam.Interface.ExamManages
 {
-    public interface IExtractRuleService:IQueryService<ExtractRuleViewResponse,ExtractRuleDto,ExtractRulePagedRequest>,IApiService<AddExtractRuleDto,UpdateExtractRuleDto,ExtractRule>
+    public interface IExtractRuleService:IQueryService<ExtractRuleViewResponse,ExtractRuleDto,ExtractRulePagedRequest>,IApiService<AddExtractRuleDto,UpdateExtractRuleDto,ExamExtractRule>
     {
         public Task<List<TagQuestionViewResponse>> GetTagQuestionCount(TagQuestionRequest tagQuestionRequest);
     }

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

@@ -1,10 +1,9 @@
-
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Requests.Exam;
 
-namespace Exam.Application.Interface.Exam
+namespace Hotline.Application.Exam.Interface.ExamManages
 {
     public interface IUnExamUserService:IQueryService<UnExamUserViewResponse,UserExamDto,UnExamUserReportPagedRequest>
     {

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

@@ -1,10 +1,9 @@
-
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Requests.Exam;
 
-namespace Exam.Application.Interface.Exam
+namespace Hotline.Application.Exam.Interface.ExamManages
 {
     public interface IUserExamResultService:IQueryService<UserExamResultViewResponse,UserExamDto,UserExamResultReportPagedRequest>
     {

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

@@ -1,16 +1,16 @@
-using Exam.ExamManages;
-
+using Exam.Application.Interface.Exam;
 using Exam.Share;
 using Exam.Share.Dtos.ExamManage;
 using Exam.Share.ViewResponses.Exam;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.ExamManages;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.ViewResponses.Exam;
 
-namespace Exam.Application.Interface.Exam
+namespace Hotline.Application.Exam.Interface.ExamManages
 {
-    public interface IUserExamService:IQueryService<UserExamResultViewResponse,UserExamDto,UserExamPagedRequest>,IApiService<AddUserExamDto,UpdateUserExamDto,UserExam>
+    public interface IUserExamService:IQueryService<UserExamResultViewResponse,UserExamDto,UserExamPagedRequest>,IApiService<AddUserExamDto,UpdateUserExamDto,ExamUserExam>
     {
         /// <summary>
         /// 交卷

src/Hotline.Application/Exam/Interface/Practices/IPracticeService.cs

@@ -1,7 +1,6 @@
-
-using Exam.Practices;
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Practices;
+using Hotline.Exams.Practices;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Practices;
 using Hotline.Share.Requests.Exam;
@@ -9,9 +8,9 @@ using Hotline.Share.Requests.TestPaper;
 using Hotline.Share.ViewResponses.Exam;
 using Hotline.Share.ViewResponses.Practices;
 
-namespace Exam.Application.Interface.Practices
+namespace Hotline.Application.Exam.Interface.Practices
 {
-    public interface IPracticeService:IQueryService<PracticeViewResponse, PracticeDto,PracticePagedRequest>,IApiService<AddPracticeDto,UpdatePracticeDto,Practice>
+    public interface IPracticeService:IQueryService<PracticeViewResponse, PracticeDto,PracticePagedRequest>,IApiService<AddPracticeDto,UpdatePracticeDto,ExamPractice>
     {
         /// <summary>
         /// 获取自我练习试题类型和Id

src/Hotline.Application/Exam/Interface/Questions/IQuestionAnswerService.cs

@@ -1,19 +1,17 @@
-
-
-using Exam.Questions;
+using System.ComponentModel;
 using Exam.Share;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Questions
 {
     /// <summary>
     /// 试题参考答案服务接口
     /// </summary>
     [Description("试题参考答案服务接口")]
-    public interface IQuestionAnswerService:IQueryService<QuestionAnswerViewResponse,QuestionAnswerDto,QuestionAnswerPagedRequest>,IApiService<AddQuestionAnswerDto,UpdateQuestionAnswerDto,QuestionAnswer>
+    public interface IQuestionAnswerService:IQueryService<QuestionAnswerViewResponse,QuestionAnswerDto,QuestionAnswerPagedRequest>,IApiService<AddQuestionAnswerDto,UpdateQuestionAnswerDto,ExamQuestionAnswer>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Questions/IQuestionKnowladgeService.cs

@@ -1,19 +1,17 @@
-
-
-using Exam.Questions;
+using System.ComponentModel;
 using Exam.Share;
+using Hotline.Exams.TestPapers;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Questions
 {
     /// <summary>
     /// 关联知识服务接口
     /// </summary>
     [Description("关联知识服务接口")]
-    public interface IQuestionKnowladgeService:IQueryService<QuestionKnowladgeViewResponse,PracticeQuestionKnowladgeDto,QuestionKnowladgePagedRequest>,IApiService<AddQuestionKnowladgeDto,UpdateQuestionKnowladgeDto,TestPaperItemKnowladge>
+    public interface IQuestionKnowladgeService:IQueryService<QuestionKnowladgeViewResponse,PracticeQuestionKnowladgeDto,QuestionKnowladgePagedRequest>,IApiService<AddQuestionKnowladgeDto,UpdateQuestionKnowladgeDto,ExamTestPaperItemKnowladge>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Questions/IQuestionOptionsService.cs

@@ -1,19 +1,17 @@
-
-
-using Exam.Questions;
+using System.ComponentModel;
 using Exam.Share;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Questions
 {
     /// <summary>
     /// 试题选项服务接口
     /// </summary>
     [Description("试题选项服务接口")]
-    public interface IQuestionOptionsService:IQueryService<QuestionOptionsViewResponse,QuestionOptionsDto,QuestionOptionsPagedRequest>,IApiService<AddQuestionOptionsDto,UpdateQuestionOptionsDto,QuestionOptions>
+    public interface IQuestionOptionsService:IQueryService<QuestionOptionsViewResponse,QuestionOptionsDto,QuestionOptionsPagedRequest>,IApiService<AddQuestionOptionsDto,UpdateQuestionOptionsDto,ExamQuestionOptions>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Questions/IQuestionService.cs

@@ -1,14 +1,13 @@
-
-using Exam.Questions;
-using Exam.Share.ViewResponses.Question;
+using Exam.Share.ViewResponses.Question;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
 using Microsoft.AspNetCore.Http;
 
-namespace Exam.Application.Interface.Questions
+namespace Hotline.Application.Exam.Interface.Questions
 {
-    public interface IQuestionService:IQueryService<QuestionViewResponse,QuestionDto,QuestionPagedRequest>,IApiService<AddQuestionDto, UpdateQuestionDto, Question>
+    public interface IQuestionService:IQueryService<QuestionViewResponse,QuestionDto,QuestionPagedRequest>,IApiService<AddQuestionDto, UpdateQuestionDto, ExamQuestion>
     {
 
         /// <summary>

src/Hotline.Application/Exam/Interface/Questions/IQuestionSourcewareService.cs

@@ -1,19 +1,17 @@
-
-
-using Exam.Questions;
+using System.ComponentModel;
 using Exam.Share;
+using Hotline.Exams.Practices;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Questions
 {
     /// <summary>
     /// 关联课件服务接口
     /// </summary>
     [Description("关联课件服务接口")]
-    public interface IQuestionSourcewareService:IQueryService<QuestionSourcewareViewResponse,PracticeQuestionSourcewareDto,QuestionSourcewarePagedRequest>,IApiService<AddQuestionSourcewareDto,UpdateQuestionSourcewareDto,PracticeQuestionSourceware>
+    public interface IQuestionSourcewareService:IQueryService<QuestionSourcewareViewResponse,PracticeQuestionSourcewareDto,QuestionSourcewarePagedRequest>,IApiService<AddQuestionSourcewareDto,UpdateQuestionSourcewareDto,ExamPracticeQuestionSourceware>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Questions/IQuestionTagService.cs

@@ -1,19 +1,17 @@
-
-
-using Exam.Questions;
+using System.ComponentModel;
 using Exam.Share;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Questions
 {
     /// <summary>
     /// 试题标签服务接口
     /// </summary>
     [Description("试题标签服务接口")]
-    public interface IQuestionTagService:IQueryService<QuestionTagViewResponse,QuestionTagDto,QuestionTagPagedRequest>,IApiService<AddQuestionTagDto,UpdateQuestionTagDto,QuestionTag>
+    public interface IQuestionTagService:IQueryService<QuestionTagViewResponse,QuestionTagDto,QuestionTagPagedRequest>,IApiService<AddQuestionTagDto,UpdateQuestionTagDto,ExamQuestionTag>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Sourcewares/ISourcewareCategoryService.cs

@@ -1,17 +1,17 @@
+using System.ComponentModel;
 using Exam.Share.ViewResponses.Sourceware;
 using Hotline.Exams.Sourcewares;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
-using System.ComponentModel;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.Interface.Sourcewares
 {
     /// <summary>
     /// 课件类型服务接口
     /// </summary>
     [Description("课件类型服务接口")]
-    public interface ISourcewareCategoryService:IQueryService<SourcewareCategoryViewResponse,SourcewareCategoryDto,SourcewareCategoryRequest>,IApiService<AddSourcewareCategoryDto,UpdateSourcewareCategoryDto,SourcewareCategory>
+    public interface ISourcewareCategoryService:IQueryService<SourcewareCategoryViewResponse,SourcewareCategoryDto,SourcewareCategoryRequest>,IApiService<AddSourcewareCategoryDto,UpdateSourcewareCategoryDto,ExamSourcewareCategory>
     {
         public Task<List<SourcewareCategoryViewResponse>> GetTreeAsync(SourcewareCategoryRequest sourcewareCategoryRequest);
     }

src/Hotline.Application/Exam/Interface/Sourcewares/ISourcewareService.cs

@@ -1,17 +1,17 @@
+using System.ComponentModel;
 using Hotline.Exams.Sourcewares;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
 using Hotline.Share.ViewResponses.Sourcewares;
-using System.ComponentModel;
 
-namespace Exam.Application.Interface.Sourcewares
+namespace Hotline.Application.Exam.Interface.Sourcewares
 {
     /// <summary>
     /// 课件服务接口
     /// </summary>
     [Description("课件服务接口")]
-    public interface ISourcewareService:IQueryService<SourcewareViewResponse,SourcewareDto,SourcewarePagedRequest>,IApiService<AddSourcewareDto, UpdateSourcewareDto, Sourceware>
+    public interface ISourcewareService:IQueryService<SourcewareViewResponse,SourcewareDto,SourcewarePagedRequest>,IApiService<AddSourcewareDto, UpdateSourcewareDto, ExamSourceware>
     {
     }
 }

src/Hotline.Application/Exam/Interface/TestPapers/ITestPaperService.cs

@@ -1,18 +1,15 @@
-
-using Exam.Share.ViewResponses.Question;
-using Exam.Share.ViewResponses.TestPaper;
-using Exam.TestPapers;
+using Exam.Share.ViewResponses.TestPaper;
+using Hotline.Exams.TestPapers;
 using Hotline.Repository.SqlSugar.Interface;
-using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.TestPaper;
 using Hotline.Share.ViewResponses.Exam;
 using Hotline.Share.ViewResponses.Questions;
 
-namespace Exam.Application.Interface.TestPapers
+namespace Hotline.Application.Exam.Interface.TestPapers
 {
-    public interface ITestPaperService:IQueryService<TestPaperViewResponse,TestPaperDto,TestPaperPagedRequest>,IApiService<AddTestPaperDto,UpdateTestPaperDto,TestPaper>
+    public interface ITestPaperService:IQueryService<TestPaperViewResponse,TestPaperDto,TestPaperPagedRequest>,IApiService<AddTestPaperDto,UpdateTestPaperDto,ExamTestPaper>
     {
         /// <summary>
         /// 获取试卷试题数量

src/Hotline.Application/Exam/Interface/Train/ITrainPlanService.cs

@@ -1,13 +1,12 @@
-
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
+using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Requests.Train;
 
-namespace Exam.Application.Interface.Train
+namespace Hotline.Application.Exam.Interface.Train
 {
-    public interface ITrainPlanService:IQueryService<TrainPlanViewResponse,TrainPlanDto,TrainPlanPagedRequest>,IApiService<AddTrainPlanDto,UpdateTrainPlanDto,TrainPlan>
+    public interface ITrainPlanService:IQueryService<TrainPlanViewResponse,TrainPlanDto,TrainPlanPagedRequest>,IApiService<AddTrainPlanDto,UpdateTrainPlanDto,ExamTrainPlan>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Train/ITrainRecordAnswerService.cs

@@ -1,11 +1,10 @@
-
-using Exam.Trains;
+using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Trains;
 
-namespace Exam.Application.Interface.Train
+namespace Hotline.Application.Exam.Interface.Train
 {
-    public interface ITrainRecordAnswerService:IApiService<AddTrainRecordAnswerDto,UpdateTrainRecordAnswerDto,TrainRecordAnswer>
+    public interface ITrainRecordAnswerService:IApiService<AddTrainRecordAnswerDto,UpdateTrainRecordAnswerDto,ExamTrainRecordAnswer>
     {
     }
 }

src/Hotline.Application/Exam/Interface/Train/ITrainRecordService.cs

@@ -1,15 +1,14 @@
 using Exam.Share.Dtos.Trains;
 using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
+using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Trains;
-using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.Train;
 using Hotline.Share.ViewResponses.Trains;
 
-namespace Train.Application.Interface.Train
+namespace Hotline.Application.Exam.Interface.Train
 {
-    public interface ITrainRecordService:IQueryService<TrainRecordViewResponse,TrainRecordDto,TrainRecordPagedRequest>,IApiService<AddTrainRecordDto,UpdateTrainRecordDto,TrainRecord>
+    public interface ITrainRecordService:IQueryService<TrainRecordViewResponse,TrainRecordDto,TrainRecordPagedRequest>,IApiService<AddTrainRecordDto,UpdateTrainRecordDto,ExamTrainRecord>
     {
         /// <summary>
         /// 结束培训

src/Hotline.Application/Exam/Interface/Train/ITrainTemplateService.cs

@@ -1,13 +1,12 @@
-
-using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
+using Exam.Share.ViewResponses.Train;
+using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar.Interface;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
 
-namespace Exam.Application.Interface.Train
+namespace Hotline.Application.Exam.Interface.Train
 {
-    public interface ITrainTemplateService:IQueryService<TrainTemplateViewResponse,TrainTemplateDto,TrainTemplatePagedRequest>,IApiService<AddTrainTemplateDto,UpdateTrainTemplateDto,TrainTemplate>
+    public interface ITrainTemplateService:IQueryService<TrainTemplateViewResponse,TrainTemplateDto,TrainTemplatePagedRequest>,IApiService<AddTrainTemplateDto,UpdateTrainTemplateDto,ExamTrainTemplate>
     {
     }
 }

src/Hotline.Application/Exam/Mappers/MapperConfigs.cs

@@ -1,21 +0,0 @@
-using Exam.Infrastructure.Data.Interface;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
-using Hotline.Share.Dtos.Questions;
-using Hotline.Share.Notifications.NewRockCallCenter.Base;
-using Mapster;
-using System.Reflection;
-using System.Text.RegularExpressions;
-using XF.Domain.Entities;
-using XF.Domain.Repository;
-
-namespace Exam.Application.Mappers
-{
-    internal class MapperConfigs : IRegister
-    {
-        public void Register(TypeAdapterConfig config)
-        {
-            config.ForType<QuestionDto, Question>().IgnoreNullValues(true);
-        }
-    }
-}

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

@@ -1,7 +1,6 @@
-using Exam.ExamManages;
-using Exam.Questions;
-using Exam.Repository.Sqlsugar.Repositories;
+using Exam.Repository.Sqlsugar.Repositories;
 using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
@@ -12,6 +11,11 @@ using Hotline.Repository.SqlSugar.Interface;
 using MapsterMapper;
 using SqlSugar;
 using XF.Domain.Authentications;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using ExamQuestionAnswer = Hotline.Exams.Questions.ExamQuestionAnswer;
+using ExamQuestionKnowladge = Hotline.Exams.Questions.ExamQuestionKnowladge;
+using ExamQuestionOptions = Hotline.Exams.Questions.ExamQuestionOptions;
+using ExamQuestionSourceware = Hotline.Exams.Questions.ExamQuestionSourceware;
 
 namespace Hotline.Application.Exam.Proxy
 {
@@ -53,9 +57,9 @@ namespace Hotline.Application.Exam.Proxy
         }
 
         #region public method
-        public async Task GenerateQuestion(List<Question> questions, string testPaperId, CancellationToken cancellationToken)
+        public async Task GenerateQuestion(List<ExamQuestion> questions, string testPaperId, CancellationToken cancellationToken)
         {
-            List<ExamQuestion> examQuestions = await SyncQuestion(questions, testPaperId, cancellationToken);
+            List<Exams.ExamManages.ExamQuestion> examQuestions = await SyncQuestion(questions, testPaperId, cancellationToken);
 
             var examQuestionOptionses = await SyncQuestionOptions(examQuestions, cancellationToken);
             var examQuestionSourcewares = await SyncQuestionSourcewares(examQuestions, cancellationToken);
@@ -116,17 +120,17 @@ namespace Hotline.Application.Exam.Proxy
         #region private method
 
 
-        private async Task<List<ExamQuestionAnswer>> SyncQuestionAnswer(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        private async Task<List<Exams.ExamManages.ExamQuestionAnswer>> SyncQuestionAnswer(List<Exams.ExamManages.ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionAnswersRepository = new ExamRepository<ExamQuestionAnswer>(_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>();
+            var examQuestionAnswers = new List<Exams.ExamManages.ExamQuestionAnswer>();
 
             questionAnswers.ForEach(item =>
             {
-                var examQuestionAnswer = _mapper.Map<ExamQuestionAnswer>(item);
+                var examQuestionAnswer = _mapper.Map<Exams.ExamManages.ExamQuestionAnswer>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionAnswer.QuestionAnswerId = item.Id;
                 examQuestionAnswer.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -140,17 +144,17 @@ namespace Hotline.Application.Exam.Proxy
             return examQuestionAnswers;
         }
 
-        private async Task<List<ExamQuestionKnowladge>> SyncQuestionKnowladge(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        private async Task<List<Exams.ExamManages.ExamQuestionKnowladge>> SyncQuestionKnowladge(List<Exams.ExamManages.ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgesRepository = new ExamRepository<ExamQuestionKnowladge>(_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>();
+            var examQuestionKnowladges = new List<Exams.ExamManages.ExamQuestionKnowladge>();
 
             questionKnowladges.ForEach(item =>
             {
-                var examQuestionKnowladge = _mapper.Map<ExamQuestionKnowladge>(item);
+                var examQuestionKnowladge = _mapper.Map<Exams.ExamManages.ExamQuestionKnowladge>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionKnowladge.KnowladgeId = item.Id;
                 examQuestionKnowladge.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -164,17 +168,17 @@ namespace Hotline.Application.Exam.Proxy
             return examQuestionKnowladges;
         }
 
-        private async Task<List<ExamQuestionSourceware>> SyncQuestionSourcewares(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        private async Task<List<Exams.ExamManages.ExamQuestionSourceware>> SyncQuestionSourcewares(List<Exams.ExamManages.ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewaresRepository = new ExamRepository<ExamQuestionSourceware>(_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>();
+            var examQuestionSourcewares = new List<Exams.ExamManages.ExamQuestionSourceware>();
 
             questionSourcewares.ForEach(item =>
             {
-                var examQuestionSourceware = _mapper.Map<ExamQuestionSourceware>(item);
+                var examQuestionSourceware = _mapper.Map<Exams.ExamManages.ExamQuestionSourceware>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionSourceware.SourcewareId = item.Id;
                 examQuestionSourceware.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -188,17 +192,17 @@ namespace Hotline.Application.Exam.Proxy
             return examQuestionSourcewares;
         }
 
-        private async Task<List<ExamQuestionOptions>> SyncQuestionOptions(List<ExamQuestion> examQuestions, CancellationToken cancellationToken)
+        private async Task<List<Exams.ExamManages.ExamQuestionOptions>> SyncQuestionOptions(List<Exams.ExamManages.ExamQuestion> examQuestions, CancellationToken cancellationToken)
         {
-            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionsRepository = new ExamRepository<ExamQuestionOptions>(_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>();
+            var examQuestionOptions = new List<Exams.ExamManages.ExamQuestionOptions>();
 
             questionOptions.ForEach(item =>
             {
-                var examQuestionOption = _mapper.Map<ExamQuestionOptions>(item);
+                var examQuestionOption = _mapper.Map<Exams.ExamManages.ExamQuestionOptions>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionOption.QuestionOptionId = item.Id;
                 examQuestionOption.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -212,14 +216,14 @@ namespace Hotline.Application.Exam.Proxy
             return examQuestionOptions;
         }
 
-        private async Task<List<ExamQuestion>> SyncQuestion(List<Question> questions, string testPaperId, CancellationToken cancellationToken)
+        private async Task<List<Exams.ExamManages.ExamQuestion>> SyncQuestion(List<ExamQuestion> questions, string testPaperId, CancellationToken cancellationToken)
         {
 
-            var examQuestions = new List<ExamQuestion>();
+            var examQuestions = new List<Exams.ExamManages.ExamQuestion>();
 
             questions.ForEach(item =>
             {
-                var examQuestion = _mapper.Map<ExamQuestion>(item);
+                var examQuestion = _mapper.Map<Exams.ExamManages.ExamQuestion>(item);
                 examQuestion.ExamId = testPaperId;
                 examQuestion.QuestionId = item.Id;
                 examQuestions.Add(examQuestion);

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

@@ -1,6 +1,4 @@
-using Exam.Questions;
-using Exam.Repository.Sqlsugar.Repositories;
-using Exam.TestPapers;
+using Exam.Repository.Sqlsugar.Repositories;
 using Hotline.Exams.TestPapers;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
@@ -10,6 +8,7 @@ using Hotline.Repository.SqlSugar.Extensions;
 using MapsterMapper;
 using SqlSugar;
 using System.Threading;
+using Hotline.Exams.Questions;
 using XF.Domain.Authentications;
 using XF.Domain.Repository;
 
@@ -52,9 +51,9 @@ namespace Hotline.Application.Exam.Proxy
         }
 
         #region public method
-        public async Task GenerateQuestion(List<Question> questions,string testPaperId, CancellationToken cancellationToken)
+        public async Task GenerateQuestion(List<ExamQuestion> questions,string testPaperId, CancellationToken cancellationToken)
         {
-            List<TestPaperItem> testPaperItems = await SyncQuestion(questions, testPaperId, cancellationToken);
+            List<ExamTestPaperItem> testPaperItems = await SyncQuestion(questions, testPaperId, cancellationToken);
 
             var testPaperItemOptionses = await SyncQuestionOptions(testPaperItems, cancellationToken);
             var testPaperItemSourcewares = await SyncQuestionSourcewares(testPaperItems, cancellationToken);
@@ -114,17 +113,17 @@ namespace Hotline.Application.Exam.Proxy
         #region private method
 
 
-        private async Task<List<TestPaperItemAnswer>> SyncQuestionAnswer(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemAnswer>> SyncQuestionAnswer(List<ExamTestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionAnswersRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionAnswersRepository = new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionAnswers = await questionAnswersRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemAnswers = new List<TestPaperItemAnswer>();
+            var testPaperItemAnswers = new List<ExamTestPaperItemAnswer>();
 
             questionAnswers.ForEach(item =>
             {
-                var testPaperItemAnswer = _mapper.Map<TestPaperItemAnswer>(item);
+                var testPaperItemAnswer = _mapper.Map<ExamTestPaperItemAnswer>(item);
                 var testPaperItem = testPaperItems.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 testPaperItemAnswer.QuestionAnswerId = item.Id;
                 testPaperItemAnswer.TestPaperItemId = testPaperItem?.Id ?? string.Empty;
@@ -138,17 +137,17 @@ namespace Hotline.Application.Exam.Proxy
             return testPaperItemAnswers;
         }
 
-        private async Task<List<TestPaperItemKnowladge>> SyncQuestionKnowladge(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemKnowladge>> SyncQuestionKnowladge(List<ExamTestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionKnowladgesRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgesRepository = new ExamRepository<ExamQuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionKnowladges = await questionKnowladgesRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemKnowladges = new List<TestPaperItemKnowladge>();
+            var testPaperItemKnowladges = new List<ExamTestPaperItemKnowladge>();
 
             questionKnowladges.ForEach(item =>
             {
-                var testPaperItemKnowladge = _mapper.Map<TestPaperItemKnowladge>(item);
+                var testPaperItemKnowladge = _mapper.Map<ExamTestPaperItemKnowladge>(item);
                 var testPaperItem = testPaperItems.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 testPaperItemKnowladge.KnowladgeId = item.Id;
                 testPaperItemKnowladge.TestPaperItemId = testPaperItem?.Id ?? string.Empty;
@@ -162,17 +161,17 @@ namespace Hotline.Application.Exam.Proxy
             return testPaperItemKnowladges;
         }
 
-        private async Task<List<TestPaperItemSourceware>> SyncQuestionSourcewares(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemSourceware>> SyncQuestionSourcewares(List<ExamTestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionSourcewaresRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewaresRepository = new ExamRepository<ExamQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionSourcewares = await questionSourcewaresRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemSourcewares = new List<TestPaperItemSourceware>();
+            var testPaperItemSourcewares = new List<ExamTestPaperItemSourceware>();
 
             questionSourcewares.ForEach(item =>
             {
-                var testPaperItemSourceware = _mapper.Map<TestPaperItemSourceware>(item);
+                var testPaperItemSourceware = _mapper.Map<ExamTestPaperItemSourceware>(item);
                 var testPaperItem = testPaperItems.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 testPaperItemSourceware.SourcewareId = item.Id;
                 testPaperItemSourceware.TestPaperItemId = testPaperItem?.Id ?? string.Empty;
@@ -186,17 +185,17 @@ namespace Hotline.Application.Exam.Proxy
             return testPaperItemSourcewares;
         }
 
-        private async Task<List<TestPaperItemOptions>> SyncQuestionOptions(List<TestPaperItem> testPaperItems, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemOptions>> SyncQuestionOptions(List<ExamTestPaperItem> testPaperItems, CancellationToken cancellationToken)
         {
-            var questionOptionsRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionsRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionIds = testPaperItems.Select(x => x.QuestionId);
             var questionOptions = await questionOptionsRepository.Queryable().Where(x => questionIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemOptions = new List<TestPaperItemOptions>();
+            var testPaperItemOptions = new List<ExamTestPaperItemOptions>();
 
             questionOptions.ForEach(item =>
             {
-                var testPaperItemOption = _mapper.Map<TestPaperItemOptions>(item);
+                var testPaperItemOption = _mapper.Map<ExamTestPaperItemOptions>(item);
                 var testPaperItem = testPaperItems.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 testPaperItemOption.QuestionOptionId = item.Id;
                 testPaperItemOption.TestPaperItemId = testPaperItem?.Id ?? string.Empty;
@@ -210,14 +209,14 @@ namespace Hotline.Application.Exam.Proxy
             return testPaperItemOptions;
         }
 
-        private async Task<List<TestPaperItem>> SyncQuestion(List<Question> questions, string testPaperId, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItem>> SyncQuestion(List<ExamQuestion> questions, string testPaperId, CancellationToken cancellationToken)
         {
 
-            var testPaperItems = new List<TestPaperItem>();
+            var testPaperItems = new List<ExamTestPaperItem>();
 
             questions.ForEach(item =>
             {
-                var testPaperItem = _mapper.Map<TestPaperItem>(item);
+                var testPaperItem = _mapper.Map<ExamTestPaperItem>(item);
                 testPaperItem.TestPaperId = testPaperId;
                 testPaperItem.QuestionId = item.Id;
                 testPaperItems.Add(testPaperItem);

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

@@ -1,9 +1,9 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
+using Exam.Infrastructure.Extensions;
 using Hotline.Share.Requests.Exam;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {

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

@@ -1,8 +1,4 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
-using Exam.TestPapers;
+using Exam.Infrastructure.Extensions;
 using Hotline.Share.Requests.Exam;
 using System;
 using System.Collections.Generic;
@@ -10,6 +6,8 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {

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

@@ -1,6 +1,6 @@
-using Exam.ExamManages;
 using Hotline.Share.Requests.Exam;
 using System.Linq.Expressions;
+using Hotline.Exams.ExamManages;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {

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

@@ -1,19 +1,19 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
+using Exam.Infrastructure.Extensions;
 using Hotline.Share.Requests.Exam;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {
     public static class ExtractRuleQueryExtensions
     {
-        public static Expression<Func<ExtractRule, bool>> GetExpression(this ExtractRulePagedRequest extractRulePagedRequest)
+        public static Expression<Func<ExamExtractRule, bool>> GetExpression(this ExtractRulePagedRequest extractRulePagedRequest)
         {
-            Expression<Func<ExtractRule, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamExtractRule, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<ExtractRule>()
+            expression = ExpressionableUtility.CreateExpression<ExamExtractRule>()
                          .AndIF(extractRulePagedRequest.Code.IsNotNullOrEmpty(), x => x.Code.Contains(extractRulePagedRequest.Code))
                          .AndIF(extractRulePagedRequest.Name.IsNotNullOrEmpty(), x => x.Name.Contains(extractRulePagedRequest.Name))
                          .AndIF(extractRulePagedRequest.ExamType.IsNotNull(), x => x.RuleType == extractRulePagedRequest.ExamType)

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

@@ -1,19 +1,19 @@
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
-using Hotline.Application.Exam.Extensions;
+using Hotline.Application.Exam.Extensions;
 using Hotline.Share.Requests.Exam;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.Questions;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {
     public static class TagQuestionQueryExtensions
     {
-        public static Expression<Func<QuestionTag, bool>> GetExpression(this TagQuestionRequest tagQuestionRequest)
+        public static Expression<Func<ExamQuestionTag, bool>> GetExpression(this TagQuestionRequest tagQuestionRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionTag>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionTag>()
                 .AndIF(tagQuestionRequest.TagIds.IsNotNullOrEmpty(), x => tagQuestionRequest.TagIds.Contains(x.TagId)).ToExpression();
 
             return expression;

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

@@ -1,8 +1,5 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
+using Exam.Infrastructure.Extensions;
 using Exam.Share;
-using Exam.Trains;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.Train;
 using JiebaNet.Segmenter.Common;
@@ -12,16 +9,18 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
 
 namespace Hotline.Application.Exam.QueryExtensions.ExamManages
 {
     public static class UserExamQueryExtensions
     {
-        public static Expression<Func<UserExam,bool>> GetExpression(this UserExamPagedRequest userExamPagedRequest)
+        public static Expression<Func<ExamUserExam,bool>> GetExpression(this UserExamPagedRequest userExamPagedRequest)
         {
-            Expression<Func<UserExam, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamUserExam, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<UserExam>()
+            expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
                 .AndIF(userExamPagedRequest.MinScore.IsNotNull(), x => x.Score >= userExamPagedRequest.MinScore)
                 .AndIF(userExamPagedRequest.MaxScore.IsNotNull(), x => x.Score <= userExamPagedRequest.MaxScore)
                 .And(x=>x.UserId == userExamPagedRequest.UserId)
@@ -49,11 +48,11 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
         }
 
     
-        public static Expression<Func<UserExam,bool>> GetExpression(this GradingExamRequest gradingExamRequest)
+        public static Expression<Func<ExamUserExam,bool>> GetExpression(this GradingExamRequest gradingExamRequest)
         {
-            Expression<Func<UserExam, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamUserExam, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<UserExam>()
+            expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
                 .AndIF(gradingExamRequest.ExamId.IsNotNullOrEmpty(), x => x.ExamId == gradingExamRequest.ExamId)
                 .AndIF(gradingExamRequest.UserId.IsNotNullOrEmpty(), x => x.UserId == gradingExamRequest.UserId).ToExpression();
 
@@ -74,11 +73,11 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
             return expression;
         }
 
-        public static Expression<Func<UserExam, bool>> GetUserExamExpression(this UnExamUserReportPagedRequest unExamUserReportPagedRequest)
+        public static Expression<Func<ExamUserExam, bool>> GetUserExamExpression(this UnExamUserReportPagedRequest unExamUserReportPagedRequest)
         {
-            Expression<Func<UserExam, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamUserExam, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<UserExam>()
+            expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
                 .And(x=>x.ExamStatus == Share.Enums.Exams.EExamStatus.NoStart)
             .ToExpression();
 
@@ -98,11 +97,11 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
             return expression;
         }
 
-        public static Expression<Func<UserExam, bool>> GetUserExamExpression(this UserExamResultReportPagedRequest userExamResultReportPagedRequest)
+        public static Expression<Func<ExamUserExam, bool>> GetUserExamExpression(this UserExamResultReportPagedRequest userExamResultReportPagedRequest)
         {
-            Expression<Func<UserExam, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamUserExam, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<UserExam>()
+            expression = ExpressionableUtility.CreateExpression<ExamUserExam>()
             .AndIF(userExamResultReportPagedRequest.MinScore.IsNotNull(), x => x.Score >= userExamResultReportPagedRequest.MinScore)
             .AndIF(userExamResultReportPagedRequest.MaxScore.IsNotNull(), x => x.Score <= userExamResultReportPagedRequest.MaxScore)
             .ToExpression();

src/Hotline.Application/Exam/QueryExtensions/Practices/PracticeQueryExtensions.cs

@@ -1,7 +1,4 @@
 using DocumentFormat.OpenXml.Office2013.Excel;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Practices;
-using Exam.Questions;
 using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Share.Enums.Exams;
@@ -9,58 +6,61 @@ using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.TestPaper;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.Practices;
+using Hotline.Exams.Questions;
 
 namespace Hotline.Application.Exam.QueryExtensions.Practices
 {
     public static class PracticeQueryExtensions
     {
-        public static Expression<Func<Practice,bool>> GetExpression(this PracticePagedRequest practicePagedRequest)
+        public static Expression<Func<ExamPractice,bool>> GetExpression(this PracticePagedRequest practicePagedRequest)
         {
-            Expression<Func<Practice, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamPractice, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<Practice>()
+            expression = ExpressionableUtility.CreateExpression<ExamPractice>()
                 .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<PracticeQuestion,bool>> GetExpression(this PracticeQuestionGroupRequest practiceQuestionGroupRequest)
+        public static Expression<Func<ExamPracticeQuestion,bool>> GetExpression(this PracticeQuestionGroupRequest practiceQuestionGroupRequest)
         {
-            Expression<Func<PracticeQuestion, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamPracticeQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<PracticeQuestion>()
+            expression = ExpressionableUtility.CreateExpression<ExamPracticeQuestion>()
                 .AndIF(practiceQuestionGroupRequest.PracticeId.IsNotNull(),x=>x.PracticeId == practiceQuestionGroupRequest.PracticeId)
                 .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<PracticeQuestion,bool>> GetExpression(this PracticeQuestionRequest practiceQuestionRequest)
+        public static Expression<Func<ExamPracticeQuestion,bool>> GetExpression(this PracticeQuestionRequest practiceQuestionRequest)
         {
-            Expression<Func<PracticeQuestion, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamPracticeQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<PracticeQuestion>()
+            expression = ExpressionableUtility.CreateExpression<ExamPracticeQuestion>()
                 .AndIF(practiceQuestionRequest.PracticeQuestionId.IsNotNull(), x => x.Id == practiceQuestionRequest.PracticeQuestionId)
                 .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<QuestionTag, bool>> GetExpression(this TagQuestionCountForPracticeRequest tagQuestionCountForPracticeRequest)
+        public static Expression<Func<ExamQuestionTag, bool>> GetExpression(this TagQuestionCountForPracticeRequest tagQuestionCountForPracticeRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionTag>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionTag>()
                .AndIF(tagQuestionCountForPracticeRequest.TagIds.IsNotNullOrEmpty() && tagQuestionCountForPracticeRequest.TagIds.Any(), x => tagQuestionCountForPracticeRequest.TagIds.Contains(x.TagId))               
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<Question, bool>> GetQuestionExpression(this TagQuestionCountForPracticeRequest tagQuestionCountForPracticeRequest)
+        public static Expression<Func<ExamQuestion, bool>> GetQuestionExpression(this TagQuestionCountForPracticeRequest tagQuestionCountForPracticeRequest)
         {
-            Expression<Func<Question, bool>> expression = m => m.Id != null;
-            expression = ExpressionableUtility.CreateExpression<Question>()
+            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
+            expression = ExpressionableUtility.CreateExpression<ExamQuestion>()
             .And(x=>x.QuestionType == EQuestionType.Single || x.QuestionType == EQuestionType.Multi || x.QuestionType == EQuestionType.Judge)
             .ToExpression();
 

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionAnswerQueryExtensions.cs

@@ -1,14 +1,14 @@
-using Exam.Questions;
 using Hotline.Share.Requests.Question;
 using System.Linq.Expressions;
+using Hotline.Exams.Questions;
 
 namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionAnswerQueryExtesions
     {
-        public static Expression<Func<QuestionAnswer,bool>> GetExpression(this QuestionAnswerPagedRequest questionAnswerPagedRequest)
+        public static Expression<Func<ExamQuestionAnswer,bool>> GetExpression(this QuestionAnswerPagedRequest questionAnswerPagedRequest)
         {
-            Expression<Func<QuestionAnswer, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionAnswer, bool>> expression = m => m.Id != null;
 
             return expression;
         }

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionKnowladgeQueryExtensions.cs

@@ -1,14 +1,14 @@
-using Exam.Questions;
 using Hotline.Share.Requests.Question;
 using System.Linq.Expressions;
+using Hotline.Exams.TestPapers;
 
 namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionKnowladgeQueryExtesions
     {
-        public static Expression<Func<TestPaperItemKnowladge,bool>> GetExpression(this QuestionKnowladgePagedRequest questionKnowladgePagedRequest)
+        public static Expression<Func<ExamTestPaperItemKnowladge,bool>> GetExpression(this QuestionKnowladgePagedRequest questionKnowladgePagedRequest)
         {
-            Expression<Func<TestPaperItemKnowladge, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaperItemKnowladge, bool>> expression = m => m.Id != null;
 
             return expression;
         }

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionOptionsQueryExtensions.cs

@@ -1,14 +1,14 @@
-using Exam.Questions;
 using Hotline.Share.Requests.Question;
 using System.Linq.Expressions;
+using Hotline.Exams.Questions;
 
 namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionOptionsQueryExtesions
     {
-        public static Expression<Func<QuestionOptions,bool>> GetExpression(this QuestionOptionsPagedRequest questionOptionsPagedRequest)
+        public static Expression<Func<ExamQuestionOptions,bool>> GetExpression(this QuestionOptionsPagedRequest questionOptionsPagedRequest)
         {
-            Expression<Func<QuestionOptions, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionOptions, bool>> expression = m => m.Id != null;
 
             return expression;
         }

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionQueryExtesions.cs

@@ -1,32 +1,34 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
+using Exam.Infrastructure.Extensions;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Share.Requests.Question;
 using JiebaNet.Segmenter.Common;
 using SqlSugar;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using ExamQuestionKnowladge = Hotline.Exams.Questions.ExamQuestionKnowladge;
 
 namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionQueryExtesions
     {
-        public static Expression<Func<Question, bool>> GetExpression(this QuestionPagedRequest questionPagedRequest)
+        public static Expression<Func<ExamQuestion, bool>> GetExpression(this QuestionPagedRequest questionPagedRequest)
         {
-            Expression<Func<Question, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<Question>().AndIF(questionPagedRequest.DifficultyLevel.IsNotNull(), x => questionPagedRequest.DifficultyLevel == x.DifficultyLevel)
+            expression = ExpressionableUtility.CreateExpression<ExamQuestion>().AndIF(questionPagedRequest.DifficultyLevel.IsNotNull(), x => questionPagedRequest.DifficultyLevel == x.DifficultyLevel)
             .AndIF(questionPagedRequest.Title.IsNotNullOrEmpty(), x => x.Title.Contains(questionPagedRequest.Title))
             .ToExpression();
             return expression;
         }
 
-        public static Expression<Func<QuestionTag, bool>> GetQuestionTagExpression(this QuestionPagedRequest questionPagedRequest)
+        public static Expression<Func<ExamQuestionTag, bool>> GetQuestionTagExpression(this QuestionPagedRequest questionPagedRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionTag>().AndIF(questionPagedRequest.TagIds.IsNotNullOrEmpty(), x => questionPagedRequest.TagIds.Contains(x.TagId))
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionTag>().AndIF(questionPagedRequest.TagIds.IsNotNullOrEmpty(), x => questionPagedRequest.TagIds.Contains(x.TagId))
             .ToExpression();
             return expression;
         }
@@ -42,11 +44,11 @@ namespace Hotline.Application.Exam.QueryExtensions.Questions
             return expression;
         }
 
-        public static Expression<Func<QuestionKnowladge, bool>> GetQuestionKnowladgeExpression(this QuestionPagedRequest questionPagedRequest)
+        public static Expression<Func<ExamQuestionKnowladge, bool>> GetQuestionKnowladgeExpression(this QuestionPagedRequest questionPagedRequest)
         {
-            Expression<Func<QuestionKnowladge, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionKnowladge, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionKnowladge>().
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionKnowladge>().
             AndIF(questionPagedRequest.KnowladgeIds.IsNotNullOrEmpty(), x => questionPagedRequest.KnowladgeIds.Contains(x.QuestionId))
             .ToExpression();
 

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionSourcewareQueryExtensions.cs

@@ -1,14 +1,14 @@
-using Exam.Questions;
-using Hotline.Share.Requests.Question;
 using System.Linq.Expressions;
+using Hotline.Exams.Practices;
+using Hotline.Share.Requests.Question;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionSourcewareQueryExtesions
     {
-        public static Expression<Func<PracticeQuestionSourceware,bool>> GetExpression(this QuestionSourcewarePagedRequest questionSourcewarePagedRequest)
+        public static Expression<Func<ExamPracticeQuestionSourceware,bool>> GetExpression(this QuestionSourcewarePagedRequest questionSourcewarePagedRequest)
         {
-            Expression<Func<PracticeQuestionSourceware, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamPracticeQuestionSourceware, bool>> expression = m => m.Id != null;
 
             return expression;
         }

src/Hotline.Application/Exam/QueryExtensions/Questions/QuestionTagQueryExtensions.cs

@@ -1,14 +1,14 @@
-using Exam.Questions;
-using Hotline.Share.Requests.Question;
 using System.Linq.Expressions;
+using Hotline.Exams.Questions;
+using Hotline.Share.Requests.Question;
 
-namespace Exam.Application
+namespace Hotline.Application.Exam.QueryExtensions.Questions
 {
     public static class QuestionTagQueryExtesions
     {
-        public static Expression<Func<QuestionTag,bool>> GetExpression(this QuestionTagPagedRequest questionTagPagedRequest)
+        public static Expression<Func<ExamQuestionTag,bool>> GetExpression(this QuestionTagPagedRequest questionTagPagedRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
             return expression;
         }

src/Hotline.Application/Exam/QueryExtensions/Sourcewares/SourcewareCategoryQueryExtensions.cs

@@ -1,19 +1,18 @@
+using System.Linq.Expressions;
 using Exam.Infrastructure.Extensions;
 using Hotline.Exams.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
-using JiebaNet.Segmenter.Common;
 using SqlSugar;
-using System.Linq.Expressions;
 
-namespace Exam.Application.QueryExtensions.Sourcewares
+namespace Hotline.Application.Exam.QueryExtensions.Sourcewares
 {
     public static class SourcewareCategoryQueryExtesions
     {
-        public static Expression<Func<SourcewareCategory,bool>> GetExpression(this SourcewareCategoryRequest sourcewareCategoryPagedRequest)
+        public static Expression<Func<ExamSourcewareCategory,bool>> GetExpression(this SourcewareCategoryRequest sourcewareCategoryPagedRequest)
         {
-            Expression<Func<SourcewareCategory, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamSourcewareCategory, bool>> expression = m => m.Id != null;
 
-            Expressionable<SourcewareCategory> expressionable = new Expressionable<SourcewareCategory>();
+            Expressionable<ExamSourcewareCategory> expressionable = new Expressionable<ExamSourcewareCategory>();
 
             expressionable.AndIF(sourcewareCategoryPagedRequest.Name.IsNotNullOrEmpty(), x => x.Name.Contains(sourcewareCategoryPagedRequest.Name));
 

src/Hotline.Application/Exam/QueryExtensions/Sourcewares/SourcewareQueryExtensions.cs

@@ -1,20 +1,19 @@
+using System.Linq.Expressions;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
+using Hotline.Application.Exam.Core.Utilities;
 using Hotline.Exams.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
-using SqlSugar;
-using System.Linq.Expressions;
 
-namespace Exam.Application.QueryExtensions.Sourcewares
+namespace Hotline.Application.Exam.QueryExtensions.Sourcewares
 {
     public static class SourcewareQueryExtesions
     {
-        public static Expression<Func<Sourceware, bool>> GetExpression(this SourcewarePagedRequest sourcewarePagedRequest)
+        public static Expression<Func<ExamSourceware, bool>> GetExpression(this SourcewarePagedRequest sourcewarePagedRequest)
         {
-            Expression<Func<Sourceware, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamSourceware, bool>> expression = m => m.Id != null;
 
 
-            expression = ExpressionableUtility.CreateExpression<Sourceware>().AndIF(sourcewarePagedRequest.Name.IsNotNullOrEmpty(), m => m.Name.Contains(sourcewarePagedRequest.Name))
+            expression = ExpressionableUtility.CreateExpression<ExamSourceware>().AndIF(sourcewarePagedRequest.Name.IsNotNullOrEmpty(), m => m.Name.Contains(sourcewarePagedRequest.Name))
            .AndIF(sourcewarePagedRequest.SourcewareType.IsNotNullOrEmpty(), m => m.SourcewareType == sourcewarePagedRequest.SourcewareType)
            .AndIF(sourcewarePagedRequest.SourcewareCategoryId.IsNotNullOrEmpty(), m => m.CategoryId == sourcewarePagedRequest.SourcewareCategoryId)
            .ToExpression();

src/Hotline.Application/Exam/QueryExtensions/TestPapers/TestPaperQueryExtensions.cs

@@ -1,24 +1,25 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
-using Exam.TestPapers;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Share.Enums.Exams;
 using Hotline.Share.Requests.TestPaper;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
+using Hotline.Exams.TestPapers;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
 
 namespace Hotline.Application.Exam.QueryExtensions.TestPapers
 {
     public static class TestPaperQueryExtensions
     {
-        public static Expression<Func<TestPaper,bool>> GetExpression(this TestPaperPagedRequest testPaperPagedRequest)
+        public static Expression<Func<ExamTestPaper,bool>> GetExpression(this TestPaperPagedRequest testPaperPagedRequest)
         {
-            Expression<Func<TestPaper, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaper, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaper>()
+            expression = ExpressionableUtility.CreateExpression<ExamTestPaper>()
                 .AndIF(testPaperPagedRequest.Name.IsNotNullOrEmpty(), x => x.Name.Contains(testPaperPagedRequest.Name))
                 .AndIF(testPaperPagedRequest.Code.IsNotNullOrEmpty(), x => x.Code.Contains(testPaperPagedRequest.Code))
                 .AndIF(testPaperPagedRequest.Status.IsNotNull(), x => x.Status == testPaperPagedRequest.Status)
@@ -29,11 +30,11 @@ namespace Hotline.Application.Exam.QueryExtensions.TestPapers
             return expression;
         }
 
-        public static Expression<Func<TestPaperRule, bool>> GetTestPaperRuleExpression(this EntityQueryRequest entityQueryRequest)
+        public static Expression<Func<ExamTestPaperRule, bool>> GetTestPaperRuleExpression(this EntityQueryRequest entityQueryRequest)
         {
-            Expression<Func<TestPaperRule, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaperRule, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaperRule>()
+            expression = ExpressionableUtility.CreateExpression<ExamTestPaperRule>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TestPaperId))
                 .ToExpression();
@@ -41,66 +42,66 @@ namespace Hotline.Application.Exam.QueryExtensions.TestPapers
             return expression;
         }
 
-        public static Expression<Func<TestPaper,bool>> GetTestPaperCountExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
+        public static Expression<Func<ExamTestPaper,bool>> GetTestPaperCountExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
         {
-            Expression<Func<TestPaper, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaper, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaper>()
+            expression = ExpressionableUtility.CreateExpression<ExamTestPaper>()
                .AndIF(testPaperQuestionCountRequest.TestPaperId.IsNotNullOrEmpty(), x => x.Id == testPaperQuestionCountRequest.TestPaperId)
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<ExtractRule, bool>> GetExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
+        public static Expression<Func<ExamExtractRule, bool>> GetExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
         {
-            Expression<Func<ExtractRule, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamExtractRule, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<ExtractRule>()
+            expression = ExpressionableUtility.CreateExpression<ExamExtractRule>()
                .AndIF(testPaperQuestionCountRequest.ExtractRuleId.IsNotNullOrEmpty(), x => x.Id == testPaperQuestionCountRequest.ExtractRuleId)
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<TestPaperRule,bool>> GetTestPaperRuleExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
+        public static Expression<Func<ExamTestPaperRule,bool>> GetTestPaperRuleExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
         {
-            Expression<Func<TestPaperRule, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaperRule, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaperRule>()
+            expression = ExpressionableUtility.CreateExpression<ExamTestPaperRule>()
                .AndIF(testPaperQuestionCountRequest.TestPaperId.IsNotNullOrEmpty(), x => x.TestPaperId == testPaperQuestionCountRequest.TestPaperId)
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<TestPaperItem,bool>> GetTestPaperItemsExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
+        public static Expression<Func<ExamTestPaperItem,bool>> GetTestPaperItemsExpression(this TestPaperQuestionCountRequest testPaperQuestionCountRequest)
         {
-            Expression<Func<TestPaperItem, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTestPaperItem, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TestPaperItem>()
+            expression = ExpressionableUtility.CreateExpression<ExamTestPaperItem>()
                .AndIF(testPaperQuestionCountRequest.TestPaperId.IsNotNullOrEmpty(), x => x.TestPaperId == testPaperQuestionCountRequest.TestPaperId)
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<QuestionTag,bool>> GetExpression(this TagQuestionCountRequest tagQuestionCountRequest)
+        public static Expression<Func<ExamQuestionTag,bool>> GetExpression(this TagQuestionCountRequest tagQuestionCountRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionTag>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionTag>()
                .AndIF(tagQuestionCountRequest.TagIds.IsNotNullOrEmpty() && tagQuestionCountRequest.TagIds.Any(), x => tagQuestionCountRequest.TagIds.Contains(x.TagId))
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<Question,bool>> GetQuestionExpression(this TagQuestionCountRequest tagQuestionCountRequest)
+        public static Expression<Func<ExamQuestion,bool>> GetQuestionExpression(this TagQuestionCountRequest tagQuestionCountRequest)
         {
-            Expression<Func<Question, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<Question>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestion>()
                .AndIF(tagQuestionCountRequest.QuestionType.IsNotNull(), x => tagQuestionCountRequest.QuestionType ==x.QuestionType)
                .AndIF(tagQuestionCountRequest.DifficultyLevel.IsNotNull(),x=> tagQuestionCountRequest.DifficultyLevel == x.DifficultyLevel)
                .AndIF(tagQuestionCountRequest.QuestionIds.IsNotNullOrEmpty(), x => !tagQuestionCountRequest.QuestionIds.Contains(x.Id))
@@ -109,22 +110,22 @@ namespace Hotline.Application.Exam.QueryExtensions.TestPapers
             return expression;
         }
 
-        public static Expression<Func<QuestionTag, bool>> GetExpression(this TestPaperQuestionRequest testPaperQuestionRequest)
+        public static Expression<Func<ExamQuestionTag, bool>> GetExpression(this TestPaperQuestionRequest testPaperQuestionRequest)
         {
-            Expression<Func<QuestionTag, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionTag, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<QuestionTag>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionTag>()
                .AndIF(testPaperQuestionRequest.TagIds.IsNotNullOrEmpty(), x => testPaperQuestionRequest.TagIds.Contains(x.TagId))
                .ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<Question, bool>> GetQuestionExpression(this TestPaperQuestionRequest testPaperQuestionRequest)
+        public static Expression<Func<ExamQuestion, bool>> GetQuestionExpression(this TestPaperQuestionRequest testPaperQuestionRequest)
         {
-            Expression<Func<Question, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<Question>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestion>()
                .AndIF(testPaperQuestionRequest.QuestionType.IsNotNull(), x => testPaperQuestionRequest.QuestionType == x.QuestionType)
                .AndIF(testPaperQuestionRequest.DifficultyLevel.IsNotNull(), x => testPaperQuestionRequest.DifficultyLevel == x.DifficultyLevel)
                .AndIF(testPaperQuestionRequest.QuestionIds.IsNotNullOrEmpty(), x => !testPaperQuestionRequest.QuestionIds.Contains(x.Id))

src/Hotline.Application/Exam/QueryExtensions/Trains/TrainPlanQueryExtensions.cs

@@ -1,21 +1,20 @@
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Trains;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Exams.Trains;
 using Hotline.Share.Requests.Train;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
 
 namespace Hotline.Application.Exam.QueryExtensions.Trains
 {
     public static class TrainPlanQueryExtensions
     {
-        public static Expression<Func<TrainPlan,bool>> GetExpression(this TrainPlanPagedRequest trainPlanPagedRequest)
+        public static Expression<Func<ExamTrainPlan,bool>> GetExpression(this TrainPlanPagedRequest trainPlanPagedRequest)
         {
-            Expression<Func<TrainPlan, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPlan, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPlan>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPlan>()
                 .AndIF(trainPlanPagedRequest.Code.IsNotNullOrEmpty(), x => x.Code.Contains(trainPlanPagedRequest.Code))
                 .AndIF(trainPlanPagedRequest.Name.IsNotNullOrEmpty(), x => x.Name.Contains(trainPlanPagedRequest.Name))
                 .AndIF(trainPlanPagedRequest.MaxStartTime.IsNotNull(), x => x.TrainStartTime <= trainPlanPagedRequest.MaxStartTime)
@@ -25,11 +24,11 @@ namespace Hotline.Application.Exam.QueryExtensions.Trains
             return expression;
         }
 
-        public static Expression<Func<TrainPlanTemplate,bool>> GetTemplateExpression(this TrainPlanPagedRequest trainPlanPagedRequest)
+        public static Expression<Func<ExamTrainPlanTemplate,bool>> GetTemplateExpression(this TrainPlanPagedRequest trainPlanPagedRequest)
         {
-            Expression<Func<TrainPlanTemplate, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPlanTemplate, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPlanTemplate>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPlanTemplate>()
                 .AndIF(trainPlanPagedRequest.TrainTemplateIds.IsNotNullOrEmpty(), x => trainPlanPagedRequest.TrainTemplateIds.Contains(x.TrainTemplateId))
                 .ToExpression();
 
@@ -37,11 +36,11 @@ namespace Hotline.Application.Exam.QueryExtensions.Trains
         }
 
 
-        public static Expression<Func<TrainPlan, bool>> GetExpression(this TrainResultReportPagedRequest trainResultReportPagedRequest)
+        public static Expression<Func<ExamTrainPlan, bool>> GetExpression(this TrainResultReportPagedRequest trainResultReportPagedRequest)
         {
-            Expression<Func<TrainPlan, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPlan, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPlan>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPlan>()
                 .AndIF(trainResultReportPagedRequest.StartTime.IsNotNull(), x => x.TrainStartTime >= trainResultReportPagedRequest.StartTime)
                 .AndIF(trainResultReportPagedRequest.EndTime.IsNotNull(), x => x.TrainStartTime <= trainResultReportPagedRequest.EndTime)
                 .ToExpression();
@@ -49,11 +48,11 @@ namespace Hotline.Application.Exam.QueryExtensions.Trains
             return expression;
         }
 
-        public static Expression<Func<TrainTemplate, bool>> GetTemplateExpression(this TrainResultReportPagedRequest trainResultReportPagedRequest)
+        public static Expression<Func<ExamTrainTemplate, bool>> GetTemplateExpression(this TrainResultReportPagedRequest trainResultReportPagedRequest)
         {
-            Expression<Func<TrainTemplate, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainTemplate, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainTemplate>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainTemplate>()
                 .AndIF(trainResultReportPagedRequest.Keyword.IsNotNullOrEmpty(), x => x.Name.Contains(trainResultReportPagedRequest.Keyword))
                 .ToExpression();
 

src/Hotline.Application/Exam/QueryExtensions/Trains/TrainRecordQueryExtensions.cs

@@ -1,23 +1,20 @@
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Questions;
-using Exam.TestPapers;
-using Exam.Trains;
 using Hotline.Exams.Trains;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Requests.Train;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
 
 namespace Hotline.Application.Exam.QueryExtensions.Trains
 {
     public static class TrainRecordQueryExtensions
     {
-        public static Expression<Func<TrainPlan,bool>> GetExpression(this TrainRecordPagedRequest trainRecordPagedRequest)
+        public static Expression<Func<ExamTrainPlan,bool>> GetExpression(this TrainRecordPagedRequest trainRecordPagedRequest)
         {
-            Expression<Func<TrainPlan, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPlan, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPlan>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPlan>()
                 .AndIF(trainRecordPagedRequest.Code.IsNotNull(),x=>x.Code.Contains(trainRecordPagedRequest.Code))
                 .AndIF(trainRecordPagedRequest.Name.IsNotNull(),x=>x.Name.Contains(trainRecordPagedRequest.Name))
                 .AndIF(trainRecordPagedRequest.MinStartTime.IsNotNull(),x=>x.TrainStartTime>=trainRecordPagedRequest.MinStartTime)
@@ -29,21 +26,21 @@ namespace Hotline.Application.Exam.QueryExtensions.Trains
             return expression;
         }
 
-        public static Expression<Func<TrainPractice, bool>> GetExpression(this TrainQuestionRequest trainQuestionRequest)
+        public static Expression<Func<ExamTrainPractice, bool>> GetExpression(this TrainQuestionRequest trainQuestionRequest)
         {
-            Expression<Func<TrainPractice, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPractice, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPractice>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPractice>()
                 .AndIF(trainQuestionRequest.QuestionId.IsNotNullOrEmpty(), x => x.QuestionId == trainQuestionRequest.QuestionId).ToExpression();
 
             return expression;
         }
 
-        public static Expression<Func<TrainPractice,bool>> GetExpression(this TrainPracticeRequest trainPracticeRequest)
+        public static Expression<Func<ExamTrainPractice,bool>> GetExpression(this TrainPracticeRequest trainPracticeRequest)
         {
-            Expression<Func<TrainPractice, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainPractice, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPractice>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainPractice>()
                 .AndIF(trainPracticeRequest.TrainPracticeId.IsNotNullOrEmpty(), x => x.Id == trainPracticeRequest.TrainPracticeId).ToExpression();
 
             return expression;

src/Hotline.Application/Exam/QueryExtensions/Trains/TrainTemplateQueryExtensions.cs

@@ -1,20 +1,20 @@
 using DocumentFormat.OpenXml.Presentation;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Utilities;
-using Exam.Trains;
 using Hotline.Share.Requests.Train;
 using JiebaNet.Segmenter.Common;
 using System.Linq.Expressions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.Trains;
 
 namespace Hotline.Application.Exam.QueryExtensions.Trains
 {
     public static class TrainTemplateQueryExtensions
     {
-        public static Expression<Func<TrainTemplate,bool>> GetExpression(this TrainTemplatePagedRequest trainTemplatePagedRequest)
+        public static Expression<Func<ExamTrainTemplate,bool>> GetExpression(this TrainTemplatePagedRequest trainTemplatePagedRequest)
         {
-            Expression<Func<TrainTemplate, bool>> expression = m => m.Id!=null;
+            Expression<Func<ExamTrainTemplate, bool>> expression = m => m.Id!=null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainTemplate>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainTemplate>()
                 .AndIF(trainTemplatePagedRequest.Code.IsNotNullOrEmpty(), x => x.Code.Contains(trainTemplatePagedRequest.Code))
                 .AndIF(trainTemplatePagedRequest.Name.IsNotNullOrEmpty(), x => x.Name.Contains(trainTemplatePagedRequest.Name))
                 .AndIF(trainTemplatePagedRequest.IsContainsPractice.IsNotNull(), x => x.IsContainsPractice == trainTemplatePagedRequest.IsContainsPractice)

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

@@ -1,11 +1,7 @@
-using Exam.ExamManages;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
@@ -31,7 +27,6 @@ using XF.Domain.Authentications;
 using Hotline.Repository.SqlSugar.Exam.Core.Constants;
 using Exam.Repository.Sqlsugar.Repositories.ExamManages;
 using NPOI.SS.Formula.Functions;
-using Exam.TestPapers;
 using Hotline.Exams.TestPapers;
 using Hotline.Application.Exam.Proxy;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.TestPapers;
@@ -41,7 +36,13 @@ using Hotline.Tools;
 using Hotline.Users;
 using System.Buffers;
 using Exam.Repository.Sqlsugar.Repositories.TestPapers;
+using Hotline.Application.Exam.Core.Extensions;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
+using ExamErrorMessage = Hotline.Exams.Validate.ExamErrorMessage;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
@@ -266,10 +267,10 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             await DeleteExamQuestionScores(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<UserExam>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamUserExam>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.ExamId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.ExamId))
-                .ToEntityQueryRequest<UserExam>();
+                .ToEntityQueryRequest<ExamUserExam>();
 
             await DeleteUserExam(tmpEntityQueryRequest, cancellationToken);
 
@@ -309,7 +310,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var examManage = examManages.FirstOrDefault();
             if (examManage != null)
             {
-                var questions = new List<Question>();
+                var questions = new List<ExamQuestion>();
                 if (examManage.Mode == Share.Enums.Exams.EExamMode.Random)
                 {
                     var tagQuestionCounts = await GetTagQuestions(examManage);
@@ -338,9 +339,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
         }
 
-        private async Task<List<Question>> GetQuestions(ExamManage examManage)
+        private async Task<List<ExamQuestion>> GetQuestions(ExamManage examManage)
         {
-            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTable = questionRepository.Queryable();
             var testPaperItemTable = _testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
@@ -351,11 +352,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return await questions.ToListAsync();
         }
 
-        private async Task<List<TagQuestion>> GetTagQuestions(ExamManage examManage)
+        private async Task<List<ExamTagQuestion>> GetTagQuestions(ExamManage examManage)
         {
-            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 extractRuleRepository = new ExamRepository<ExamExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var ruleTagRepository = new ExamRepository<ExamRuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<ExamTagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
           
             var extractRuleTable = extractRuleRepository.Queryable().Where(x=>x.Id == examManage.ExtractRuleId && x.RuleType == examManage.ExamType);
@@ -407,7 +408,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return examQuestionScores;
         }
 
-        private async Task<List<UserExam>> AddUserExam(AddExamManageDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamUserExam>> AddUserExam(AddExamManageDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.UserExamDtos == null) return null;
 
@@ -415,12 +416,12 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var userExamDtos = actionRequest.UserExamDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var userExams = new List<UserExam>();
+            var userExams = new List<ExamUserExam>();
             //_mapper.Map<List<UserExam>>(userExamDtos);
 
             userExamDtos.ForEach(x =>
             {
-                userExams.Add(_mapper.Map<UserExam>(x));
+                userExams.Add(_mapper.Map<ExamUserExam>(x));
             });
 
             userExams.ToInsert(_sessionContext);
@@ -430,7 +431,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return userExams;
 
         }
-        private async Task<List<UserExam>> UpdateUserExam(UpdateExamManageDto actionRequest, List<UserExam> all, CancellationToken cancellationToken)
+        private async Task<List<ExamUserExam>> UpdateUserExam(UpdateExamManageDto actionRequest, List<ExamUserExam> all, CancellationToken cancellationToken)
         {
             if (actionRequest.UserExamDtos == null) return null;
 
@@ -446,7 +447,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 var userExamDto = userExamDtos.FirstOrDefault(x => x.Id == item.Id);
 
                 if (userExamDto != null)
-                    _mapper.Map<UpdateUserExamDto, UserExam>(userExamDto, item);
+                    _mapper.Map<UpdateUserExamDto, ExamUserExam>(userExamDto, item);
             });
 
             userExams.ToUpdate(_sessionContext);
@@ -492,7 +493,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             await _examQuestionScoreRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<UserExam>> ModifyUserExam(UpdateExamManageDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamUserExam>> ModifyUserExam(UpdateExamManageDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.UserExamDtos == null) return null;
 
@@ -500,7 +501,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             actionRequest.UserExamDtos.ResolveOperationStatus(all);
 
-            var userExams = new List<UserExam>();
+            var userExams = new List<ExamUserExam>();
 
             userExams.AddRangeExt(await AddUserExam(_addExamManageDto, cancellationToken));
 
@@ -508,7 +509,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var questionOptionsDtos = actionRequest.UserExamDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = questionOptionsDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<UserExam>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamUserExam>(ids);
 
             await DeleteUserExam(entityQueryRequest, cancellationToken);
 
@@ -582,7 +583,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if(examManage.Mode == Share.Enums.Exams.EExamMode.Random)
             {
-                var tagQuestionRepository = new ExamRepository<TagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+                var tagQuestionRepository = new ExamRepository<ExamTagQuestion>(_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 +598,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
             else
             {
-                var testPaperItemRepository = new ExamRepository<TestPaperItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+                var testPaperItemRepository = new ExamRepository<ExamTestPaperItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
                 var testPaperItemTable = testPaperItemRepository.Queryable().Where(x => x.TestPaperId == examManage.TestPaperId);
 
                 var result = examQuestionScoreDtos.InnerJoin(testPaperItemTable, (e, t) => e.QuestionType == t.QuestionType)
@@ -628,7 +629,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var totalScore = examQuestionScoreDtos.Sum(x => x.Count * x.Score);
             if (totalScore != actionRequest.TotalScore)
             {
-                throw new UserFriendlyException(ErrorMessage.ServiceError, string.Format(ErrorMessage.IsNotEqual, "试题分数总和", typeof(AddExamManageDto).GetDescription(nameof(AddExamManageDto.TotalScore))));
+                throw new UserFriendlyException(ExamErrorMessage.ServiceError, string.Format(ExamErrorMessage.IsNotEqual, "试题分数总和", typeof(AddExamManageDto).GetDescription(nameof(AddExamManageDto.TotalScore))));
             }
         }
 
@@ -660,20 +661,20 @@ namespace Hotline.Application.Exam.Service.ExamManages
         }
 
 
-        private async Task<List<Question>> GetQuestions(List<TagQuestion> tagQuestionCounts)
+        private async Task<List<ExamQuestion>> GetQuestions(List<ExamTagQuestion> tagQuestionCounts)
         {
-            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTable = questionRepository.Queryable();
             var questionTagTable = questionTagRepository.Queryable();
 
             if (tagQuestionCounts != null && tagQuestionCounts.Any())
             {
-                var questionQuerables = new List<ISugarQueryable<Question>>();
+                var questionQuerables = new List<ISugarQueryable<ExamQuestion>>();
                 tagQuestionCounts.ForEach(item =>
                 {
-                    ISugarQueryable<Question> queryable = questionTable.InnerJoin(questionTagTable, (q, t) => t.Id == t.QuestionId)
+                    ISugarQueryable<ExamQuestion> 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);

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

@@ -1,5 +1,4 @@
 using Exam.Application.Interface.Exam;
-using Exam.ExamManages;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Extensions;
 using Exam.Insfrastructure.Service.Service;
@@ -17,6 +16,8 @@ using Hotline.Share.ViewResponses.Exam;
 using Mapster;
 using MapsterMapper;
 using System.ComponentModel;
+using Hotline.Application.Exam.Interface.ExamManages;
+using Hotline.Exams.ExamManages;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 
@@ -102,7 +103,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             if (_repository.CheckHasChild(entityQueryRequest))
             {
-                throw new UserFriendlyException(BusinessErrorMessage.ServiceError,string.Format(BusinessErrorMessage.HasChild, typeof(ExamTag).GetDescription()));
+                throw new UserFriendlyException(BusinessExamErrorMessage.ServiceError,string.Format(BusinessExamErrorMessage.HasChild, typeof(ExamTag).GetDescription()));
             }
 
             return base.DeleteAsync(entityQueryRequest, cancellationToken);

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

@@ -1,17 +1,18 @@
 using DocumentFormat.OpenXml.Office2010.Excel;
 using Exam.Application.Interface.Exam;
-using Exam.ExamManages;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share.ViewResponses.Exam;
+using Hotline.Application.Exam.Core.Extensions;
+using Hotline.Application.Exam.Core.Utilities;
 using Hotline.Application.Exam.Extensions;
+using Hotline.Application.Exam.Interface.ExamManages;
 using Hotline.Application.Exam.QueryExtensions.ExamManages;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Core.Constants;
@@ -27,10 +28,11 @@ using MapsterMapper;
 using SqlSugar;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
-    public class ExtractRuleService : ApiService<ExtractRule, AddExtractRuleDto, UpdateExtractRuleDto, HotlineDbContext>, IExtractRuleService, IScopeDependency
+    public class ExtractRuleService : ApiService<ExamExtractRule, AddExtractRuleDto, UpdateExtractRuleDto, HotlineDbContext>, IExtractRuleService, IScopeDependency
     {
         private readonly IExtractRuleRepository _repository;
         private readonly ITagQuestionRepository _tagQuestionRepository;
@@ -183,15 +185,15 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tempEntityQueryRequest = ExpressionableUtility.CreateExpression<TagQuestion>()
+            var tempEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTagQuestion>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.RuleId == entityQueryRequest.Id)
-                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.RuleId)).ToEntityQueryRequest<TagQuestion>();
+                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.RuleId)).ToEntityQueryRequest<ExamTagQuestion>();
 
             await DeleteTagQuestions(tempEntityQueryRequest, cancellationToken);
 
-            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<RuleTag>()
+            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamRuleTag>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.RuleId == entityQueryRequest.Id)
-                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.RuleId)).ToEntityQueryRequest<RuleTag>();
+                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.RuleId)).ToEntityQueryRequest<ExamRuleTag>();
 
 
             await DeleteRuleTags(tempEntityQueryRequest, cancellationToken);
@@ -207,8 +209,8 @@ namespace Hotline.Application.Exam.Service.ExamManages
             if (tagQuestionRequest.TagIds.IsNullOrEmpty()) return new List<TagQuestionViewResponse>();
 
             var expression = tagQuestionRequest.GetExpression();
-            var questionTagTable = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var questionTable = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTagTable = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
+            var questionTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = questionTagTable.LeftJoin(questionTable, (t, q) => t.QuestionId == q.Id)
                 .GroupBy((t, q) => new { t.TagId, q.QuestionType })
@@ -257,7 +259,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         /// <param name="actionRequest"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        private async Task<List<TagQuestion>> AddTagQuestions(AddExtractRuleDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTagQuestion>> AddTagQuestions(AddExtractRuleDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TagQuestionDtos == null) return null;
 
@@ -265,7 +267,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var tagQuestionDtos = actionRequest.TagQuestionDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var tagQuestions = _mapper.Map<List<TagQuestion>>(tagQuestionDtos);
+            var tagQuestions = _mapper.Map<List<ExamTagQuestion>>(tagQuestionDtos);
 
             tagQuestions.ToInsert(_sessionContext);
 
@@ -280,7 +282,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         /// <param name="actionRequest"></param>
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        private async Task<List<RuleTag>> AddRuleTags(AddExtractRuleDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamRuleTag>> AddRuleTags(AddExtractRuleDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.RuleTagDtos == null) return null;
 
@@ -288,7 +290,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var ruleTagDtos = actionRequest.RuleTagDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var ruleTags = _mapper.Map<List<RuleTag>>(ruleTagDtos);
+            var ruleTags = _mapper.Map<List<ExamRuleTag>>(ruleTagDtos);
 
             ruleTags.ToInsert(_sessionContext);
 
@@ -305,7 +307,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         /// <exception cref="NotImplementedException"></exception>
-        private async Task<List<TagQuestion>> ModifyTagQuestions(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTagQuestion>> ModifyTagQuestions(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TagQuestionDtos == null) return null;
 
@@ -313,12 +315,12 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             //actionRequest.TagQuestionDtos.ResolveOperationStatus(all);
 
-            var entityQueyRequest = ExpressionableUtility.CreateExpression<TagQuestion>()
-               .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.RuleId == actionRequest.Id).ToEntityQueryRequest<TagQuestion>();
+            var entityQueyRequest = ExpressionableUtility.CreateExpression<ExamTagQuestion>()
+               .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.RuleId == actionRequest.Id).ToEntityQueryRequest<ExamTagQuestion>();
 
             await DeleteTagQuestions(entityQueyRequest, cancellationToken);
 
-            var tagQuestions = new List<TagQuestion>();
+            var tagQuestions = new List<ExamTagQuestion>();
 
             tagQuestions.AddRangeExt(await AddTagQuestions(_addExtractRuleDto, cancellationToken));
 
@@ -341,7 +343,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         /// <exception cref="NotImplementedException"></exception>
-        private async Task<List<TagQuestion>> UpdateTagQuestions(UpdateExtractRuleDto actionRequest, List<TagQuestion> all, CancellationToken cancellationToken)
+        private async Task<List<ExamTagQuestion>> UpdateTagQuestions(UpdateExtractRuleDto actionRequest, List<ExamTagQuestion> all, CancellationToken cancellationToken)
         {
             if (actionRequest.TagQuestionDtos == null) return null;
 
@@ -349,7 +351,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var ids = tagQuestionDtos.Select(x => x.Id).ToList();
             var tagQuestions = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            var entitys = new List<TagQuestion>();
+            var entitys = new List<ExamTagQuestion>();
             tagQuestionDtos.ForEach(x =>
             {
                 var entity = tagQuestions.FirstOrDefault(x => x.Id == x.Id);
@@ -376,7 +378,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         /// <param name="cancellationToken"></param>
         /// <returns></returns>
         /// <exception cref="NotImplementedException"></exception>
-        private async Task<List<RuleTag>> ModifyRuleTags(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamRuleTag>> ModifyRuleTags(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
         {
             var ruleId = actionRequest.Id;
 
@@ -386,10 +388,10 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             //actionRequest.RuleTagDtos.ResolveOperationStatus(all);
 
-            var ruleTags = new List<RuleTag>();
+            var ruleTags = new List<ExamRuleTag>();
 
-            var entityQueyRequest = ExpressionableUtility.CreateExpression<RuleTag>()
-                .AndIF(ruleId.IsNotNullOrEmpty(), x => x.RuleId == ruleId).ToEntityQueryRequest<RuleTag>();
+            var entityQueyRequest = ExpressionableUtility.CreateExpression<ExamRuleTag>()
+                .AndIF(ruleId.IsNotNullOrEmpty(), x => x.RuleId == ruleId).ToEntityQueryRequest<ExamRuleTag>();
 
             await DeleteRuleTags(entityQueyRequest, cancellationToken);
 
@@ -405,7 +407,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return ruleTags;
         }
 
-        private async Task<List<RuleTag>> UpdateRuleTags(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamRuleTag>> UpdateRuleTags(UpdateExtractRuleDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.RuleTagDtos == null) return null;
 
@@ -413,7 +415,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var ids = ruleTagDtos.Select(x => x.Id).ToList();
             var ruleTags = await _ruleTagRepository.Queryable().Where(x => ids.Contains(x.Id)).ToListAsync();
 
-            var entitys = new List<RuleTag>();
+            var entitys = new List<ExamRuleTag>();
             ruleTagDtos.ForEach(x =>
             {
                 var entity = ruleTags.FirstOrDefault(x => x.Id == x.Id);

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

@@ -2,20 +2,16 @@
 using DocumentFormat.OpenXml.Drawing.Charts;
 using DocumentFormat.OpenXml.Office2010.Excel;
 using Exam.Application.Interface.Exam;
-using Exam.ExamManages;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Data.Interface;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
 using Exam.Infrastructure.Validation.Validation;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share;
 using Exam.Share.Dtos.ExamManage;
 using Exam.Share.ViewResponses.Exam;
-using Exam.TestPapers;
 using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Application.Exam.Interface.Strategy;
@@ -42,14 +38,21 @@ using NPOI.SS.Formula.Functions;
 using SqlSugar;
 using System.Linq;
 using System.Threading.Tasks;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Application.Exam.Interface.ExamManages;
+using Hotline.Exams.Questions;
+using Hotline.Exams.Validate;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 using XF.Domain.Repository;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using ExamQuestionAnswer = Hotline.Exams.ExamManages.ExamQuestionAnswer;
+using ExamQuestionOptions = Hotline.Exams.ExamManages.ExamQuestionOptions;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
-    public class UserExamService : ApiService<UserExam, AddUserExamDto, UpdateUserExamDto, HotlineDbContext>, IUserExamService, IScopeDependency
+    public class UserExamService : ApiService<ExamUserExam, AddUserExamDto, UpdateUserExamDto, HotlineDbContext>, IUserExamService, IScopeDependency
     {
         private readonly IUserExamRepository _repository;
         private readonly IUserExamItemRepository _userExamItemRepository;
@@ -91,7 +94,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         public async Task<ExamQuestionDto> GetExamQuestionDto(ExamQuestionRequest examQuestionRequest)
         {
             var expression = examQuestionRequest.GetExpression();
-            var quesetion = await new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
+            var quesetion = await new ExamRepository<Exams.ExamManages.ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
 
             if (quesetion != null)
             {
@@ -101,7 +104,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 {
                     var questionOptions = await new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamQuestionId == quesetion.Id).ToListAsync();
 
-                    List<UserExamItemOptions> userItemItemOptions = await GetUserExteamItemOptios(quesetion);
+                    List<ExamUserExamItemOptions> userItemItemOptions = await GetUserExteamItemOptios(quesetion);
 
                     if (questionOptions != null)
                     {
@@ -133,7 +136,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
             else
             {
-                throw new UserFriendlyException(ErrorMessage.ServiceError, string.Format(ErrorMessage.IsNotExists, string.Concat(typeof(Question).GetDescription(), ":", examQuestionRequest.QuestionId)));
+                throw new UserFriendlyException(ExamErrorMessage.ServiceError, string.Format(ExamErrorMessage.IsNotExists, string.Concat(typeof(ExamQuestion).GetDescription(), ":", examQuestionRequest.QuestionId)));
             }
 
         }
@@ -141,7 +144,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         private async Task<List<ExamAnswer>> GetExamAnswers(ExamQuestionRequest examQuestionRequest)
         {
             var examAnswerRepository = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var userExamItemRepository = new ExamRepository<UserExamItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var userExamItemRepository = new ExamRepository<ExamUserExamItem>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var userExamItemTable = userExamItemRepository.Queryable().Where(i=> i.QuestionId == examQuestionRequest.QuestionId);
             var userExamTable = _repository.Queryable().Where(u=> u.UserId == _sessionContext.UserId);
@@ -153,9 +156,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return examAnswers;
         }
 
-        private async Task<List<UserExamItemOptions>> GetUserExteamItemOptios(ExamQuestion quesetion)
+        private async Task<List<ExamUserExamItemOptions>> GetUserExteamItemOptios(Exams.ExamManages.ExamQuestion quesetion)
         {
-            var userExamItemOptionsRepository = new ExamRepository<UserExamItemOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var userExamItemOptionsRepository = new ExamRepository<ExamUserExamItemOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var userExamItemOptionsTable = userExamItemOptionsRepository.Queryable();
             var userExamItemTable = _userExamItemRepository.Queryable();
@@ -176,7 +179,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var expression = examQuestionGroupRequest.GetExpression();
             var examManageTable = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemTable = new ExamRepository<Exams.ExamManages.ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
@@ -199,7 +202,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             var expression = examQuestionGroupRequest.GetExpression();
             var examManageTable = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression);
-            var testPaperItemTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemTable = new ExamRepository<Exams.ExamManages.ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
@@ -225,7 +228,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return result;
         }
 
-        private bool CheckCorrect(ExamQuestion n, List<ExamQuestionScore> examQuestionScores, List<UserExamItem> userExamItems)
+        private bool CheckCorrect(Exams.ExamManages.ExamQuestion n, List<ExamQuestionScore> examQuestionScores, List<ExamUserExamItem> userExamItems)
         {
             var examQuestionScore = examQuestionScores.FirstOrDefault(x => x.QuestionType == n.QuestionType);
             var userItem = userExamItems.FirstOrDefault(x => x.QuestionId == n.QuestionId);
@@ -259,7 +262,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if (userExamItem != null)
             {
-                userExamItem = _mapper.Map<GradingExtamItemDto, UserExamItem>(gradingExtamItemDto, userExamItem);
+                userExamItem = _mapper.Map<GradingExtamItemDto, ExamUserExamItem>(gradingExtamItemDto, userExamItem);
 
                 await _userExamItemRepository.ValidateUpdateAsync(userExamItem, cancellationToken);
             }
@@ -273,7 +276,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if (userExam != null)
             {
-                userExam = _mapper.Map<SubmitExamDto, UserExam>(submitExamDto, userExam);
+                userExam = _mapper.Map<SubmitExamDto, ExamUserExam>(submitExamDto, userExam);
 
                 await _repository.ValidateUpdateAsync(userExam, cancellationToken);
             }
@@ -281,7 +284,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         public async Task<StartExamViewResponse> ExamAsync(UpdateUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
         {
-            var userExam = await new ExamRepository<UserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId).FirstAsync();
+            var userExam = await new ExamRepository<ExamUserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId).FirstAsync();
 
             var startExamViewResponse = await CheckExamValid(userExam);
 
@@ -340,11 +343,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             };
         }
 
-        private async Task<StartExamViewResponse> CheckExamValid(UserExam userExam)
+        private async Task<StartExamViewResponse> CheckExamValid(ExamUserExam examUserExam)
         {
             var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
-            var examManage = await examManageRepository.Queryable().Where(x => x.Id == userExam.ExamId).FirstAsync();
+            var examManage = await examManageRepository.Queryable().Where(x => x.Id == examUserExam.ExamId).FirstAsync();
 
             var startExamViewResponse = new StartExamViewResponse
             {
@@ -358,10 +361,10 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 var examStrategys = new List<IExamStrategy>();
 
-                startExamViewResponse = AddCheckStartTimeStrategy(userExam, examManage, startExamViewResponse, examStrategys);
-                startExamViewResponse = AddCheckEndTimeStrategy(userExam, examManage, startExamViewResponse, examStrategys);
-                startExamViewResponse = AddCheckValidateTimeStrategy(userExam, examManage, startExamViewResponse, examStrategys);
-                startExamViewResponse = AddCheckValidateCountStrategy(userExam, examManage, startExamViewResponse, examStrategys);
+                startExamViewResponse = AddCheckStartTimeStrategy(examUserExam, examManage, startExamViewResponse, examStrategys);
+                startExamViewResponse = AddCheckEndTimeStrategy(examUserExam, examManage, startExamViewResponse, examStrategys);
+                startExamViewResponse = AddCheckValidateTimeStrategy(examUserExam, examManage, startExamViewResponse, examStrategys);
+                startExamViewResponse = AddCheckValidateCountStrategy(examUserExam, examManage, startExamViewResponse, examStrategys);
 
                 if (!examStrategyProxy.Validate())
                 {
@@ -374,7 +377,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return startExamViewResponse;
         }
 
-        private StartExamViewResponse AddCheckValidateCountStrategy(UserExam userExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
+        private StartExamViewResponse AddCheckValidateCountStrategy(ExamUserExam examUserExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
         {
             if (examManage.ExamType == Share.Enums.Exams.EExamType.Simulate)
             {
@@ -395,7 +398,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             }
             else
             {
-                var count = new ExamRepository<UserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).CountAsync(x => x.ExamId == examManage.Id && x.UserId == userExam.UserId).Result;
+                var count = new ExamRepository<ExamUserExam>(_uow, _dataPermissionFilterBuilder, _serviceProvider).CountAsync(x => x.ExamId == examManage.Id && x.UserId == examUserExam.UserId).Result;
 
                 var checkStartTime = new CheckValidateCountStrategy(examManage.Count, count)
                 {
@@ -415,11 +418,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         }
 
-        private StartExamViewResponse AddCheckValidateTimeStrategy(UserExam userExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
+        private StartExamViewResponse AddCheckValidateTimeStrategy(ExamUserExam examUserExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
         {
             if (examManage.ExamType == Share.Enums.Exams.EExamType.Simulate) return startExamViewResponse;
 
-            var checkStartTime = new CheckValidateTimeStrategy(examManage.TimeSpan, userExam.StartTime)
+            var checkStartTime = new CheckValidateTimeStrategy(examManage.TimeSpan, examUserExam.StartTime)
             {
                 CallBack = () =>
                 {
@@ -435,7 +438,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return startExamViewResponse;
         }
 
-        private StartExamViewResponse AddCheckEndTimeStrategy(UserExam userExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
+        private StartExamViewResponse AddCheckEndTimeStrategy(ExamUserExam examUserExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
         {
             if (examManage.ExamType == Share.Enums.Exams.EExamType.Simulate) return startExamViewResponse;
 
@@ -455,11 +458,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return startExamViewResponse;
         }
 
-        private static StartExamViewResponse AddCheckStartTimeStrategy(UserExam userExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
+        private static StartExamViewResponse AddCheckStartTimeStrategy(ExamUserExam examUserExam, ExamManage examManage, StartExamViewResponse startExamViewResponse, List<IExamStrategy> examStrategys)
         {
             if (examManage.ExamType == Share.Enums.Exams.EExamType.Simulate) return startExamViewResponse;
 
-            var checkStartTime = new CheckStartTimeStrategy(examManage.StartTime, userExam.StartTime)
+            var checkStartTime = new CheckStartTimeStrategy(examManage.StartTime, examUserExam.StartTime)
             {
                 CallBack = () =>
                 {
@@ -509,7 +512,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var userExamItemTable = _userExamItemRepository.Queryable();
             var userExamItemOptionTable = _userExamItemOptionRepository.Queryable();
             var examAnswerTable = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var questionTable = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTable = new ExamRepository<Exams.ExamManages.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();
@@ -646,7 +649,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             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 testPaperItemRepository = new ExamRepository<Exams.ExamManages.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();
@@ -669,7 +672,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             await userExamRepository.UpdateWithValidateAsync(userExamItem, cancellationToken);
         }
 
-        private async Task AddExamAsync(IRepository<UserExamItem> userExamItemRepository, AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
+        private async Task AddExamAsync(IRepository<ExamUserExamItem> userExamItemRepository, AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
         {
             var userExamItem = await AddUserExamItem(addUserExamItemDto, cancellationToken);
 
@@ -683,7 +686,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 .ExecuteCommandAsync();
         }
 
-        private async Task UpdateExamAsync(IRepository<UserExamItem> userExamItemRepository, UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
+        private async Task UpdateExamAsync(IRepository<ExamUserExamItem> userExamItemRepository, UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
         {
             var userExamItem = await UpdateUserExamItem(updateUserExamItemDto, cancellationToken);
 
@@ -706,13 +709,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             if (userExamItem != null)
             {
-                var testPaperItem = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.Id == userExamItem.Id && !x.QuestionType.CheckSelectType()).First();
+                var testPaperItem = new ExamRepository<Exams.ExamManages.ExamQuestion>(_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<ExamQuestion, GradingExamQuestionDto>(testPaperItem, gradingExamQuestionDto);
+                gradingExamQuestionDto = _mapper.Map<Exams.ExamManages.ExamQuestion, GradingExamQuestionDto>(testPaperItem, gradingExamQuestionDto);
 
                 var examAnswer = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
 
@@ -753,7 +756,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
         private async Task<UserExamQuestionDto> GetNextExamQuestion(AddUserExamItemDto addUserExamItemDto)
         {
             // TODO: 获取未阅卷的第一道题
-            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<Exams.ExamManages.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);
@@ -774,7 +777,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 var userExamQuestionDto = new UserExamQuestionDto();
 
-                userExamQuestionDto = _mapper.Map<ExamQuestion, UserExamQuestionDto>(question, userExamQuestionDto);
+                userExamQuestionDto = _mapper.Map<Exams.ExamManages.ExamQuestion, UserExamQuestionDto>(question, userExamQuestionDto);
 
                 if (question.QuestionType.CheckSelectType())
                 {
@@ -854,14 +857,14 @@ namespace Hotline.Application.Exam.Service.ExamManages
         }
 
 
-        private async Task<List<UserExamItemOptions>> ModifyUserItemOptions(UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
+        private async Task<List<ExamUserExamItemOptions>> ModifyUserItemOptions(UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
         {
             if (updateUserExamItemDto.QuestionType.CheckSelectType())
             {
 
                 var entityQuestionRequest = new EntityQueryRequest
                 {
-                    Expression = ExpressionableUtility.CreateExpression<UserExamItemOptions>()
+                    Expression = ExpressionableUtility.CreateExpression<ExamUserExamItemOptions>()
               .AndIF(updateUserExamItemDto.Id.IsNotEmpty(), x => x.UserExamItemId == updateUserExamItemDto.Id).ToExpression()
                 };
 
@@ -892,7 +895,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 var userExamItemOptions = await _userExamItemOptionRepository.Queryable().Where(x => x.UserExamItemId == updateUserExamItemDto.Id).ToListAsync();
 
-                var entities = new List<UserExamItemOptions>();
+                var entities = new List<ExamUserExamItemOptions>();
 
                 if (updateUserExamItemDto.UserExamItemOptionDtos != null)
                 {
@@ -901,7 +904,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                         var entity = userExamItemOptions.FirstOrDefault(m => m.Id == x.Id);
                         if (entity != null)
                         {
-                            entities.Add(_mapper.Map<UpdateUserExamItemOptionDto, UserExamItemOptions>(x, entity));
+                            entities.Add(_mapper.Map<UpdateUserExamItemOptionDto, ExamUserExamItemOptions>(x, entity));
                         }
 
                     });
@@ -915,11 +918,11 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         }
 
-        private async Task<UserExamItem> UpdateUserExamItem(UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
+        private async Task<ExamUserExamItem> UpdateUserExamItem(UpdateUserExamItemDto updateUserExamItemDto, CancellationToken cancellationToken)
         {
             var userExamItem = await _userExamItemRepository.GetAsync(x => x.UserExamId == updateUserExamItemDto.UserExamId && x.QuestionId == updateUserExamItemDto.QuestionId);
 
-            userExamItem = _mapper.Map<UpdateUserExamItemDto, UserExamItem>(updateUserExamItemDto, userExamItem);
+            userExamItem = _mapper.Map<UpdateUserExamItemDto, ExamUserExamItem>(updateUserExamItemDto, userExamItem);
 
             updateUserExamItemDto.Id = userExamItem.Id;
 
@@ -939,9 +942,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
         }
 
 
-        private async Task<List<UserExamItemOptions>> AddUserExamItemOptions(AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
+        private async Task<List<ExamUserExamItemOptions>> AddUserExamItemOptions(AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
         {
-            var userExamItemOptions = new List<UserExamItemOptions>();
+            var userExamItemOptions = new List<ExamUserExamItemOptions>();
 
             if (addUserExamItemDto.QuestionType.CheckSelectType())
             {
@@ -949,7 +952,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
                 {
                     addUserExamItemDto.UserExamItemOptionDtos.ToList().ForEach(x =>
                     {
-                        userExamItemOptions.Add(_mapper.Map<UserExamItemOptions>(x));
+                        userExamItemOptions.Add(_mapper.Map<ExamUserExamItemOptions>(x));
                     });
                 }
             }
@@ -961,9 +964,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return userExamItemOptions;
         }
 
-        private async Task<UserExamItem> AddUserExamItem(AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
+        private async Task<ExamUserExamItem> AddUserExamItem(AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
         {
-            var userExamItem = _mapper.Map<UserExamItem>(addUserExamItemDto);
+            var userExamItem = _mapper.Map<ExamUserExamItem>(addUserExamItemDto);
 
             userExamItem.ToInsert(_sessionContext);
 

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

@@ -1,17 +1,11 @@
-using Exam.Application.Interface.Practices;
-using Exam.ExamManages;
-using Exam.Infrastructure.Data.Entity;
+using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Data.Interface;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Practices;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
 using Exam.Share.ViewResponses.Practices;
-using Exam.TestPapers;
-using Exam.Trains;
 using Hotline.Application.Exam.Core.Constants;
 using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Core.Utilities;
@@ -40,12 +34,14 @@ using NPOI.OpenXmlFormats.Dml;
 using NPOI.SS.Formula.Functions;
 using SqlSugar;
 using System.Linq;
+using Hotline.Application.Exam.Interface.Practices;
+using Hotline.Exams.Questions;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
 
 namespace Hotline.Application.Exam.Service.Practices
 {
-    public class PracticeService : ApiService<Practice, AddPracticeDto, UpdatePracticeDto, HotlineDbContext>, IPracticeService, IScopeDependency
+    public class PracticeService : ApiService<ExamPractice, AddPracticeDto, UpdatePracticeDto, HotlineDbContext>, IPracticeService, IScopeDependency
     {
         private readonly IPracticeRepository _repository;
         private readonly IPracticeRecordRepository _practiceRecordRepository;
@@ -122,7 +118,7 @@ namespace Hotline.Application.Exam.Service.Practices
         {
             var questions = await ExactractQuestion(actionRequest);
             base.StartTran();
-            actionRequest.Code = await GenerateCode(BusiConstants.PracticeCode,3);
+            actionRequest.Code = await GenerateCode(ExamBusiConstants.PracticeCode,3);
             var id = await base.AddAsync(actionRequest, cancellationToken);
             var addPracticeQuestionDtos = new List<AddPracticeQuestionDto>();
             questions.ForEach(item =>
@@ -135,7 +131,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
             var practiceRecord = await AddPracticeRecord(id, cancellationToken);
 
-            base.Entity.PracticeRecords = new List<PracticeRecord>();
+            base.Entity.PracticeRecords = new List<ExamPracticeRecord>();
                 base.Entity.PracticeRecords.Add(practiceRecord); 
 
             base.Entity.PracticeQuestions = await AddPracticeQuestions(addPracticeQuestionDtos, cancellationToken);
@@ -264,7 +260,7 @@ namespace Hotline.Application.Exam.Service.Practices
             return await QueryPracticeQuestion(practiceQuestionRequest);
         }
 
-        private async Task<PracticeResult> AddPracticeResult(SubmitPracticeDto submitPracticeDto, CancellationToken cancellationToken)
+        private async Task<ExamPracticeResult> AddPracticeResult(SubmitPracticeDto submitPracticeDto, CancellationToken cancellationToken)
         {
             var practiceQuetionOptions = await _practiceQuestionOptionsRepository.Queryable().Where(x => x.PracticeQuestionId == submitPracticeDto.PracticeQuestionId && x.IsAnswer).ToListAsync();
 
@@ -275,7 +271,7 @@ namespace Hotline.Application.Exam.Service.Practices
                                 .Select((p, q) => p.Id).FirstAsync();
 
 
-            var practiceResult = new PracticeResult
+            var practiceResult = new ExamPracticeResult
             {
                 PracticeRecordId = practiceRecordId,
                 PracticeQuestionId = submitPracticeDto.PracticeQuestionId,
@@ -305,15 +301,15 @@ namespace Hotline.Application.Exam.Service.Practices
 
         #region private method
 
-        private async Task<List<PracticeResultItem>> AddPracticeResultItem(SubmitPracticeDto submitPracticeDto, CancellationToken cancellationToken)
+        private async Task<List<ExamPracticeResultItem>> AddPracticeResultItem(SubmitPracticeDto submitPracticeDto, CancellationToken cancellationToken)
         {
             if (submitPracticeDto.PracticeResultItemDtos == null) return null;
 
-            var practiceResultItems = new List<PracticeResultItem>();
+            var practiceResultItems = new List<ExamPracticeResultItem>();
 
             submitPracticeDto.PracticeResultItemDtos.ForEach(item =>
             {
-                var practiceResultItem = _mapper.Map<PracticeResultItem>(item);
+                var practiceResultItem = _mapper.Map<ExamPracticeResultItem>(item);
                 practiceResultItem.PracticeResultId = submitPracticeDto.PracticeResultId;
                 practiceResultItem.ToInsert(_sessionContext);
                 practiceResultItems.Add(practiceResultItem);
@@ -347,13 +343,13 @@ namespace Hotline.Application.Exam.Service.Practices
             return practiceQuestionDto;
         }
 
-        private async Task<List<PracticeResultItem>> GetPracticeResultItems(PracticeQuestionRequest practiceQuestionRequest)
+        private async Task<List<ExamPracticeResultItem>> GetPracticeResultItems(PracticeQuestionRequest practiceQuestionRequest)
         {
-            var practiceRecordRepository = new ExamRepository<PracticeRecord>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var practiceRecordRepository = new ExamRepository<ExamPracticeRecord>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var practiceRecordTable = practiceRecordRepository.Queryable().Where(x=>x.UserId == _sessionContext.UserId);
 
-            var practiceResultItems = practiceRecordTable.InnerJoin<PracticeResult>((p, r) => p.Id == r.PracticeRecordId)
-                                      .InnerJoin<PracticeResultItem>((p, r, i) => i.PracticeResultId == r.Id)
+            var practiceResultItems = practiceRecordTable.InnerJoin<ExamPracticeResult>((p, r) => p.Id == r.PracticeRecordId)
+                                      .InnerJoin<ExamPracticeResultItem>((p, r, i) => i.PracticeResultId == r.Id)
                                       .Where((p, r, i) => r.PracticeQuestionId == practiceQuestionRequest.PracticeQuestionId)
                                       .Select((p, r, i) => i);
 
@@ -384,7 +380,7 @@ namespace Hotline.Application.Exam.Service.Practices
         private async Task<List<PracticeQuestionSourcewareDto>> GetPracticeQuestionSourceware(PracticeQuestionRequest practiceQuestionRequest)
         {
 
-            var sourcewareRepository = new ExamRepository<Sourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var sourcewareRepository = new ExamRepository<ExamSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = practiceQuestionRequest.GetExpression();
             var practiceQuestionTable = _practiceQuestionRepository.Queryable().Where(expression);
@@ -438,15 +434,15 @@ namespace Hotline.Application.Exam.Service.Practices
             return queryResult;
         }
 
-        private async Task<List<PracticeQuestionSourceware>> AddPracticeQuestionSourcewareAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
+        private async Task<List<ExamPracticeQuestionSourceware>> AddPracticeQuestionSourcewareAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<ExamQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
             var questionSourceware = await questionSourcewareRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var practiceQuestionSourcewares = new List<PracticeQuestionSourceware>();
+            var practiceQuestionSourcewares = new List<ExamPracticeQuestionSourceware>();
 
             practiceQuestionDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -458,7 +454,7 @@ namespace Hotline.Application.Exam.Service.Practices
                 {
                     options.ForEach(item =>
                     {
-                        var practiceQuestionSourceware = _mapper.Map<QuestionSourceware, PracticeQuestionSourceware>(item);
+                        var practiceQuestionSourceware = _mapper.Map<ExamQuestionSourceware, ExamPracticeQuestionSourceware>(item);
 
                         practiceQuestionSourceware.PracticeQuestionId = practiceQuestion?.Id;
 
@@ -474,15 +470,15 @@ namespace Hotline.Application.Exam.Service.Practices
             return practiceQuestionSourcewares;
         }
 
-        private async Task<List<PracticeQuestionKnowladge>> AddPracticeQuestionKnowladgeAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
+        private async Task<List<ExamPracticeQuestionKnowladge>> AddPracticeQuestionKnowladgeAsync(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<ExamQuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
             var questionKnowladge = await questionKnowladgeRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var practiceQuestionKnowladges = new List<PracticeQuestionKnowladge>();
+            var practiceQuestionKnowladges = new List<ExamPracticeQuestionKnowladge>();
 
             practiceQuestionDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -493,7 +489,7 @@ namespace Hotline.Application.Exam.Service.Practices
                 {
                     options.ForEach(item =>
                     {
-                        var practiceQuestionKnowladge = _mapper.Map<QuestionKnowladge, PracticeQuestionKnowladge>(item);
+                        var practiceQuestionKnowladge = _mapper.Map<ExamQuestionKnowladge, ExamPracticeQuestionKnowladge>(item);
 
                         practiceQuestionKnowladge.PracticeQuestionId = practiceQuestion?.Id;
 
@@ -509,15 +505,15 @@ namespace Hotline.Application.Exam.Service.Practices
             return practiceQuestionKnowladges;
         }
 
-        private async Task<List<PracticeQuestionOptions>> AddPracticeQuestionOptions(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
+        private async Task<List<ExamPracticeQuestionOptions>> AddPracticeQuestionOptions(List<AddPracticeQuestionDto> practiceQuestionDtos, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = practiceQuestionDtos.Select(x => x.QuestionId);
 
             var questionOptions = await questionOptionRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var practiceQuestionOptions = new List<PracticeQuestionOptions>();
+            var practiceQuestionOptions = new List<ExamPracticeQuestionOptions>();
 
             practiceQuestionDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -528,7 +524,7 @@ namespace Hotline.Application.Exam.Service.Practices
                 {
                     options.ForEach(item =>
                     {
-                        var practiceQuestionOption = _mapper.Map<QuestionOptions, PracticeQuestionOptions>(item);
+                        var practiceQuestionOption = _mapper.Map<ExamQuestionOptions, ExamPracticeQuestionOptions>(item);
 
                         practiceQuestionOption.PracticeQuestionId = practiceQuestion?.Id;
 
@@ -547,15 +543,15 @@ namespace Hotline.Application.Exam.Service.Practices
             return practiceQuestionOptions;
         }
 
-        private async Task<List<PracticeQuestion>> AddPracticeQuestions(List<AddPracticeQuestionDto> addPracticeQuestionDtos, CancellationToken cancellationToken)
+        private async Task<List<ExamPracticeQuestion>> AddPracticeQuestions(List<AddPracticeQuestionDto> addPracticeQuestionDtos, CancellationToken cancellationToken)
         {
-            var practiceQuestions = new List<PracticeQuestion>();
+            var practiceQuestions = new List<ExamPracticeQuestion>();
 
             var sortIndex = 0;
 
             addPracticeQuestionDtos.ForEach(item =>
             {
-                var practiceQuestion = _mapper.Map<PracticeQuestion>(item);
+                var practiceQuestion = _mapper.Map<ExamPracticeQuestion>(item);
                 practiceQuestion.SortIndex = sortIndex;
                 practiceQuestions.Add(practiceQuestion);
                 sortIndex++;
@@ -569,7 +565,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         }
 
-        private async Task<PracticeRecord> AddPracticeRecord(string practiceId, CancellationToken cancellationToken)
+        private async Task<ExamPracticeRecord> AddPracticeRecord(string practiceId, CancellationToken cancellationToken)
         {
             var practiceRecordDto = new PracticeRecordDto
             {
@@ -578,7 +574,7 @@ namespace Hotline.Application.Exam.Service.Practices
                 PracticeTime = DateTime.Now
             };
 
-            var practiceRecord = _mapper.Map<PracticeRecord>(practiceRecordDto);
+            var practiceRecord = _mapper.Map<ExamPracticeRecord>(practiceRecordDto);
 
             practiceRecord.ToInsert(_sessionContext);
 
@@ -587,14 +583,14 @@ namespace Hotline.Application.Exam.Service.Practices
             return practiceRecord;
         }
 
-        private async Task<List<Question>> ExactractQuestion(AddPracticeDto actionRequest)
+        private async Task<List<ExamQuestion>> ExactractQuestion(AddPracticeDto actionRequest)
         {
-            if (actionRequest.PracticeTagDtos == null) return new List<Question>();
+            if (actionRequest.PracticeTagDtos == null) return new List<ExamQuestion>();
 
             var tagIds = actionRequest.PracticeTagDtos.Select(x => x.TagId).ToList();
 
-            var questionTagRepostiory = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepostiory = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var questionTagTable = questionTagRepostiory.Queryable();
             var questionTable = questionRepository.Queryable();
@@ -606,7 +602,7 @@ namespace Hotline.Application.Exam.Service.Practices
             }
             else
             {
-                var unionQuestions = new List<ISugarQueryable<QuestionTag>>();
+                var unionQuestions = new List<ISugarQueryable<ExamQuestionTag>>();
                 var ids = new List<string>();
                 // 保证每个标签至少获取一道题
                 tagIds.ForEach(v =>
@@ -651,7 +647,7 @@ namespace Hotline.Application.Exam.Service.Practices
 
         #region protect method
 
-        protected override async Task CompleteAdd(Practice entity)
+        protected override async Task CompleteAdd(ExamPractice entity)
         {
             await base.AddNav(entity).Include(x => x.PracticeRecords)
                   .Include(x => x.PracticeQuestions)
@@ -673,8 +669,8 @@ namespace Hotline.Application.Exam.Service.Practices
             var expression = tagQuestionCountForPracticeRequest.GetExpression();
             var questionExpression = tagQuestionCountForPracticeRequest.GetQuestionExpression();
 
-            var tagQuestionRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var quesitonRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var quesitonRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var tagQuestionTable = tagQuestionRepository.Queryable().Where(expression);
             var questionTable = quesitonRepository.Queryable().Where(questionExpression);

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

@@ -1,14 +1,9 @@
 using DocumentFormat.OpenXml.Office2010.Excel;
 using Exam.Application;
-using Exam.Application.Interface.Questions;
-using Exam.ExamManages;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share.ViewResponses.Question;
 using Hotline.Application.Exam.QueryExtensions.Questions;
@@ -38,11 +33,20 @@ using System.Threading.Tasks;
 using Hotline.Share.Enums.Exams;
 using Hotline.Share.Tools;
 using DocumentFormat.OpenXml.Drawing;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Application.Exam.Interface.Questions;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
 using Hotline.Share.Dtos.TestPapers;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using ExamQuestionAnswer = Hotline.Exams.Questions.ExamQuestionAnswer;
+using ExamQuestionKnowladge = Hotline.Exams.Questions.ExamQuestionKnowladge;
+using ExamQuestionOptions = Hotline.Exams.Questions.ExamQuestionOptions;
+using ExamQuestionSourceware = Hotline.Exams.Questions.ExamQuestionSourceware;
 
 namespace Hotline.Application.Exam.Service.Questions
 {
-    public class QuestionService : ApiService<Question, AddQuestionDto,UpdateQuestionDto, HotlineDbContext>, IQuestionService, IScopeDependency
+    public class QuestionService : ApiService<ExamQuestion, AddQuestionDto,UpdateQuestionDto, HotlineDbContext>, IQuestionService, IScopeDependency
     {
         #region ctor
         private readonly IQuestionRepository _repository;
@@ -110,7 +114,7 @@ namespace Hotline.Application.Exam.Service.Questions
             var questionTable = _repository.Queryable().Where(expression);
 
             var questionKnowladgeExpression = queryRequest.GetQuestionKnowladgeExpression();
-            var questionKnowladgeTable = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(questionKnowladgeExpression);
+            var questionKnowladgeTable = new ExamRepository<ExamQuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(questionKnowladgeExpression);
 
             var queryable = questionTable.InnerJoin(questionKnowladgeTable, (q, k) => q.Id == k.QuestionId).Select((q, k) => new QuestionViewResponse
             {
@@ -133,7 +137,7 @@ namespace Hotline.Application.Exam.Service.Questions
             var questionTable = _repository.Queryable().Where(expression);
 
             var questionTagExpression = queryRequest.GetQuestionTagExpression();
-            var questionTagRepository = new BaseRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new BaseRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var examTagRepository = new BaseRepository<ExamTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionTagTable = questionTagRepository.Queryable().Where(questionTagExpression);
 
@@ -225,38 +229,38 @@ namespace Hotline.Application.Exam.Service.Questions
         {
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<QuestionTag>()
+            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionTag>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.QuestionId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.QuestionId))
-                .ToEntityQueryRequest<QuestionTag>();
+                .ToEntityQueryRequest<ExamQuestionTag>();
 
             await DeleteQuestionTags(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<QuestionOptions>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionOptions>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.QuestionId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.QuestionId))
-                .ToEntityQueryRequest<QuestionOptions>();
+                .ToEntityQueryRequest<ExamQuestionOptions>();
 
             await DeleteQuestionOptions(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<QuestionAnswer>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionAnswer>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.QuestionId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.QuestionId))
-                .ToEntityQueryRequest<QuestionAnswer>();
+                .ToEntityQueryRequest<ExamQuestionAnswer>();
 
             await DeleteQuestionAnswer(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<QuestionKnowladge>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionKnowladge>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.QuestionId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.QuestionId))
-                .ToEntityQueryRequest<QuestionKnowladge>();
+                .ToEntityQueryRequest<ExamQuestionKnowladge>();
 
             await DeleteKnowladges(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<QuestionSourceware>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionSourceware>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.QuestionId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.QuestionId))
-                .ToEntityQueryRequest<QuestionSourceware>();
+                .ToEntityQueryRequest<ExamQuestionSourceware>();
 
             await DeleteSourcewares(tmpEntityQueryRequest, cancellationToken);
         }
@@ -267,7 +271,7 @@ namespace Hotline.Application.Exam.Service.Questions
             {
                 var contents = ExcelHelper.Read(stream, true);
 
-                var questions = new List<Question>();
+                var questions = new List<ExamQuestion>();
                 var examTags = await GetExamTags(contents);
 
                 base.StartTran();
@@ -297,7 +301,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             contents.ForEach(item =>
             {
-                var tagNameStr = ((ExpandoObject)item).GetValueOrDefault(SystemConstants.ColumnNames[1])?.ToString();
+                var tagNameStr = ((ExpandoObject)item).GetValueOrDefault(ExamSystemConstants.ColumnNames[1])?.ToString();
 
                 if (tagNameStr.IsNotNullOrEmpty())
                 {
@@ -328,16 +332,16 @@ namespace Hotline.Application.Exam.Service.Questions
 
                 ResolveOptions(options,item,6,15);
 
-                var answer = item.GetValueOrDefault(SystemConstants.ColumnNames[16]).ToString();
+                var answer = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[16]).ToString();
 
                 var questionDto = new AddQuestionDto
                 {
-                    Title = item.GetValueOrDefault(SystemConstants.ColumnNames[2]) != null ? item.GetValueOrDefault(SystemConstants.ColumnNames[5]).ToString() : string.Empty,
-                    QuestionTagDtos = BuildQuestionTags(item.GetValueOrDefault(SystemConstants.ColumnNames[1]).ToString(), examTags),
-                    DifficultyLevel = item.GetValueOrDefault(SystemConstants.ColumnNames[2]).ToString().ToEnumByDesc<EDifficultyLevel>(),
-                    QuestionType = item.GetValueOrDefault(SystemConstants.ColumnNames[0]).ToString().ToEnumByDesc<EQuestionType>(),
-                    FormalEnable = item.GetValueOrDefault(SystemConstants.ColumnNames[4]).ToString().ToEnumByDesc<ECheck>() == ECheck.Yes,
-                    SimulateEnable = item.GetValueOrDefault(SystemConstants.ColumnNames[5]).ToString().ToEnumByDesc<ECheck>() == ECheck.Yes,                   
+                    Title = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[2]) != null ? item.GetValueOrDefault(ExamSystemConstants.ColumnNames[5]).ToString() : string.Empty,
+                    QuestionTagDtos = BuildQuestionTags(item.GetValueOrDefault(ExamSystemConstants.ColumnNames[1]).ToString(), examTags),
+                    DifficultyLevel = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[2]).ToString().ToEnumByDesc<EDifficultyLevel>(),
+                    QuestionType = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[0]).ToString().ToEnumByDesc<EQuestionType>(),
+                    FormalEnable = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[4]).ToString().ToEnumByDesc<ECheck>() == ECheck.Yes,
+                    SimulateEnable = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[5]).ToString().ToEnumByDesc<ECheck>() == ECheck.Yes,                   
                 };
                 questionDto.QuestionAnswerDto = BuildQuestionAnswer(answer, questionDto.QuestionType);
 
@@ -363,8 +367,8 @@ namespace Hotline.Application.Exam.Service.Questions
                     var addQuestionOption = new AddQuestionOptionsDto
                     {
                         Content = item,
-                        Label = SystemConstants.Labels[index],
-                        IsAnswer = answer.Contains(SystemConstants.Labels[index])
+                        Label = ExamSystemConstants.Labels[index],
+                        IsAnswer = answer.Contains(ExamSystemConstants.Labels[index])
                     };
 
                     addQuestionOptionDtos.Add(addQuestionOption);
@@ -381,7 +385,7 @@ namespace Hotline.Application.Exam.Service.Questions
         {
             for(int i = start; i <= end; i++)
             {
-                var option = item.GetValueOrDefault(SystemConstants.ColumnNames[i])?.ToString();
+                var option = item.GetValueOrDefault(ExamSystemConstants.ColumnNames[i])?.ToString();
                 if (option.IsNotNullOrEmpty())
                 {
                     options.Add(option.ToString());
@@ -465,7 +469,7 @@ namespace Hotline.Application.Exam.Service.Questions
             }
         }
 
-        private async Task<List<QuestionTag>> AddQuestionTags(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionTag>> AddQuestionTags(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionTagDtos == null) return null;
 
@@ -473,7 +477,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionTagDtos = actionRequest.QuestionTagDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var questionTags = _mapper.Map<List<QuestionTag>>(questionTagDtos);
+            var questionTags = _mapper.Map<List<ExamQuestionTag>>(questionTagDtos);
 
             questionTags.ToInsert(_sessionContext);
 
@@ -482,7 +486,7 @@ namespace Hotline.Application.Exam.Service.Questions
             return questionTags;
         }
 
-        private async Task<List<QuestionOptions>> AddQuestionOptions(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionOptions>> AddQuestionOptions(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionOptionsDtos == null) return null;
 
@@ -494,13 +498,13 @@ namespace Hotline.Application.Exam.Service.Questions
             var questionOptionseDtos = actionRequest.QuestionOptionsDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
             
-            var questionOptionses = _mapper.Map<List<QuestionOptions>>(questionOptionseDtos);
+            var questionOptionses = _mapper.Map<List<ExamQuestionOptions>>(questionOptionseDtos);
 
             var sortIndex = 0;
             questionOptionses.ForEach(m =>
             {
                 m.SortIndex = sortIndex;
-                m.Label = SystemConstants.Labels[sortIndex];
+                m.Label = ExamSystemConstants.Labels[sortIndex];
                 sortIndex++;
             });
 
@@ -510,7 +514,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionOptionses;
         }
-        private async Task<List<QuestionAnswer>> AddQuestionAnswer(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionAnswer>> AddQuestionAnswer(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionAnswerDto == null) return null;
 
@@ -521,9 +525,9 @@ namespace Hotline.Application.Exam.Service.Questions
 
             // 简答和填空没有选项
             if (actionRequest.QuestionType.CheckSelectType()) return null;
-            var questionAnswer = _mapper.Map<QuestionAnswer>(actionRequest.QuestionAnswerDto);
+            var questionAnswer = _mapper.Map<ExamQuestionAnswer>(actionRequest.QuestionAnswerDto);
 
-            var questionAnswers = new List<QuestionAnswer>();
+            var questionAnswers = new List<ExamQuestionAnswer>();
 
             questionAnswer.ToInsert(_sessionContext);
 
@@ -533,7 +537,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionAnswers;
         }
-        private async Task<List<QuestionSourceware>> AddSourcewares(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionSourceware>> AddSourcewares(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionSourcewareDtos == null) return null;
 
@@ -541,7 +545,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionSourcewareDtos = actionRequest.QuestionSourcewareDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var questionSourcewares = _mapper.Map<List<QuestionSourceware>>(questionSourcewareDtos);
+            var questionSourcewares = _mapper.Map<List<ExamQuestionSourceware>>(questionSourcewareDtos);
                         
             questionSourcewares.ToInsert(_sessionContext);
 
@@ -549,7 +553,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionSourcewares;
         }
-        private async Task<List<QuestionKnowladge>> AddKnowladges(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionKnowladge>> AddKnowladges(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionKnowladgeDtos == null) return null;
 
@@ -557,7 +561,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionKnoladgeDtos = actionRequest.QuestionKnowladgeDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var questionKnowladges = _mapper.Map<List<QuestionKnowladge>>(questionKnoladgeDtos);
+            var questionKnowladges = _mapper.Map<List<ExamQuestionKnowladge>>(questionKnoladgeDtos);
 
             questionKnowladges.ToInsert(_sessionContext);
 
@@ -565,7 +569,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionKnowladges;
         }
-        private async Task<List<QuestionSourceware>> UpdateSourcewares(UpdateQuestionDto actionRequest, List<QuestionSourceware> all, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionSourceware>> UpdateSourcewares(UpdateQuestionDto actionRequest, List<ExamQuestionSourceware> all, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionSourcewareDtos == null) return null;
 
@@ -577,14 +581,14 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionSourcewares = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            var entitys = new List<QuestionSourceware>();
+            var entitys = new List<ExamQuestionSourceware>();
             foreach (var questionSourcewareDto in questionSourcewareDtos)
             {
                 var entity = questionSourcewares.FirstOrDefault(x => x.Id == questionSourcewareDto.Id);
                 if (entity != null)
                 {
                     entity.QuestionId = actionRequest.Id;
-                    entitys.Add(_mapper.Map<UpdateQuestionSourcewareDto, QuestionSourceware>(questionSourcewareDto, entity));
+                    entitys.Add(_mapper.Map<UpdateQuestionSourcewareDto, ExamQuestionSourceware>(questionSourcewareDto, entity));
                 }
 
             }
@@ -600,7 +604,7 @@ namespace Hotline.Application.Exam.Service.Questions
             return questionSourcewares;
         }
 
-        private async Task<List<QuestionKnowladge>> UpdateKnowladges(UpdateQuestionDto actionRequest, List<QuestionKnowladge> all, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionKnowladge>> UpdateKnowladges(UpdateQuestionDto actionRequest, List<ExamQuestionKnowladge> all, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionKnowladgeDtos == null) return null;
 
@@ -612,14 +616,14 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionKnowladges = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            var entitys = new List<QuestionKnowladge>();
+            var entitys = new List<ExamQuestionKnowladge>();
             foreach (var questionKnowladgeDto in questionKnowladgeDtos)
             {
                 var entity = questionKnowladges.FirstOrDefault(x => x.Id == questionKnowladgeDto.Id);
                 if (entity != null)
                 {
                     entity.QuestionId = actionRequest.Id;
-                    entitys.Add(_mapper.Map<UpdateQuestionKnowladgeDto, QuestionKnowladge>(questionKnowladgeDto, entity));
+                    entitys.Add(_mapper.Map<UpdateQuestionKnowladgeDto, ExamQuestionKnowladge>(questionKnowladgeDto, entity));
                 }
                
             }
@@ -635,7 +639,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionKnowladges;
         }
-        private async Task<QuestionAnswer> UpdateQuestionAnswer(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<ExamQuestionAnswer> UpdateQuestionAnswer(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionAnswerDto == null) return null;
 
@@ -644,7 +648,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionAnswer = await _questionAnswerRepository.GetAsync(actionRequest.QuestionAnswerDto.Id);
 
-           questionAnswer = _mapper.Map<UpdateQuestionAnswerDto, QuestionAnswer>(actionRequest.QuestionAnswerDto, questionAnswer);
+           questionAnswer = _mapper.Map<UpdateQuestionAnswerDto, ExamQuestionAnswer>(actionRequest.QuestionAnswerDto, questionAnswer);
 
             questionAnswer.QuestionId = actionRequest.Id;            
 
@@ -654,7 +658,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             return questionAnswer;
         }
-        private async Task<List<QuestionOptions>> UpdateQuestionOptions(UpdateQuestionDto actionRequest,List<QuestionOptions> all, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionOptions>> UpdateQuestionOptions(UpdateQuestionDto actionRequest,List<ExamQuestionOptions> all, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionOptionsDtos == null) return null;
 
@@ -668,14 +672,14 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionOptionses = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            var entitys = new List<QuestionOptions>();
+            var entitys = new List<ExamQuestionOptions>();
             foreach(var questionOptionsDto in questionOptionsDtos)
             {
                 var entity = questionOptionses.FirstOrDefault(x => x.Id == questionOptionsDto.Id);
                 if (entity != null)
                 {
                     entity.QuestionId = actionRequest.Id;
-                    entitys.Add(_mapper.Map<UpdateQuestionOptionsDto, QuestionOptions>(questionOptionsDto, entity));
+                    entitys.Add(_mapper.Map<UpdateQuestionOptionsDto, ExamQuestionOptions>(questionOptionsDto, entity));
                 }               
             }
 
@@ -690,7 +694,7 @@ namespace Hotline.Application.Exam.Service.Questions
             return entitys;
         }
 
-        private async Task<List<QuestionTag>> UpdateQuestionTags(UpdateQuestionDto actionRequest,List<QuestionTag> all, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionTag>> UpdateQuestionTags(UpdateQuestionDto actionRequest,List<ExamQuestionTag> all, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionTagDtos == null) return null;
 
@@ -700,14 +704,14 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionTags = all.Where(x => ids.Contains(x.Id)).ToList();
 
-            var entitys = new List<QuestionTag>();
+            var entitys = new List<ExamQuestionTag>();
             foreach (var questionOptionsDto in questionTagDtos)
             {
                 var entity = questionTags.FirstOrDefault(x => x.Id == questionOptionsDto.Id);
                 if (entity != null)
                 {
                     entity.QuestionId = actionRequest.Id;
-                    entitys.Add(_mapper.Map<UpdateQuestionTagDto, QuestionTag>(questionOptionsDto, entity));
+                    entitys.Add(_mapper.Map<UpdateQuestionTagDto, ExamQuestionTag>(questionOptionsDto, entity));
                 }
                 
             }
@@ -739,13 +743,13 @@ namespace Hotline.Application.Exam.Service.Questions
         {
             await _questionTagRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
-        private async Task<List<QuestionSourceware>> ModifySourcewares(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionSourceware>> ModifySourcewares(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             var all = await _questionSourcewareRepository.Queryable().Where(x => x.QuestionId == actionRequest.Id).ToListAsync();
 
             if (actionRequest.QuestionSourcewareDtos == null) return null;
 
-            var questionSourcewares = new List<QuestionSourceware>();
+            var questionSourcewares = new List<ExamQuestionSourceware>();
 
             actionRequest.QuestionSourcewareDtos.ResolveOperationStatus(all);
 
@@ -755,20 +759,20 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionSourcewareDtos = actionRequest.QuestionSourcewareDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = questionSourcewareDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<QuestionSourceware>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionSourceware>(ids);
 
             await DeleteSourcewares(entityQueryRequest, cancellationToken);
 
             return questionSourcewares;
         }
 
-        private async Task<List<QuestionKnowladge>> ModifyKnowladges(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionKnowladge>> ModifyKnowladges(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             var all = await _questionKnowladgeRepository.Queryable().Where(x => x.QuestionId == actionRequest.Id).ToListAsync();
 
             if (actionRequest.QuestionKnowladgeDtos == null) return null;
 
-            var questionKnowladges = new List<QuestionKnowladge>();
+            var questionKnowladges = new List<ExamQuestionKnowladge>();
 
             actionRequest.QuestionKnowladgeDtos.ResolveOperationStatus(all);
 
@@ -778,18 +782,18 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionKnowladgeDtos = actionRequest.QuestionKnowladgeDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = questionKnowladgeDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<QuestionKnowladge>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionKnowladge>(ids);
 
             await DeleteKnowladges(entityQueryRequest, cancellationToken);
 
             return questionKnowladges;
         }
 
-        private async Task<List<QuestionAnswer>> ModifyQuestionAnswer(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionAnswer>> ModifyQuestionAnswer(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             var all = await _questionAnswerRepository.Queryable().Where(x => x.QuestionId == actionRequest.Id).ToListAsync();
 
-            var questionAnswers = new List<QuestionAnswer>();
+            var questionAnswers = new List<ExamQuestionAnswer>();
 
             if (actionRequest.QuestionAnswerDto == null)
             {
@@ -800,7 +804,7 @@ namespace Hotline.Application.Exam.Service.Questions
                     var ids = all.Select(m => m.Id).ToList();
                     var entityQueryRequest = new EntityQueryRequest
                     {
-                        Expression = ExpressionableUtility.CreateExpression<QuestionAnswer>()
+                        Expression = ExpressionableUtility.CreateExpression<ExamQuestionAnswer>()
                         .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id)).ToExpression()
                     };
 
@@ -846,11 +850,11 @@ namespace Hotline.Application.Exam.Service.Questions
 
         }
 
-        private async Task<List<QuestionOptions>> ModifyQuestionOptions(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionOptions>> ModifyQuestionOptions(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionOptionsDtos == null) return null;
 
-            var questionOptions = new List<QuestionOptions>();
+            var questionOptions = new List<ExamQuestionOptions>();
 
             var all = await _questionOptionRepository.Queryable().Where(x=>x.QuestionId == actionRequest.Id).ToListAsync();
 
@@ -864,18 +868,18 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionOptionsDtos = actionRequest.QuestionOptionsDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = questionOptionsDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<QuestionOptions>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionOptions>(ids);
 
             await DeleteQuestionOptions(entityQueryRequest, cancellationToken);
 
             return questionOptions;
         }
 
-        private async Task<List<QuestionTag>> ModifyQuestionTags(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionTag>> ModifyQuestionTags(UpdateQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.QuestionTagDtos == null) return null;
 
-            var questionTags = new List<QuestionTag>();
+            var questionTags = new List<ExamQuestionTag>();
 
             var all = await _questionTagRepository.Queryable().Where(x => x.QuestionId == actionRequest.Id).ToListAsync();
 
@@ -887,7 +891,7 @@ namespace Hotline.Application.Exam.Service.Questions
 
             var questionTagDtos = actionRequest.QuestionTagDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = questionTagDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<QuestionTag>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionTag>(ids);
 
             await DeleteQuestionTags(entityQueryRequest, cancellationToken);
 
@@ -910,7 +914,7 @@ namespace Hotline.Application.Exam.Service.Questions
         {
             var questionSourcewareTable = _questionSourcewareRepository.Queryable().Where(x => x.QuestionId == entityQueryRequest.Id);
 
-            var sourcewareTable = new ExamRepository<Sourceware>(_questionSourcewareRepository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var sourcewareTable = new ExamRepository<ExamSourceware>(_questionSourcewareRepository.UOW, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var questionSourcewares = questionSourcewareTable.InnerJoin(sourcewareTable, (q, s) =>
               q.SourcewareId == s.Id).Select((q, s) => new QuestionSourcewareDto
@@ -967,7 +971,7 @@ namespace Hotline.Application.Exam.Service.Questions
             return await questionTagDtos.ToListAsync();
         }
 
-        private async Task<Question> AddQuestion(AddQuestionDto actionRequest, CancellationToken cancellationToken)
+        private async Task<ExamQuestion> AddQuestion(AddQuestionDto actionRequest, CancellationToken cancellationToken)
         {
             var id = await base.AddAsync(actionRequest, cancellationToken);
 

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

@@ -1,28 +1,28 @@
-using Exam.Application.QueryExtensions.Sourcewares;
+using System.ComponentModel;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Extensions;
 using Exam.Insfrastructure.Service.Service;
 using Exam.Share.ViewResponses.Sourceware;
 using Hotline.Application.Exam.Constants.Messages;
 using Hotline.Application.Exam.Extensions;
+using Hotline.Application.Exam.Interface.Sourcewares;
+using Hotline.Application.Exam.QueryExtensions.Sourcewares;
 using Hotline.Exams.Sourcewares;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Sourcewares;
 using Hotline.Share.Dtos.Sourcewares;
 using Hotline.Share.Requests.Sourceware;
-using Mapster;
 using MapsterMapper;
-using System.ComponentModel;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 
-namespace Exam.Application.Service.Sourcewares
+namespace Hotline.Application.Exam.Service.Sourcewares
 {
     /// <summary>
     /// 课件类型服务
     /// </summary>
     [Description("课件类型服务")]
-    public class SourcewareCategoryService : ApiService<SourcewareCategory, AddSourcewareCategoryDto,UpdateSourcewareCategoryDto,HotlineDbContext>,ISourcewareCategoryService, IScopeDependency
+    public class SourcewareCategoryService : ApiService<ExamSourcewareCategory, AddSourcewareCategoryDto,UpdateSourcewareCategoryDto,HotlineDbContext>,ISourcewareCategoryService, IScopeDependency
     {
         private readonly ISourcewareCategoryRepository _repository;
         private readonly IMapper _mapper;
@@ -98,7 +98,7 @@ namespace Exam.Application.Service.Sourcewares
 
             if (_repository.CheckHasChild(entityQueryRequest))
             {
-                throw new UserFriendlyException(BusinessErrorMessage.ServiceError, string.Format(BusinessErrorMessage.HasChild,typeof(SourcewareCategory).GetDescription()));
+                throw new UserFriendlyException(BusinessExamErrorMessage.ServiceError, string.Format(BusinessExamErrorMessage.HasChild,typeof(ExamSourcewareCategory).GetDescription()));
             }
 
             return base.DeleteAsync(entityQueryRequest, cancellationToken);

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

@@ -1,6 +1,4 @@
 using Exam.Application;
-using Exam.Application.Interface.Sourcewares;
-using Exam.Application.QueryExtensions.Sourcewares;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Data.Interface;
 using Exam.Infrastructure.Extensions;
@@ -17,6 +15,8 @@ using Mapster;
 using MapsterMapper;
 using SqlSugar;
 using System.ComponentModel;
+using Hotline.Application.Exam.Interface.Sourcewares;
+using Hotline.Application.Exam.QueryExtensions.Sourcewares;
 using XF.Domain.Dependency;
 
 namespace Hotline.Application.Exam.Service.Sourcewares
@@ -25,7 +25,7 @@ namespace Hotline.Application.Exam.Service.Sourcewares
     /// 课件服务
     /// </summary>
     [Description("课件服务")]
-    public class SourcewareService : ApiService<Sourceware, AddSourcewareDto,UpdateSourcewareDto,HotlineDbContext>,ISourcewareService, IScopeDependency
+    public class SourcewareService : ApiService<ExamSourceware, AddSourcewareDto,UpdateSourcewareDto,HotlineDbContext>,ISourcewareService, IScopeDependency
     {
         private readonly ISourcewareRepository _repository;
         private readonly IDataPermissionFilterBuilder _datePermissionFilterBuilder;
@@ -109,7 +109,7 @@ namespace Hotline.Application.Exam.Service.Sourcewares
         /// <returns></returns>
         private async Task SetDefaultCategory(AddSourcewareDto actionRequest)
         {
-            var category = await new BaseRepository<SourcewareCategory>(_uow, _datePermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.Name == InfrastructureConstant.NoCategory);
+            var category = await new BaseRepository<ExamSourcewareCategory>(_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>(_uow, _datePermissionFilterBuilder, _serviceProvider).Queryable();
+            var sourcewareCategoryTable = new BaseRepository<ExamSourcewareCategory>(_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

@@ -1,19 +1,13 @@
 using DocumentFormat.OpenXml.Office2010.Excel;
-using Exam.Application.Interface.TestPapers;
-using Exam.ExamManages;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Data.Interface;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Repository.Sqlsugar.Repositories.TestPapers;
 using Exam.Share.ViewResponses.TestPaper;
-using Exam.TestPapers;
 using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Extensions;
 using Hotline.Application.Exam.Proxy;
@@ -40,13 +34,22 @@ using Microsoft.Extensions.DependencyInjection;
 using NPOI.SS.Formula.Functions;
 using SqlSugar;
 using System.Collections.Immutable;
+using Hotline.Application.Exam.Core.Utilities;
+using Hotline.Application.Exam.Interface.TestPapers;
+using Hotline.Exams.ExamManages;
+using Hotline.Exams.Questions;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
 using XF.Domain.Repository;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using ExamQuestionAnswer = Hotline.Exams.Questions.ExamQuestionAnswer;
+using ExamQuestionKnowladge = Hotline.Exams.Questions.ExamQuestionKnowladge;
+using ExamQuestionOptions = Hotline.Exams.Questions.ExamQuestionOptions;
+using ExamQuestionSourceware = Hotline.Exams.Questions.ExamQuestionSourceware;
 
 namespace Hotline.Application.Exam.Service.TestPapers
 {
-    public class TestPaperService : ApiService<TestPaper, AddTestPaperDto, UpdateTestPaperDto, HotlineDbContext>, ITestPaperService, IScopeDependency
+    public class TestPaperService : ApiService<ExamTestPaper, AddTestPaperDto, UpdateTestPaperDto, HotlineDbContext>, ITestPaperService, IScopeDependency
     {
         private readonly ITestPaperRepository _repository;
         private readonly ITestPaperItemRepository _testPaperItemRepository;
@@ -233,23 +236,23 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tempEntityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperItem>()
+            var tempEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperItem>()
                .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == entityQueryRequest.Id)
-               .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TestPaperId)).ToEntityQueryRequest<TestPaperItem>();
+               .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TestPaperId)).ToEntityQueryRequest<ExamTestPaperItem>();
 
             await DeleteTestPaperItems(tempEntityQueryRequest, cancellationToken);
 
-            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperRule>()
+            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperRule>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == entityQueryRequest.Id)
-                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TestPaperId)).ToEntityQueryRequest<TestPaperRule>();
+                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TestPaperId)).ToEntityQueryRequest<ExamTestPaperRule>();
 
 
             await DeleteTestPaperRules(tempEntityQueryRequest, cancellationToken);
 
 
             var ids = testPaperRuleTags.Select(x => x.Id).ToList();
-            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperRuleTag>()
-                .AndIF(ids.IsNotNull(), x => ids.Contains(x.Id)).ToEntityQueryRequest<TestPaperRuleTag>();
+            tempEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperRuleTag>()
+                .AndIF(ids.IsNotNull(), x => ids.Contains(x.Id)).ToEntityQueryRequest<ExamTestPaperRuleTag>();
 
             await DeleteTestPaperRuleTags(tempEntityQueryRequest, cancellationToken);
         }
@@ -328,8 +331,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         private async Task<List<SimpleQuestionViewResponse>> GetQuestions(TestPaperQuestionRequest testPaperQuestionRequest)
         {
-            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = testPaperQuestionRequest.GetExpression();
             var questionExpression = testPaperQuestionRequest.GetQuestionExpression();
@@ -353,10 +356,10 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return questionDtos;
         }
 
-        private async Task<List<Question>> GetQuestions(GenerateTestPaperRequest generateTestPaperRequest)
+        private async Task<List<ExamQuestion>> GetQuestions(GenerateTestPaperRequest generateTestPaperRequest)
         {
-            var questionRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var questionTagRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionTagRepository = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var testPaperRuleTable = _testPaperRuleRepository.Queryable().Where(x => x.TestPaperId == generateTestPaperRequest.TestPaperId);
             var testPaperTagTable = _testPaperRuleTagRepository.Queryable();
             var questionTagTable = questionTagRepository.Queryable();
@@ -386,8 +389,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
             var expression = tagQuestionCountRequest.GetExpression();
             var questionExpression = tagQuestionCountRequest.GetQuestionExpression();
 
-            var tagQuestionRepository = new ExamRepository<QuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var quesitonRepository = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<ExamQuestionTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var quesitonRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var tagQuestionTable = tagQuestionRepository.Queryable().Where(expression);
             var questionTable = quesitonRepository.Queryable().Where(questionExpression);
@@ -432,7 +435,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
         }
 
 
-        private async Task<List<TestPaperItemOptions>> ModifyTestPaperItemOptions(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemOptions>> ModifyTestPaperItemOptions(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -440,7 +443,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var entityQueryRequest = new EntityQueryRequest
             {
-                Expression = ExpressionableUtility.CreateExpression<TestPaperItemOptions>()
+                Expression = ExpressionableUtility.CreateExpression<ExamTestPaperItemOptions>()
                              .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
             };
 
@@ -455,7 +458,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperItemOptionsRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperItemAnswer>> ModifyTestPaperItemAnswer(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemAnswer>> ModifyTestPaperItemAnswer(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -463,7 +466,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var entityQueryRequest = new EntityQueryRequest
             {
-                Expression = ExpressionableUtility.CreateExpression<TestPaperItemAnswer>()
+                Expression = ExpressionableUtility.CreateExpression<ExamTestPaperItemAnswer>()
                              .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
             };
 
@@ -477,7 +480,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperItemAnswerRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperRule>> AddTestPaperRules(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRule>> AddTestPaperRules(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -486,7 +489,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             actionRequest.TestPaperRuleDtos.ResolveOperationStatus();
 
             var testPaperRuleDtos = actionRequest.TestPaperRuleDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
-            var testPaperRules = _mapper.Map<List<TestPaperRule>>(testPaperRuleDtos);
+            var testPaperRules = _mapper.Map<List<ExamTestPaperRule>>(testPaperRuleDtos);
 
             testPaperRules.ToInsert(_sessionContext);
 
@@ -497,14 +500,14 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         }
 
-        private async Task<List<TestPaperItem>> AddTestPaperItems(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItem>> AddTestPaperItems(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
             actionRequest.TestPaperItemDtos.ResolveOperationStatus();
 
             var testPaperItemDtos = actionRequest.TestPaperItemDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
-            var testPaperItems = _mapper.Map<List<TestPaperItem>>(testPaperItemDtos);
+            var testPaperItems = _mapper.Map<List<ExamTestPaperItem>>(testPaperItemDtos);
             //试题排序，为后续考试顺序出题做准备
             var index = 0;
             testPaperItems.ForEach(x =>
@@ -521,7 +524,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
         }
 
 
-        private async Task<List<TestPaperRuleTag>> AddTestPaperRuleTags(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRuleTag>> AddTestPaperRuleTags(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -553,7 +556,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             testPaperRuleTagDtos.ResolveOperationStatus();
 
-            var testPaperRuleTags = _mapper.Map<List<TestPaperRuleTag>>(testPaperRuleTagDtos);
+            var testPaperRuleTags = _mapper.Map<List<ExamTestPaperRuleTag>>(testPaperRuleTagDtos);
 
             testPaperRuleTags.ToInsert(_sessionContext);
 
@@ -562,7 +565,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return testPaperRuleTags;
         }
 
-        private async Task<List<TestPaperRule>> ModifyTestPaperRules(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRule>> ModifyTestPaperRules(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -572,14 +575,14 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             actionRequest.TestPaperRuleDtos.ResolveOperationStatus(all);
 
-            var testPaperRules = new List<TestPaperRule>();
+            var testPaperRules = new List<ExamTestPaperRule>();
 
             testPaperRules.AddRangeExt(await AddTestPaperRules(actionRequest, cancellationToken));
 
             testPaperRules.AddRangeExt(await UpdateTestPaperRules(actionRequest,all, cancellationToken));
 
-            var entityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperRule>()
-                .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == actionRequest.Id).ToEntityQueryRequest<TestPaperRule>();
+            var entityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperRule>()
+                .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == actionRequest.Id).ToEntityQueryRequest<ExamTestPaperRule>();
 
             await DeleteTestPaperRules(entityQueryRequest, cancellationToken);
 
@@ -591,7 +594,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperRuleRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperRule>> UpdateTestPaperRules(UpdateTestPaperDto actionRequest,List<TestPaperRule> all, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRule>> UpdateTestPaperRules(UpdateTestPaperDto actionRequest,List<ExamTestPaperRule> all, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -601,7 +604,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var testPaperRules = all.Where(x => ids.Contains(x.TestPaperId)).ToList();
 
-            var entities = new List<TestPaperRule>();
+            var entities = new List<ExamTestPaperRule>();
 
             foreach (var testPaperRuleDto in testPaperRuleDtos)
             {
@@ -620,7 +623,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
         }
 
-        private async Task<List<TestPaperRuleTag>> ModifyTestPaperRuleTags(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRuleTag>> ModifyTestPaperRuleTags(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -630,7 +633,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             actionRequest.TestPaperRuleDtos.ResolveOperationStatus(all);
 
-            var testPaperRuleTags = new List<TestPaperRuleTag>();
+            var testPaperRuleTags = new List<ExamTestPaperRuleTag>();
 
             testPaperRuleTags.AddRangeExt(await AddTestPaperRuleTags(actionRequest, cancellationToken));
 
@@ -638,8 +641,8 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var ids = actionRequest.TestPaperRuleDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete).Select(x => x.Id).ToList();
 
-            var entityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperRuleTag>()
-                .AndIF(ids.IsNullOrEmpty(), x => ids.Contains(x.TestPaperRuleId)).ToEntityQueryRequest<TestPaperRuleTag>();
+            var entityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperRuleTag>()
+                .AndIF(ids.IsNullOrEmpty(), x => ids.Contains(x.TestPaperRuleId)).ToEntityQueryRequest<ExamTestPaperRuleTag>();
 
             await DeleteTestPaperRuleTags(entityQueryRequest, cancellationToken);
 
@@ -651,7 +654,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperRuleTagRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperRuleTag>> UpdateTestPaperRuleTags(UpdateTestPaperDto actionRequest,List<TestPaperRuleTag> all, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperRuleTag>> UpdateTestPaperRuleTags(UpdateTestPaperDto actionRequest,List<ExamTestPaperRuleTag> all, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperRuleDtos == null) return null;
 
@@ -659,13 +662,13 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var testPaperRuleTags = all.Where(x => ruleIds.Contains(x.TestPaperRuleId)).ToList();
 
-            var entities = new List<TestPaperRuleTag>();
+            var entities = new List<ExamTestPaperRuleTag>();
 
             foreach (var testPaperRuleTagDto in actionRequest.TestPaperRuleDtos.SelectMany(x=>x.TestPaperRuleTagDtos))
             {
                 var entity = testPaperRuleTags.FirstOrDefault(x => x.Id == testPaperRuleTagDto.Id);
 
-                entity = _mapper.Map<UpdateTestPaperRuleTagDto, TestPaperRuleTag>(testPaperRuleTagDto,entity);
+                entity = _mapper.Map<UpdateTestPaperRuleTagDto, ExamTestPaperRuleTag>(testPaperRuleTagDto,entity);
             }
 
             entities.ToUpdate(_sessionContext);
@@ -675,7 +678,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return entities;
         }
 
-        private async Task<List<TestPaperItem>> ModifyTestPaperItems(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItem>> ModifyTestPaperItems(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -683,14 +686,14 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             actionRequest.TestPaperItemDtos.ResolveOperationStatus(all);
 
-            var testPaperItems = new List<TestPaperItem>();
+            var testPaperItems = new List<ExamTestPaperItem>();
 
             testPaperItems.AddRangeExt(await AddTestPaperItems(_addTestPaperDto, cancellationToken));
 
             testPaperItems.AddRangeExt(await UpdateTestPaperItems(actionRequest,all, cancellationToken));
 
-            var entityQueryRequest = ExpressionableUtility.CreateExpression<TestPaperItem>()
-                .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == actionRequest.Id).ToEntityQueryRequest<TestPaperItem>();
+            var entityQueryRequest = ExpressionableUtility.CreateExpression<ExamTestPaperItem>()
+                .AndIF(actionRequest.Id.IsNotNullOrEmpty(), x => x.TestPaperId == actionRequest.Id).ToEntityQueryRequest<ExamTestPaperItem>();
 
             await DeleteTestPaperItems(entityQueryRequest, cancellationToken);
 
@@ -702,7 +705,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperItemRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperItem>> UpdateTestPaperItems(UpdateTestPaperDto actionRequest,List<TestPaperItem> all, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItem>> UpdateTestPaperItems(UpdateTestPaperDto actionRequest,List<ExamTestPaperItem> all, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -712,7 +715,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var testPaperItems = all.Where(x => ids.Contains(x.TestPaperId)).ToList();
 
-            var entities = new List<TestPaperItem>();
+            var entities = new List<ExamTestPaperItem>();
 
             foreach (var testPaperItemDto in testPaperItemDtos)
             {
@@ -799,7 +802,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             actionRequest.TestPaperItemDtos?.ForEach(x => x.TestPaperId = id);
         }
 
-        private async Task<List<TestPaperRuleTag>> GetTestPaperRuleTags(EntityQueryRequest entityQueryRequest)
+        private async Task<List<ExamTestPaperRuleTag>> GetTestPaperRuleTags(EntityQueryRequest entityQueryRequest)
         {
             var expression = entityQueryRequest.GetTestPaperRuleExpression();
             var testPageRuleTable = _testPaperRuleRepository.Queryable().Where(expression);
@@ -813,9 +816,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>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var ruleTagRepository = new ExamRepository<RuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var tagQuestionRepository = new ExamRepository<TagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var extractRuleRepository = new ExamRepository<ExamExtractRule>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var ruleTagRepository = new ExamRepository<ExamRuleTag>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var tagQuestionRepository = new ExamRepository<ExamTagQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
 
             var expression = testPaperQuestionCountRequest.GetExpression();
@@ -827,7 +830,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             var testPaperRules = await exatractTable.InnerJoin(ruleTagTable,(e,rt)=>e.Id == rt.RuleId)
                 .InnerJoin(tagQuestionTable,(e,rt,tq)=>rt.RuleId == tq.RuleId && rt.TagId == tq.TagId)
                 .GroupBy((e, rt, tq)=> tq.QuestionType)
-                .Select((e,rt,tq)=> new TagQuestion
+                .Select((e,rt,tq)=> new ExamTagQuestion
                 {
                     QuestionType = tq.QuestionType,
                     Count = SqlFunc.AggregateSum(tq.Count)
@@ -866,15 +869,15 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
 
 
-        private async Task<List<TestPaperItemOptions>> AddTestPaperItemOptions(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemOptions>> AddTestPaperItemOptions(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 
             var questionOptions = await questionOptionRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemOptions = new List<TestPaperItemOptions>();
+            var testPaperItemOptions = new List<ExamTestPaperItemOptions>();
 
             actionRequest.TestPaperItemDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -886,7 +889,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
                 {
                     options.ForEach(item =>
                     {
-                        var testPaperItemOption = _mapper.Map<QuestionOptions, TestPaperItemOptions>(item);
+                        var testPaperItemOption = _mapper.Map<ExamQuestionOptions, ExamTestPaperItemOptions>(item);
 
                         testPaperItemOption.TestPaperItemId = testPaperItem?.Id;
 
@@ -905,15 +908,15 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return testPaperItemOptions;
         }
 
-        private async Task<List<TestPaperItemAnswer>> AddTestPaperItemAnswer(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemAnswer>> AddTestPaperItemAnswer(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos?.Select(x => x.QuestionId);            
 
             var questionAnswer = await questionOptionRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemAnswers = new List<TestPaperItemAnswer>();
+            var testPaperItemAnswers = new List<ExamTestPaperItemAnswer>();
 
             actionRequest.TestPaperItemDtos.Where(x => !x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -923,7 +926,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
                 options.ForEach(item =>
                 {
-                    var testPaperItemAnswer = _mapper.Map<QuestionAnswer, TestPaperItemAnswer>(item);
+                    var testPaperItemAnswer = _mapper.Map<ExamQuestionAnswer, ExamTestPaperItemAnswer>(item);
 
                     testPaperItemAnswer.TestPaperItemId = testPaperItem?.Id;
 
@@ -943,15 +946,15 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
 
 
-        private async Task<List<TestPaperItemSourceware>> AddTestPaperItemSourcewareAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemSourceware>> AddTestPaperItemSourcewareAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<ExamQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 
             var questionSourceware = await questionSourcewareRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemSourcewares = new List<TestPaperItemSourceware>();
+            var testPaperItemSourcewares = new List<ExamTestPaperItemSourceware>();
 
             actionRequest.TestPaperItemDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -963,7 +966,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
                 {
                     options.ForEach(item =>
                     {
-                        var testPaperItemSourceware = _mapper.Map<QuestionSourceware, TestPaperItemSourceware>(item);
+                        var testPaperItemSourceware = _mapper.Map<ExamQuestionSourceware, ExamTestPaperItemSourceware>(item);
 
                         testPaperItemSourceware.TestPaperItemId = testPaperItem?.Id;
 
@@ -979,15 +982,15 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return testPaperItemSourcewares;
         }
 
-        private async Task<List<TestPaperItemKnowladge>> AddTestPaperItemKnowladgeAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemKnowladge>> AddTestPaperItemKnowladgeAsync(AddTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<ExamQuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TestPaperItemDtos.Select(x => x.QuestionId);
 
             var questionKnowladge = await questionKnowladgeRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var testPaperItemKnowladges = new List<TestPaperItemKnowladge>();
+            var testPaperItemKnowladges = new List<ExamTestPaperItemKnowladge>();
 
             actionRequest.TestPaperItemDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -999,7 +1002,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
                 {
                     options.ForEach(item =>
                     {
-                        var testPaperItemKnowladge = _mapper.Map<QuestionKnowladge, TestPaperItemKnowladge>(item);
+                        var testPaperItemKnowladge = _mapper.Map<ExamQuestionKnowladge, ExamTestPaperItemKnowladge>(item);
 
                         testPaperItemKnowladge.TestPaperItemId = testPaperItem?.Id;
 
@@ -1015,7 +1018,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             return testPaperItemKnowladges;
         }
 
-        private async Task<List<TestPaperItemSourceware>> ModifyTestPaperItemSourcewareAsync(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemSourceware>> ModifyTestPaperItemSourcewareAsync(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -1023,7 +1026,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var entityQueryRequest = new EntityQueryRequest
             {
-                Expression = ExpressionableUtility.CreateExpression<TestPaperItemSourceware>()
+                Expression = ExpressionableUtility.CreateExpression<ExamTestPaperItemSourceware>()
                              .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
             };
 
@@ -1037,7 +1040,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
             await _testPaperItemSourcewareRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TestPaperItemKnowladge>> ModifyTestPaperItemKnowladgeAsync(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTestPaperItemKnowladge>> ModifyTestPaperItemKnowladgeAsync(UpdateTestPaperDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TestPaperItemDtos == null) return null;
 
@@ -1045,7 +1048,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
 
             var entityQueryRequest = new EntityQueryRequest
             {
-                Expression = ExpressionableUtility.CreateExpression<TestPaperItemKnowladge>()
+                Expression = ExpressionableUtility.CreateExpression<ExamTestPaperItemKnowladge>()
                              .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
             };
 
@@ -1061,7 +1064,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
         #endregion
 
         #region protected method
-        protected override async Task CompleteAdd(TestPaper entity)
+        protected override async Task CompleteAdd(ExamTestPaper entity)
         {
             await base.AddNav(entity)
                   //.Include(x => x.TestPaperRules)
@@ -1085,7 +1088,7 @@ namespace Hotline.Application.Exam.Service.TestPapers
                   .ThenInclude(x => x.TestPaperItemSourcewares).ExecuteCommandAsync();
         }
 
-        protected override async Task CompleteUpdate(TestPaper entity)
+        protected override async Task CompleteUpdate(ExamTestPaper entity)
         {
             await base.UpdateNav(entity)
                  //.Include(x => x.TestPaperRules)

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

@@ -1,18 +1,16 @@
 using DocumentFormat.OpenXml.Office2010.Excel;
-using Exam.Application.Interface.Train;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share;
 using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
 using Hotline.Application.Exam.Core.Constants;
+using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Core.Utilities;
 using Hotline.Application.Exam.Extensions;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Application.Exam.QueryExtensions.Trains;
 using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar;
@@ -30,7 +28,7 @@ using XF.Domain.Dependency;
 
 namespace Hotline.Application.Exam.Service.Trains
 {
-    public class TrainPlanService : ApiService<TrainPlan, AddTrainPlanDto, UpdateTrainPlanDto, HotlineDbContext>, ITrainPlanService, IScopeDependency
+    public class TrainPlanService : ApiService<ExamTrainPlan, AddTrainPlanDto, UpdateTrainPlanDto, HotlineDbContext>, ITrainPlanService, IScopeDependency
     {
         private readonly ITrainPlanRepository _repository;
         private readonly ITrainPlanTemplateRepository _trainPlanTemplateRepository;
@@ -102,7 +100,7 @@ namespace Hotline.Application.Exam.Service.Trains
         {
             base.StartTran();
 
-            actionRequest.Code = await GenerateCode(BusiConstants.TrainCode,3);
+            actionRequest.Code = await GenerateCode(ExamBusiConstants.TrainCode,3);
 
             var id = await base.AddAsync(actionRequest, cancellationToken);
 
@@ -143,17 +141,17 @@ namespace Hotline.Application.Exam.Service.Trains
         {
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<TrainPlanTemplate>()
+            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTrainPlanTemplate>()
                .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TrainPlanId == entityQueryRequest.Id)
                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TrainPlanId))
-               .ToEntityQueryRequest<TrainPlanTemplate>();
+               .ToEntityQueryRequest<ExamTrainPlanTemplate>();
 
             await DeleteTrainPlanTemplateAsync(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<TrainRecord>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTrainRecord>()
                .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TrainPlanId == entityQueryRequest.Id)
                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TrainPlanId))
-               .ToEntityQueryRequest<TrainRecord>();
+               .ToEntityQueryRequest<ExamTrainRecord>();
 
             await DeleteTrainRecordsAsync(tmpEntityQueryRequest, cancellationToken);
 
@@ -254,7 +252,7 @@ namespace Hotline.Application.Exam.Service.Trains
             return queryResult;
         }
 
-        private async Task<List<TrainPlanTemplate>> AddTrainPlanTemplatesAsync(AddTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPlanTemplate>> AddTrainPlanTemplatesAsync(AddTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPlanTemplateDtos != null)
             {
@@ -262,11 +260,11 @@ namespace Hotline.Application.Exam.Service.Trains
 
                 var trainPlanTemplateDtos = actionRequest.TrainPlanTemplateDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-                var trainPlanTemplates = new List<TrainPlanTemplate>();
+                var trainPlanTemplates = new List<ExamTrainPlanTemplate>();
 
                 trainPlanTemplateDtos.ForEach(item =>
                 {
-                    trainPlanTemplates.Add(_mapper.Map<TrainPlanTemplate>(item));
+                    trainPlanTemplates.Add(_mapper.Map<ExamTrainPlanTemplate>(item));
                 });
 
                 trainPlanTemplates.ToInsert(_sessionContext);
@@ -279,18 +277,18 @@ namespace Hotline.Application.Exam.Service.Trains
             return null;
         }
 
-        private async Task<List<TrainRecord>> AddTrainRecordsAsync(AddTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainRecord>> AddTrainRecordsAsync(AddTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainRecordDtos != null)
             {
                 actionRequest.TrainRecordDtos.ResolveOperationStatus();
 
                 var trainPracticeDtos = actionRequest.TrainRecordDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
-                var trainPractices = new List<TrainRecord>();
+                var trainPractices = new List<ExamTrainRecord>();
 
                 trainPracticeDtos.ForEach(item =>
                 {
-                    trainPractices.Add(_mapper.Map<TrainRecord>(item));
+                    trainPractices.Add(_mapper.Map<ExamTrainRecord>(item));
                 });
 
                 trainPractices.ToInsert(_sessionContext);
@@ -303,9 +301,9 @@ namespace Hotline.Application.Exam.Service.Trains
             return null;
         }
 
-        private async Task<List<TrainPlanTemplate>> ModifyTrainPlanTemplatesAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPlanTemplate>> ModifyTrainPlanTemplatesAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
-            var trainPlanTemplates = new List<TrainPlanTemplate>();
+            var trainPlanTemplates = new List<ExamTrainPlanTemplate>();
 
             var all = await _trainPlanTemplateRepository.Queryable().Where(x => x.TrainPlanId == actionRequest.Id).ToListAsync();
 
@@ -323,7 +321,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
                     var entityQueryRequest = new EntityQueryRequest
                     {
-                        Expression = ExpressionableUtility.CreateExpression<TrainPlanTemplate>()
+                        Expression = ExpressionableUtility.CreateExpression<ExamTrainPlanTemplate>()
                     .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
                     .ToExpression()
                     };
@@ -341,7 +339,7 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainPlanTemplateRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainPlanTemplate>> UpdateTrainPlanTemplatesAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPlanTemplate>> UpdateTrainPlanTemplatesAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPlanTemplateDtos == null) return null;
 
@@ -351,7 +349,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var trainPlanTemplates = await _trainPlanTemplateRepository.Queryable().Where(x => ids.Contains(x.Id)).ToListAsync();
 
-            trainPlanTemplates = _mapper.Map<List<UpdateTrainPlanTemplateDto>, List<TrainPlanTemplate>>(trainPlanTemplateDtos, trainPlanTemplates);
+            trainPlanTemplates = _mapper.Map<List<UpdateTrainPlanTemplateDto>, List<ExamTrainPlanTemplate>>(trainPlanTemplateDtos, trainPlanTemplates);
 
             trainPlanTemplates.ToUpdate(_sessionContext);
 
@@ -360,9 +358,9 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPlanTemplates;
         }
 
-        private async Task<List<TrainRecord>> ModifyTrainRecordsAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainRecord>> ModifyTrainRecordsAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
-            var trainRecords = new List<TrainRecord>();
+            var trainRecords = new List<ExamTrainRecord>();
 
             var all =  await _trainRecordRepository.Queryable().Where(x => x.TrainPlanId == actionRequest.Id).ToListAsync();
 
@@ -381,7 +379,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
                     var entityQueryRequest = new EntityQueryRequest
                     {
-                        Expression = ExpressionableUtility.CreateExpression<TrainRecord>()
+                        Expression = ExpressionableUtility.CreateExpression<ExamTrainRecord>()
                   .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
                   .ToExpression()
                     };
@@ -399,7 +397,7 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainRecordRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainRecord>> UpdateTrainRecordsAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainRecord>> UpdateTrainRecordsAsync(UpdateTrainPlanDto actionRequest, CancellationToken cancellationToken)
         {
 
             if (actionRequest.TrainRecordDtos == null) return null;
@@ -410,7 +408,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var trainRecords = await _trainRecordRepository.Queryable().Where(x => ids.Contains(x.Id)).ToListAsync();
 
-            trainRecords = _mapper.Map<List<UpdateTrainRecordDto>, List<TrainRecord>>(trainPracticeDtos, trainRecords);
+            trainRecords = _mapper.Map<List<UpdateTrainRecordDto>, List<ExamTrainRecord>>(trainPracticeDtos, trainRecords);
 
             trainRecords.ToUpdate(_sessionContext);
 

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

@@ -1,14 +1,14 @@
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Validation.Validation;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Repository.Sqlsugar.Repositories.Trains;
 using Exam.Share.Dtos.Trains;
 using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
 using Hotline.Application.Exam.Core.Extensions;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Application.Exam.QueryExtensions.Trains;
+using Hotline.Exams.Practices;
 using Hotline.Exams.Sourcewares;
 using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar;
@@ -31,7 +31,7 @@ using NPOI.SS.Formula.Functions;
 
 namespace Hotline.Application.Exam.Service.Trains
 {
-    public class TrainRecordService : ApiService<TrainRecord, AddTrainRecordDto, UpdateTrainRecordDto, HotlineDbContext>, ITrainRecordService, IScopeDependency
+    public class TrainRecordService : ApiService<ExamTrainRecord, AddTrainRecordDto, UpdateTrainRecordDto, HotlineDbContext>, ITrainRecordService, IScopeDependency
     {
         private readonly ITrainRecordRepository _repository;
         private readonly ITrainRecordAnswerRepository _trainRecordAnswerRepository;
@@ -63,7 +63,7 @@ namespace Hotline.Application.Exam.Service.Trains
         #region public method
         public async Task CompleteTrainRecordAsync(CompleteTrainRecordDto completeTrainRecordDto, CancellationToken cancellationToken)
         {
-            var trainRecord = _mapper.Map<TrainRecord>(completeTrainRecordDto);
+            var trainRecord = _mapper.Map<ExamTrainRecord>(completeTrainRecordDto);
             trainRecord.ToUpdate(_sessionContext);
 
             await _repository.ValidateUpdateAsync(trainRecord, cancellationToken);
@@ -71,7 +71,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         public async Task CompleteTrainKnowladgeAsync(CompleteTrainKnowladgeDto completeTrainPracticeDto, CancellationToken cancellationToken)
         {
-            var trainKnowladge = _mapper.Map<TrainKnowladge>(completeTrainPracticeDto);
+            var trainKnowladge = _mapper.Map<ExamTrainKnowladge>(completeTrainPracticeDto);
 
             trainKnowladge.ToUpdate(_sessionContext);
 
@@ -155,9 +155,9 @@ namespace Hotline.Application.Exam.Service.Trains
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();
 
-            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 trainTemplateRepostitory = new ExamRepository<ExamTrainTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new ExamRepository<ExamTrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<ExamTrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var userRepository = new ExamRepository<User>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
@@ -197,9 +197,9 @@ namespace Hotline.Application.Exam.Service.Trains
             var expression = trainResultReportPagedRequest.GetExpression();
             var templateExpression = trainResultReportPagedRequest.GetTemplateExpression();
 
-            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 trainTemplateRepostitory = new ExamRepository<ExamTrainTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new ExamRepository<ExamTrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<ExamTrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
             var trainTemplateTable = trainTemplateRepostitory.Queryable().Where(templateExpression);
@@ -234,7 +234,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task AddTrainRecordItem(AddTrainDto addTrainDto, CancellationToken cancellationToken)
         {
-            var trainRecordItem = _mapper.Map<TrainRecordItem>(addTrainDto);
+            var trainRecordItem = _mapper.Map<ExamTrainRecordItem>(addTrainDto);
 
             trainRecordItem.ToInsert(_sessionContext);
 
@@ -273,9 +273,9 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private SqlSugar.ISugarQueryable<SimpleQuestionDto> QueryQuestions(EntityQueryRequest entityQueryRequest)
         {
-            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 trainPlanRepository = new ExamRepository<ExamTrainPlan>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<ExamTrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new ExamRepository<ExamTrainPlanTemplate>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var trainRecordTable = _repository.Queryable().Where(x => x.Id == entityQueryRequest.Id);
             var trainPlanTable = trainPlanRepository.Queryable();
@@ -296,7 +296,7 @@ namespace Hotline.Application.Exam.Service.Trains
         private async Task<List<SimpleKnowladgeDto>> GetKnowladges(EntityQueryRequest entityQueryRequest)
         {
             var questionTable = QueryQuestions(entityQueryRequest);
-            var questionSourcewareRepository = new ExamRepository<PracticeQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<ExamPracticeQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var sourcewareRepository = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var questionSourcewareTable = questionSourcewareRepository.Queryable();
             var sourcewareTable = sourcewareRepository.Queryable();
@@ -317,16 +317,16 @@ namespace Hotline.Application.Exam.Service.Trains
         {
             if (addTrainRecordDto.AddTrainRecordOptionDtos == null && addTrainRecordDto.AddTrainRecordAnswerDto == null) return;
 
-            var trainRecordAnswers = new List<TrainRecordAnswer>();
+            var trainRecordAnswers = new List<ExamTrainRecordAnswer>();
 
             addTrainRecordDto.AddTrainRecordOptionDtos?.ForEach(item =>
             {
-                trainRecordAnswers.Add(_mapper.Map<TrainRecordAnswer>(item));
+                trainRecordAnswers.Add(_mapper.Map<ExamTrainRecordAnswer>(item));
             });
 
             if (addTrainRecordDto.AddTrainRecordAnswerDto != null)
             {
-                trainRecordAnswers.Add(_mapper.Map<TrainRecordAnswer>(addTrainRecordDto.AddTrainRecordAnswerDto));
+                trainRecordAnswers.Add(_mapper.Map<ExamTrainRecordAnswer>(addTrainRecordDto.AddTrainRecordAnswerDto));
             }
 
             trainRecordAnswers.ToInsert(_sessionContext);
@@ -336,8 +336,8 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<TrainPracticeDto> GetTrainQuestionOptions(AddTrainDto addTrainDto)
         {
-            var trainPracticeOptionsRepository = new ExamRepository<TrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainPracticeRepository = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeOptionsRepository = new ExamRepository<ExamTrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<ExamTrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             // TODO: 获取未答题的第一道题
             var trainPractice = await trainPracticeRepository.Queryable()
@@ -360,15 +360,15 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<SimpleTrainPracticeOptionsDto>> GetTrainQuestionOptions(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeRepository = new ExamRepository<TrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var trainRecordAnswerRepository = new ExamRepository<TrainRecordAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepository = new ExamRepository<ExamTrainPracticeOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainRecordAnswerRepository = new ExamRepository<ExamTrainRecordAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             // TODO: 获取未阅卷的第一道题
             var trainPracticeOptions = trainPracticeRepository.Queryable().Where(x => x.TrainPracticeId == trainPracticeRequest.TrainPracticeId);
 
             var trainRecordOptions = await trainRecordAnswerRepository.Queryable()
-                .InnerJoin<TrainRecord>((t,x)=>t.TrainRecordId == x.Id)
-                .InnerJoin<TrainPlanTemplate>((t,x,p)=> x.TrainPlanId == p.TrainPlanId)
-                .InnerJoin<TrainPractice>((t,x,p,tp)=> x.Id == tp.TrainTemplateId)
+                .InnerJoin<ExamTrainRecord>((t,x)=>t.TrainRecordId == x.Id)
+                .InnerJoin<ExamTrainPlanTemplate>((t,x,p)=> x.TrainPlanId == p.TrainPlanId)
+                .InnerJoin<ExamTrainPractice>((t,x,p,tp)=> x.Id == tp.TrainTemplateId)
                 .Where((t, x, p, tp) => tp.Id == trainPracticeRequest.TrainPracticeId)
                 .Select((t, x, p, tp) => t)
                 .ToListAsync();
@@ -389,10 +389,10 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeKnowladgeDto>> GetTrainPracticeKnowladges(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeKnowladgeRepository = new ExamRepository<TrainPracticeKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeKnowladgeRepository = new ExamRepository<ExamTrainPracticeKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var knowledgeRepository = new ExamRepository<KnowledgeBase.Knowledge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
-            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepostitory = new ExamRepository<ExamTrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = trainPracticeRequest.GetExpression();
             var trainPracticeTable = trainPracticeRepostitory.Queryable().Where(expression);
@@ -413,10 +413,10 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeSourcewareDto>> GetTrainPracticeSourcewares(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeSourcewareRepository = new ExamRepository<TrainPracticeSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var sourcewareRepository = new ExamRepository<Sourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeSourcewareRepository = new ExamRepository<ExamTrainPracticeSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var sourcewareRepository = new ExamRepository<ExamSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
-            var trainPracticeRepostitory = new ExamRepository<TrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPracticeRepostitory = new ExamRepository<ExamTrainPractice>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var expression = trainPracticeRequest.GetExpression();
             var trainPracticeTable = trainPracticeRepostitory.Queryable().Where(expression);

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

@@ -1,22 +1,17 @@
 using DocumentFormat.OpenXml.Office2010.Excel;
-using Exam.Application.Interface.Train;
 using Exam.Infrastructure.Data.Entity;
 using Exam.Infrastructure.Enums;
 using Exam.Infrastructure.Extensions;
-using Exam.Infrastructure.Web.Extensions;
-using Exam.Infrastructure.Web.Utilities;
 using Exam.Insfrastructure.Service.Service;
-using Exam.Practices;
-using Exam.Questions;
 using Exam.Repository.Sqlsugar.Repositories;
 using Exam.Share.ViewResponses.Train;
-using Exam.TestPapers;
-using Exam.Trains;
 using Hotline.Application.Exam.Core.Constants;
 using Hotline.Application.Exam.Core.Extensions;
 using Hotline.Application.Exam.Core.Utilities;
 using Hotline.Application.Exam.Extensions;
+using Hotline.Application.Exam.Interface.Train;
 using Hotline.Application.Exam.QueryExtensions.Trains;
+using Hotline.Exams.Questions;
 using Hotline.Exams.TestPapers;
 using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar;
@@ -37,7 +32,7 @@ using XF.Domain.Dependency;
 
 namespace Hotline.Application.Exam.Service.Trains
 {
-    public class TrainTemplateService : ApiService<TrainTemplate, AddTrainTemplateDto, UpdateTrainTemplateDto, HotlineDbContext>, ITrainTemplateService, IScopeDependency
+    public class TrainTemplateService : ApiService<ExamTrainTemplate, AddTrainTemplateDto, UpdateTrainTemplateDto, HotlineDbContext>, ITrainTemplateService, IScopeDependency
     {
         private readonly ITrainTemplateRepository _repository;
         private readonly ITrainKnowladgeRepository _trainKnowladgeRepository;
@@ -117,7 +112,7 @@ namespace Hotline.Application.Exam.Service.Trains
         {
             base.StartTran();
 
-            actionRequest.Code = await GenerateCode(BusiConstants.TrainTemplateCode,3);
+            actionRequest.Code = await GenerateCode(ExamBusiConstants.TrainTemplateCode,3);
 
             var id = await base.AddAsync(actionRequest, cancellationToken);
 
@@ -186,17 +181,17 @@ namespace Hotline.Application.Exam.Service.Trains
         {
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<TrainKnowladge>()
+            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTrainKnowladge>()
                .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TrainTemplateId == entityQueryRequest.Id)
                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TrainTemplateId))
-               .ToEntityQueryRequest<TrainKnowladge>();
+               .ToEntityQueryRequest<ExamTrainKnowladge>();
 
             await DeleteTrainKnowladgesAsync(tmpEntityQueryRequest, cancellationToken);
 
-            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<TrainPractice>()
+            tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamTrainPractice>()
                .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.TrainTemplateId == entityQueryRequest.Id)
                .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.TrainTemplateId))
-               .ToEntityQueryRequest<TrainPractice>();
+               .ToEntityQueryRequest<ExamTrainPractice>();
 
             await DeleteTrainPracticeAsync(tmpEntityQueryRequest, cancellationToken);
         }
@@ -219,7 +214,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         }
 
-        private async Task<List<TrainPracticeOptions>> ModifyTrainPracticeOptionsAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeOptions>> ModifyTrainPracticeOptionsAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPracticeDtos == null) return null;
 
@@ -229,7 +224,7 @@ namespace Hotline.Application.Exam.Service.Trains
             {
 				var entityQueryRequest = new EntityQueryRequest
 				{
-					Expression = ExpressionableUtility.CreateExpression<TrainPracticeOptions>()
+					Expression = ExpressionableUtility.CreateExpression<ExamTrainPracticeOptions>()
 							 .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
 				};
 
@@ -246,15 +241,15 @@ namespace Hotline.Application.Exam.Service.Trains
 
 
 
-        private async Task<List<TrainPracticeSourceware>> AddTrainPracticeSourcewareAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeSourceware>> AddTrainPracticeSourcewareAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionSourcewareRepository = new ExamRepository<QuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionSourcewareRepository = new ExamRepository<ExamQuestionSourceware>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
             var questionSourceware = await questionSourcewareRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var trainPracticeSourcewares = new List<TrainPracticeSourceware>();
+            var trainPracticeSourcewares = new List<ExamTrainPracticeSourceware>();
 
             actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -264,7 +259,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
                     options.ForEach(item =>
                     {
-                        var trainPracticeSourceware = _mapper.Map<QuestionSourceware, TrainPracticeSourceware>(item);
+                        var trainPracticeSourceware = _mapper.Map<ExamQuestionSourceware, ExamTrainPracticeSourceware>(item);
 
 						trainPracticeSourceware.ToInsert(_sessionContext);
 
@@ -279,15 +274,15 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPracticeSourcewares;
         }
 
-        private async Task<List<TrainPracticeKnowladge>> AddTrainPracticeKnowladgeAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeKnowladge>> AddTrainPracticeKnowladgeAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionKnowladgeRepository = new ExamRepository<QuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionKnowladgeRepository = new ExamRepository<ExamQuestionKnowladge>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
             var questionKnowladge = await questionKnowladgeRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var trainPracticeKnowladges = new List<TrainPracticeKnowladge>();
+            var trainPracticeKnowladges = new List<ExamTrainPracticeKnowladge>();
 
             actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -299,7 +294,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
                     options.ForEach(item =>
                     {
-                        var trainPracticeKnowladge = _mapper.Map<QuestionKnowladge, TrainPracticeKnowladge>(item);
+                        var trainPracticeKnowladge = _mapper.Map<ExamQuestionKnowladge, ExamTrainPracticeKnowladge>(item);
 
                         trainPracticeKnowladge.TrainPracticeId = trainPractice?.Id;
 
@@ -316,7 +311,7 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPracticeKnowladges;
         }
 
-        private async Task<List<TrainPracticeSourceware>> ModifyTrainPracticeSourcewareAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeSourceware>> ModifyTrainPracticeSourcewareAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPracticeDtos == null) return null;
 
@@ -326,7 +321,7 @@ namespace Hotline.Application.Exam.Service.Trains
             {
 				var entityQueryRequest = new EntityQueryRequest
 				{
-					Expression = ExpressionableUtility.CreateExpression<TrainPracticeSourceware>()
+					Expression = ExpressionableUtility.CreateExpression<ExamTrainPracticeSourceware>()
 							.AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
 				};
 
@@ -341,7 +336,7 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainPracticeSourcewareRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainPracticeKnowladge>> ModifyTrainPracticeKnowladgeAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeKnowladge>> ModifyTrainPracticeKnowladgeAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPracticeDtos == null) return null;
 
@@ -351,7 +346,7 @@ namespace Hotline.Application.Exam.Service.Trains
             {
 				var entityQueryRequest = new EntityQueryRequest
 				{
-					Expression = ExpressionableUtility.CreateExpression<TrainPracticeKnowladge>()
+					Expression = ExpressionableUtility.CreateExpression<ExamTrainPracticeKnowladge>()
 						  .AndIF(questionIds.IsNotNullOrEmpty(), x => questionIds.Contains(x.QuestionId)).ToExpression()
 				};
 
@@ -366,15 +361,15 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainPracticeKnowladgeRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainPracticeOptions>> AddTrainPracticeOptionsAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPracticeOptions>> AddTrainPracticeOptionsAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var questionOptionRepository = new ExamRepository<QuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionOptionRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             var quesitonIds = actionRequest.TrainPracticeDtos.Select(x => x.QuestionId);
 
             var questionOptions = await questionOptionRepository.Queryable().Where(x => quesitonIds.Contains(x.QuestionId)).ToListAsync();
 
-            var trainPracticeOptions = new List<TrainPracticeOptions>();
+            var trainPracticeOptions = new List<ExamTrainPracticeOptions>();
 
             actionRequest.TrainPracticeDtos.Where(x => x.QuestionType.CheckSelectType()).ToList().ForEach(x =>
             {
@@ -386,7 +381,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
                     options.ForEach(item =>
                     {
-                        var trainPracticeOption = _mapper.Map<QuestionOptions, TrainPracticeOptions>(item);
+                        var trainPracticeOption = _mapper.Map<ExamQuestionOptions, ExamTrainPracticeOptions>(item);
 
                         trainPracticeOption.TrainPracticeId = trainPractice?.Id;
 
@@ -420,7 +415,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
         private async Task<List<TrainPracticeDto>> GetTrainPractices(EntityQueryRequest entityQueryRequest)
         {
-            var questionTable = new ExamRepository<Question>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTable = new ExamRepository<ExamQuestion>(_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
@@ -455,7 +450,7 @@ namespace Hotline.Application.Exam.Service.Trains
             return queryResult;
         }
 
-        private async Task<List<TrainPractice>> AddTrainPracticesAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPractice>> AddTrainPracticesAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPracticeDtos != null)
             {
@@ -463,7 +458,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
                 var trainPracticeDtos = actionRequest.TrainPracticeDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-                var trainPractices = _mapper.Map<List<TrainPractice>>(trainPracticeDtos);
+                var trainPractices = _mapper.Map<List<ExamTrainPractice>>(trainPracticeDtos);
 
                 //TODO:排序
                 var sortIndex = 0;
@@ -482,7 +477,7 @@ namespace Hotline.Application.Exam.Service.Trains
             return null;
         }
 
-        private async Task<List<TrainKnowladge>> AddTrainKnowladgesAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainKnowladge>> AddTrainKnowladgesAsync(AddTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainKnowladges != null)
             {
@@ -490,7 +485,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
                 var trainKnowladgeDtos = actionRequest.TrainKnowladges.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-                var trainKnowladges = _mapper.Map<List<TrainKnowladge>>(trainKnowladgeDtos);
+                var trainKnowladges = _mapper.Map<List<ExamTrainKnowladge>>(trainKnowladgeDtos);
 
                 trainKnowladges.ToInsert(_sessionContext);
 
@@ -501,9 +496,9 @@ namespace Hotline.Application.Exam.Service.Trains
             return null;
         }
 
-        private async Task<List<TrainPractice>> ModifyTrainPracticesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPractice>> ModifyTrainPracticesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var trainPractices = new List<TrainPractice>();
+            var trainPractices = new List<ExamTrainPractice>();
 
             trainPractices.AddRangeExt(await AddTrainPracticesAsync(_addTrainTemplateDto, cancellationToken));
 
@@ -517,7 +512,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
 					var entityQueryRequest = new EntityQueryRequest
 					{
-						Expression = ExpressionableUtility.CreateExpression<TrainPractice>()
+						Expression = ExpressionableUtility.CreateExpression<ExamTrainPractice>()
 					.AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
 					.ToExpression()
 					};
@@ -534,7 +529,7 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainPracticeRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainPractice>> UpdateTrainPracticesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainPractice>> UpdateTrainPracticesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainPracticeDtos == null) return null;
 
@@ -546,7 +541,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var trainPractices = await _trainPracticeRepository.Queryable().Where(x => ids.Contains(x.Id)).ToListAsync();
 
-            trainPractices = _mapper.Map<List<UpdateTrainPracticeDto>, List<TrainPractice>>(trainPracticeDtos, trainPractices);
+            trainPractices = _mapper.Map<List<UpdateTrainPracticeDto>, List<ExamTrainPractice>>(trainPracticeDtos, trainPractices);
 
             trainPractices.ToUpdate(_sessionContext);
 
@@ -555,9 +550,9 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPractices;
         }
 
-        private async Task<List<TrainKnowladge>> ModifyTrainKnowladgeAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainKnowladge>> ModifyTrainKnowladgeAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
-            var trainKnowladges = new List<TrainKnowladge>();
+            var trainKnowladges = new List<ExamTrainKnowladge>();
 
             trainKnowladges.AddRangeExt(await AddTrainKnowladgesAsync(_addTrainTemplateDto, cancellationToken));
 
@@ -571,7 +566,7 @@ namespace Hotline.Application.Exam.Service.Trains
                 {
 					var entityQueryRequest = new EntityQueryRequest
 					{
-						Expression = ExpressionableUtility.CreateExpression<TrainKnowladge>()
+						Expression = ExpressionableUtility.CreateExpression<ExamTrainKnowladge>()
 				   .AndIF(ids.IsNotEmpty(), x => ids.Contains(x.Id))
 				   .ToExpression()
 					};
@@ -589,7 +584,7 @@ namespace Hotline.Application.Exam.Service.Trains
             await _trainKnowladgeRepository.DeleteWithValidateAsync(entityQueryRequest, cancellationToken);
         }
 
-        private async Task<List<TrainKnowladge>> UpdateTrainKnowladgesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamTrainKnowladge>> UpdateTrainKnowladgesAsync(UpdateTrainTemplateDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.TrainKnowladges == null) return null;
 
@@ -601,7 +596,7 @@ namespace Hotline.Application.Exam.Service.Trains
 
             var trainKnowladges = await _trainKnowladgeRepository.Queryable().Where(x => ids.Contains(x.Id)).ToListAsync();
 
-            trainKnowladges = _mapper.Map<List<UpdateTrainKnowladgeDto>, List<TrainKnowladge>>(trainKnowladgeDtos, trainKnowladges);
+            trainKnowladges = _mapper.Map<List<UpdateTrainKnowladgeDto>, List<ExamTrainKnowladge>>(trainKnowladgeDtos, trainKnowladges);
 
             trainKnowladges.ToUpdate(_sessionContext);
 
@@ -627,7 +622,7 @@ namespace Hotline.Application.Exam.Service.Trains
         #endregion
 
         #region protected method
-        protected override async Task CompleteAdd(TrainTemplate entity)
+        protected override async Task CompleteAdd(ExamTrainTemplate entity)
         {
             await base.AddNav(entity)
                   .Include(x => x.TrainKnowladges)
@@ -645,7 +640,7 @@ namespace Hotline.Application.Exam.Service.Trains
                   .ThenInclude(x => x.TrainPracticeSourcewares).ExecuteCommandAsync();
         }
 
-        protected override async Task CompleteUpdate(TrainTemplate entity)
+        protected override async Task CompleteUpdate(ExamTrainTemplate entity)
         {
             await base.UpdateNav(entity)
                  .Include(x => x.TrainKnowladges)

src/Hotline.Application/FlowEngine/WorkflowApplication.cs

@@ -88,7 +88,7 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
     //     //var validResult = await validator.ValidateAsync(dto, cancellationToken);
     //     //if (!validResult.IsValid)
     //     //    throw new UserFriendlyException(
-    //     //        $"非法参数, {string.Join(',', validResult.Errors.Select(d => d.ErrorMessage))}");
+    //     //        $"非法参数, {string.Join(',', validResult.Errors.Select(d => d.ExamErrorMessage))}");
     //
     //     var wfModule = await GetWorkflowModuleAsync(dto.DefinitionModuleCode, cancellationToken);
     //     var definition = wfModule.Definition;
@@ -282,7 +282,7 @@ public class WorkflowApplication : IWorkflowApplication, IScopeDependency
     //    var validResult = await validator.ValidateAsync(dto, cancellationToken);
     //    if (!validResult.IsValid)
     //        throw new UserFriendlyException(
-    //            $"非法参数, {string.Join(',', validResult.Errors.Select(d => d.ErrorMessage))}");
+    //            $"非法参数, {string.Join(',', validResult.Errors.Select(d => d.ExamErrorMessage))}");
     //    var workflow = await _workflowDomainService.GetWorkflowAsync(dto.WorkflowId, withDefine: true, withSteps: true,
     //        withTraces: true, withCountersigns: true, cancellationToken: cancellationToken);
 

src/Hotline.Repository.SqlSugar/Exam/Core/Constants/ExamErrorMessage.cs

@@ -2,7 +2,7 @@
 
 namespace Hotline.Repository.SqlSugar.Exam.Core.Constants
 {
-    public class ExamErrorMessage:ErrorMessage
+    public class ExamErrorMessage:global::Hotline.Exams.Validate.ExamErrorMessage
     {
         public const string DeleteUnableUserExam = "考试已经开始，不能删除";
         

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

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.ExamManages;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.Interface;
 

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

@@ -1,6 +1,6 @@
-using Exam.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using System.ComponentModel;
+using Hotline.Exams.ExamManages;
 using XF.Domain.Repository;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages

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

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.Questions;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.Questions

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

@@ -1,6 +1,6 @@
-using Exam.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using System.ComponentModel;
+using Hotline.Exams.ExamManages;
 using XF.Domain.Repository;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.Exams

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

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.ExamManages;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.Interface;
 

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

@@ -2,9 +2,8 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.Questions;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
-using Exam.ExamManages;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
 {

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

@@ -1,7 +1,7 @@
-using Exam.ExamManages;
 using Hotline.Repository.SqlSugar.Interface;
 using System.ComponentModel;
 using System.Linq.Expressions;
+using Hotline.Exams.ExamManages;
 using XF.Domain.Repository;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages

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

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.ExamManages;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.Interface;
 
@@ -12,7 +12,7 @@ namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
     /// 抽题规则仓储接口
     /// </summary>
     [Description("抽题规则仓储接口")]
-    public interface IExtractRuleRepository:IRepository<ExtractRule>,IExamRepository<ExtractRule,HotlineDbContext>
+    public interface IExtractRuleRepository:IRepository<ExamExtractRule>,IExamRepository<ExamExtractRule,HotlineDbContext>
     {
        
     }

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

@@ -2,7 +2,7 @@
 using SqlSugar;
 using XF.Domain.Repository;
 using System.ComponentModel;
-using Exam.ExamManages;
+using Hotline.Exams.ExamManages;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.Interface;
 
@@ -12,7 +12,7 @@ namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
     /// 规则标签仓储接口
     /// </summary>
     [Description("规则标签仓储接口")]
-    public interface IRuleTagRepository:IRepository<RuleTag>,IExamRepository<RuleTag,HotlineDbContext>
+    public interface IRuleTagRepository:IRepository<ExamRuleTag>,IExamRepository<ExamRuleTag,HotlineDbContext>
     {
        
     }

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

@@ -4,7 +4,7 @@ using XF.Domain.Repository;
 
 namespace Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages
 {
-    public interface IUserExamItemOptionRepository:IRepository<UserExamItemOptions>,IExamRepository<UserExamItemOptions, HotlineDbContext>
+    public interface IUserExamItemOptionRepository:IRepository<ExamUserExamItemOptions>,IExamRepository<ExamUserExamItemOptions, HotlineDbContext>
     {
     }
 }