合并代码

src/Hotline.Api/Controllers/AiController.cs

@@ -559,7 +559,7 @@ namespace Hotline.Api.Controllers
                                 aiOrderVisitDetail.AiOrderVisitState = Share.Enums.Ai.EAiOrderVisitState.Ended; //更新AI子表
                                 aiOrderVisitDetail.AiVisitTime = DateTime.Now;
                                 aiOrderVisitDetail.CallTime = string.IsNullOrEmpty(callRecord.CallTime)? null : DateTime.Parse(callRecord.CallTime);
-                                aiOrderVisitDetail.SentenceList = _mapper.Map<List<SentenceList>>(callRecord.SentenceList);
+                                //aiOrderVisitDetail.SentenceList = _mapper.Map<List<SentenceList>>(callRecord.SentenceList);
                                 aiOrderVisit.VisitedCount++;
                                 //处理结果
                                 var visitDetail = _orderVisitDetailRepository.Queryable().Where(x => x.VisitId == aiOrderVisitDetail.OrderVisit.Id).ToList();
@@ -683,7 +683,7 @@ namespace Hotline.Api.Controllers
                                         //TODO 记录不满意原因到内容中供人工回访甄别选择不满意原因
                                         if (dto.CallTimes.Value>=1 && orgProcessingResults == null)
                                         {
-                                            orgProcessingResults = new Kv() { Key = "6", Value = "未接通" };
+                                            orgProcessingResults = new Kv() { Key = "0", Value = "默认满意" };
                                             aiOrderVisitDetail.OrderVisit.VisitState = EVisitState.Visited;
                                             aiOrderVisitDetail.OrderVisit.NowEvaluate = orgProcessingResults;
                                             x.VisitContent = "智能回访两次未接默认已回访";

src/Hotline.Api/Controllers/Bi/BiCallController.cs

@@ -738,6 +738,38 @@ public class BiCallController : BaseController
                 await _callReportApplication.QueryEnterpriseCallDateStatisticsDetail(dto.QueryDto)
             , "企业服务话务明细", "Date");
 
+    /// <summary>
+    /// 高效服务话务明细
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpGet("query-gaoxiao-calldate-statistics")]
+    public async Task<object> QueryGaoXiaoCallDateStatisticsDetail([FromQuery] QueryCallDateStatisticsDetailDto dto)
+    {
+        var list = await _callReportApplication.QueryGaoXiaoCallDateStatisticsDetail(dto);
+        var total = new QueryGaoXiaoCallDateStatisticsDetailResp()
+        {
+            Date = "合计",
+            GaoXiaoCallInCount = list.Sum(x => x.GaoXiaoCallInCount),
+            GaoXiaoCallInPutthroughCount = list.Sum(x => x.GaoXiaoCallInPutthroughCount),
+            GaoXiaoQueueOffCount = list.Sum(x => x.GaoXiaoQueueOffCount),//企业服务队列挂断
+            GaoXiaoWaitOffCount = list.Sum(x => x.GaoXiaoWaitOffCount) //企业服务等待挂断
+        };
+        return new { List = list, Total = total };
+    }
+
+    /// <summary>
+    /// 高效服务话务明细导出
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpPost("query-gaoxiao-calldate-statistics/export")]
+    [LogFilterAlpha("导出日志")]
+    public async Task<FileStreamResult> QueryGaoXiaoCallDateStatisticsDetailExport([FromBody] ExportExcelDto<QueryCallDateStatisticsDetailDto> dto)
+    => _exportApplication.GetExcelFile(
+                dto,
+                await _callReportApplication.QueryGaoXiaoCallDateStatisticsDetail(dto.QueryDto)
+            , "高效服务话务明细", "Date");
 
     /// <summary>
     /// 呼出话务统计明细

src/Hotline.Api/Controllers/Bi/BiOrderController.cs

@@ -2582,7 +2582,7 @@ namespace Hotline.Api.Controllers.Bi
                 Visitd = await _orderVisitRepository.Queryable()
               .Where(x => x.VisitTime >= StartTime && x.VisitTime <= EndTime && x.VisitState == EVisitState.Visited).CountAsync(),
                 WaitVisitd = await _orderVisitRepository.Queryable()
-             .Where(x => x.VisitTime >= StartTime && x.VisitTime <= EndTime && x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited).CountAsync()
+             .Where(x => x.CreationTime >= StartTime && x.CreationTime <= EndTime && x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited).CountAsync()
             };
             //
             var query = _orderVisitDetailRepository.Queryable()
@@ -3031,11 +3031,17 @@ namespace Hotline.Api.Controllers.Bi
                   CallVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType == EVisitType.CallVisit, 1, 0)),// 已回访--电话
                   SmsVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType == EVisitType.SmsVisit, 1, 0)),//已回访--短信
                   OtherVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType != EVisitType.CallVisit && x.VisitType != EVisitType.SmsVisit, 1, 0)),//其他回访
-                  WaitVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)),//待回访
+                  //WaitVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)),//待回访
               }).FirstAsync();
 
-            //部门
-            var listOrg = await _orderVisitDetailRepository.Queryable()
+			var waitVisitd = await _orderVisitRepository.Queryable()
+			 .Where(x => x.CreationTime >= StartTime && x.CreationTime <= EndTime).Select(x =>
+				   SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)) //待回访
+			  ).FirstAsync();
+			centerReportVisitd.WaitVisitd = waitVisitd;
+
+			//部门
+			var listOrg = await _orderVisitDetailRepository.Queryable()
                 .LeftJoin<OrderVisit>((it, o) => it.VisitId == o.Id)
                 .Where((it, o) => it.VisitTarget == EVisitTarget.Org && o.VisitTime >= StartTime && o.VisitTime <= EndTime && o.VisitState == EVisitState.Visited)
                  .Select((it, o) => new Satisfaction
@@ -3267,11 +3273,19 @@ namespace Hotline.Api.Controllers.Bi
                   CallVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType == EVisitType.CallVisit, 1, 0)),// 已回访--电话
                   SmsVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType == EVisitType.SmsVisit, 1, 0)),//已回访--短信
                   OtherVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState == EVisitState.Visited && x.VisitType != EVisitType.CallVisit && x.VisitType != EVisitType.SmsVisit, 1, 0)),//其他回访
-                  WaitVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)),//待回访
+                  //WaitVisitd = SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)),//待回访
               }).FirstAsync();
 
-            //部门
-            var listOrg = await _orderVisitDetailRepository.Queryable()
+            var waitVisitd = await _orderVisitRepository.Queryable()
+			  .LeftJoin<Order>((x, o) => x.OrderId == o.Id)
+			  .WhereIF(IdentityType.HasValue, (x, o) => o.IdentityType == IdentityType)
+			  .Where((x, o) => x.CreationTime >= StartTime && x.CreationTime <= EndTime).Select((x, o) => 
+                    SqlFunc.AggregateSum(SqlFunc.IIF(x.VisitState != EVisitState.None && x.VisitState != EVisitState.Visited, 1, 0)) //待回访
+               ).FirstAsync();
+            centerReportVisitd.WaitVisitd = waitVisitd;
+
+			//部门
+			var listOrg = await _orderVisitDetailRepository.Queryable()
                 .LeftJoin<OrderVisit>((x, ov) => x.VisitId == ov.Id)
                 .LeftJoin<Order>((x, ov, o) => ov.OrderId == o.Id)
                 .WhereIF(IdentityType.HasValue, (x, ov, o) => o.IdentityType == IdentityType)

src/Hotline.Api/Controllers/CallNativeContrroller.cs

@@ -267,7 +267,7 @@ namespace Hotline.Api.Controllers
         [HttpGet("verify-white-list/{phone}")]
         public async Task<bool> VerifyWhiteList(string phone)
         {
-            var isEx = await _db.Queryable<XingtangWhitePhone>().Where(p => p.Phone == phone && p.ValidDateTime <= DateTime.Now).AnyAsync();
+            var isEx = await _db.Queryable<XingtangWhitePhone>().Where(p => p.Phone == phone && p.ValidDateTime >= DateTime.Now).AnyAsync();
             if (isEx)
                 return true;
             else

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.Exam.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.Exam.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.Exam.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.Exam.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;
@@ -57,6 +58,17 @@ namespace Hotline.Api.Controllers.Exam
             return await _trainRecordService.GetTrainPracticeAsync(trainPracticeRequest);
         }
 
+        /// <summary>
+        /// 获取培训习题
+        /// </summary>
+        /// <param name="trainPracticeRequest"></param>
+        /// <returns></returns>
+        [HttpGet(TrainRecordApiRoute.GetSimpleTrainPractice)]
+        public async Task<SimpleTrainPracticeDto> GetSimpleTrainPractice([FromQuery] TrainPracticeRequest trainPracticeRequest)
+        {
+            return await _trainRecordService.GetSimpleTrainPracticeAsync(trainPracticeRequest);
+        }
+
         /// <summary>
         /// 完成培训课件学习
         /// </summary>

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/Controllers/IPPbxController.cs

@@ -687,71 +687,8 @@ namespace Hotline.Api.Controllers
             {
                 //await _iPPbxApplication.ResetTelStatus(null, dto.TelNo, CancellationToken.None);
             }
-
-            #region 处理动作数据
-            TelOperation telOperation = new()
-            {
-                StaffNo = dto.StaffNo,
-                TelNo = dto.TelNo,
-                OperateState = dto.Status,
-                OperateTime = DateTime.Now,
-            };
-
-            switch (dto.Status)
-            {
-                case 0:
-                    telOperation.OperateStateText = "签出";
-                    break;
-                case 100:
-                    telOperation.OperateStateText = "签入";
-                    break;
-                case 200:
-                    telOperation.OperateStateText = "空闲";
-                    break;
-                case 201:
-                    telOperation.OperateStateText = "小休";
-                    break;
-                case 202:
-                    telOperation.OperateStateText = "繁忙";
-                    break;
-                case 300:
-                    telOperation.OperateStateText = "呼入振铃";
-                    break;
-                case 301:
-                    telOperation.OperateStateText = "呼入通话";
-                    break;
-                case 302:
-                    telOperation.OperateStateText = "呼出振铃";
-                    break;
-                case 303:
-                    telOperation.OperateStateText = "呼出通话";
-                    break;
-                case 310:
-                    telOperation.OperateStateText = "通话保持";
-                    break;
-                case 320:
-                    telOperation.OperateStateText = "会议";
-                    break;
-                case 330:
-                    telOperation.OperateStateText = "咨询";
-                    break;
-                case 400:
-                    telOperation.OperateStateText = "整理";
-                    break;
-                case 900:
-                    telOperation.OperateStateText = "注册";
-                    break;
-                case 901:
-                    telOperation.OperateStateText = "注销";
-                    break;
-                default:
-                    break;
-            }
-            await _telOperationRepository.AddAsync(telOperation);
-            #endregion
-
-            dto.Status = await _callTelClient.GetStatusAsync(dto.Status);
-            await _callApplication.EndActionAsync(dto.Adapt<EndActionInDto>());
+            //dto.Status = await _callTelClient.GetStatusAsync(dto.Status);
+            //await _callApplication.EndActionAsync(dto.Adapt<EndActionInDto>());
 
         }
 

src/Hotline.Api/Controllers/OrderController.cs

@@ -3660,8 +3660,8 @@ public class OrderController : BaseController
             .Includes(x => x.Order)
             .WhereIF(!string.IsNullOrEmpty(dto.Keyword), x => x.Order.Title.Contains(dto.Keyword!) || x.Order.No.Contains(dto.Keyword!))
             .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No))                                //工单编号
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == true, x => x.Order.IsProvince == true)   //是否省工单
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == false, x => x.Order.IsProvince == false)
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == true, x => x.Order.IsProvince == true)   //是否省工单
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == false, x => x.Order.IsProvince == false)
             .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title))                       //工单标题
             .WhereIF(!string.IsNullOrEmpty(dto.Channel), x => x.Order.SourceChannelCode == dto.Channel)              //来源渠道
             .WhereIF(dto.Status.HasValue, x => x.Order.Status == dto.Status)                                         //工单状态
@@ -4062,10 +4062,10 @@ public class OrderController : BaseController
             )
             .WhereIF(!string.IsNullOrEmpty(dto.ActualHandleOrgName), x => x.Order.ActualHandleOrgName.Contains(dto.ActualHandleOrgName)) //接办部门（综合查询模糊）
             .WhereIF(!string.IsNullOrEmpty(dto.OrgLevelOneName), x => x.Order.OrgLevelOneName.Contains(dto.OrgLevelOneName)) //一级部门
-            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepCode), x => x.Order.CurrentStepCode == dto.CurrentStepCode) //当前办理节点
+            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepName), x => x.Order.CurrentStepName == dto.CurrentStepName) //当前办理节点
             .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No))                                //工单编号
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == true, x => x.Order.IsProvince == true)   //是否省工单
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == false, x => x.Order.IsProvince == false)
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == true, x => x.Order.IsProvince == true)   //是否省工单
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == false, x => x.Order.IsProvince == false)
             .WhereIF(!string.IsNullOrEmpty(dto.Channel), x => x.Order.SourceChannelCode == dto.Channel)              //来源渠道
             .WhereIF(dto.ExpiredTimeStart.HasValue, x => x.Order.ExpiredTime >= dto.ExpiredTimeStart)                //期满时间Start
             .WhereIF(dto.ExpiredTimeEnd.HasValue, x => x.Order.ExpiredTime <= dto.ExpiredTimeEnd)                    //期满时间End
@@ -4073,7 +4073,7 @@ public class OrderController : BaseController
             .WhereIF(dto.CreationTimeEnd.HasValue, x => x.Order.CreationTime <= dto.CreationTimeEnd)                 //受理时间End
             .WhereIF(dto.Status.HasValue, x => x.Order.Status == dto.Status)                                         //工单状态
             .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title))                       //工单标题
-            .WhereIF(!string.IsNullOrEmpty(dto.CurrentHandleOrgName), x => x.Order.CurrentHandleOrgName.Contains(dto.CurrentHandleOrgName)) //接办部门
+            .WhereIF(!string.IsNullOrEmpty(dto.CurrentHandleOrgName), x => x.Order.ActualHandleOrgName.Contains(dto.CurrentHandleOrgName)) //接办部门
             .WhereIF(dto.CurrentHandleTimeStart.HasValue, x => x.Order.CurrentHandleTime >= dto.CurrentHandleTimeStart)//接办时间Start
             .WhereIF(dto.CurrentHandleTimeEnd.HasValue, x => x.Order.CurrentHandleTime <= dto.CurrentHandleTimeEnd)    //接办时间End
             .WhereIF(!string.IsNullOrEmpty(dto.Hotspot), x => x.Order.HotspotSpliceName != null && x.Order.HotspotSpliceName.Contains(dto.Hotspot)) //热点
@@ -4105,8 +4105,8 @@ public class OrderController : BaseController
             .WhereIF(dto.UrgeState > -1, x => x.State == dto.UrgeState)
             .WhereIF(_sessionContext.OrgIsCenter == false, x => x.OrgId.StartsWith(_sessionContext.OrgId))
             .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No))                                //工单编号
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == true, x => x.Order.IsProvince == true)   //是否省工单
-            .WhereIF(dto.IsProvinceOrder.HasValue && dto.IsProvinceOrder == false, x => x.Order.IsProvince == false)
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == true, x => x.Order.IsProvince == true)   //是否省工单
+            .WhereIF(dto.IsProvince.HasValue && dto.IsProvince == false, x => x.Order.IsProvince == false)
             .WhereIF(!string.IsNullOrEmpty(dto.Channel), x => x.Order.SourceChannelCode == dto.Channel)              //来源渠道
             .WhereIF(dto.ExpiredTimeStart.HasValue, x => x.Order.ExpiredTime >= dto.ExpiredTimeStart)                //期满时间Start
             .WhereIF(dto.ExpiredTimeEnd.HasValue, x => x.Order.ExpiredTime <= dto.ExpiredTimeEnd)                    //期满时间End
@@ -4114,7 +4114,7 @@ public class OrderController : BaseController
             .WhereIF(dto.CreationTimeEnd.HasValue, x => x.Order.CreationTime <= dto.CreationTimeEnd)                 //受理时间End
             .WhereIF(dto.Status.HasValue, x => x.Order.Status == dto.Status)                                         //工单状态
             .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title))                       //工单标题
-            .WhereIF(!string.IsNullOrEmpty(dto.CurrentHandleOrgName), x => x.Order.CurrentHandleOrgName.Contains(dto.CurrentHandleOrgName)) //接办部门
+            .WhereIF(!string.IsNullOrEmpty(dto.CurrentHandleOrgName), x => x.Order.ActualHandleOrgName.Contains(dto.CurrentHandleOrgName)) //接办部门
             .WhereIF(dto.CurrentHandleTimeStart.HasValue, x => x.Order.CurrentHandleTime >= dto.CurrentHandleTimeStart)//接办时间Start
             .WhereIF(dto.CurrentHandleTimeEnd.HasValue, x => x.Order.CurrentHandleTime <= dto.CurrentHandleTimeEnd)    //接办时间End
             .WhereIF(!string.IsNullOrEmpty(dto.Hotspot), x => x.Order.HotspotSpliceName != null && x.Order.HotspotSpliceName.Contains(dto.Hotspot)) //热点
@@ -4124,7 +4124,8 @@ public class OrderController : BaseController
             .WhereIF(dto.CrTimeStart.HasValue, x => x.CreationTime >= dto.CrTimeStart)                               //催办时间Start
             .WhereIF(dto.CrTimeEnd.HasValue, x => x.CreationTime <= dto.CrTimeEnd)                                   //催办时间End
             .WhereIF(!string.IsNullOrEmpty(dto.OrgName), x => x.OrgName.Contains(dto.OrgName))                       //催办部门
-            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepCode), x => x.Order.CurrentStepCode == dto.CurrentStepCode) //当前办理节点
+            .WhereIF(!string.IsNullOrEmpty(dto.ApplyContent), x => x.ApplyContent.Contains(dto.ApplyContent))        //催办内容
+            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepName), x => x.Order.CurrentStepName == dto.CurrentStepName) //当前办理节点
             .WhereIF(dto.CrState.HasValue, x => x.State == dto.CrState)
             .OrderByDescending(x => x.CreationTime)
             .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);
@@ -9339,7 +9340,7 @@ public class OrderController : BaseController
             .WhereIF(!string.IsNullOrEmpty(dto.No), x => x.Order.No.Contains(dto.No))                                //工单编号
             .WhereIF(dto.Status.HasValue, x => x.Order.Status == dto.Status)                                         //工单状态
             .WhereIF(!string.IsNullOrEmpty(dto.Channel), x => x.Order.SourceChannelCode == dto.Channel)              //来源渠道
-            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepCode), x => x.Order.CurrentStepCode.Contains(dto.CurrentStepCode)) //当前节点
+            .WhereIF(!string.IsNullOrEmpty(dto.CurrentStepName), x => x.Order.CurrentStepName.Contains(dto.CurrentStepName)) //当前节点
             .WhereIF(!string.IsNullOrEmpty(dto.Title), x => x.Order.Title.Contains(dto.Title))                       //工单标题
             .WhereIF(dto.CreationTimeStart.HasValue, x => x.Order.CreationTime >= dto.CreationTimeStart)             //受理时间Start
             .WhereIF(dto.CreationTimeEnd.HasValue, x => x.Order.CreationTime <= dto.CreationTimeEnd)                 //受理时间End

src/Hotline.Api/Controllers/QualityController.cs

@@ -176,7 +176,7 @@ namespace Hotline.Api.Controllers
                 .WhereIF(!string.IsNullOrEmpty(dto.NameOrNo), x => x.Order.AcceptorName == dto.NameOrNo! || x.Order.AcceptorStaffNo == dto.NameOrNo!)   //受理人/坐席
                 .WhereIF(!string.IsNullOrEmpty(dto.FromPhone), x => x.Order.FromPhone.Contains(dto.FromPhone)) //来电号码
                 .WhereIF(!string.IsNullOrEmpty(dto.UserName), x => x.UserName.Contains(dto.UserName))          //质检人
-                .WhereIF(dto.QualityTimeStart.HasValue, x => x.QualityTime >= dto.QualityTimeStart)              //质检时间Star
+                .WhereIF(dto.QualityTimeStar.HasValue, x => x.QualityTime >= dto.QualityTimeStar)              //质检时间Star
                 .WhereIF(dto.QualityTimeEnd.HasValue, x => x.QualityTime <= dto.QualityTimeEnd)                //质检时间End
                 .OrderByDescending(x => x.CreationTime)
                 .ToPagedListAsync(dto.PageIndex, dto.PageSize, HttpContext.RequestAborted);

src/Hotline.Api/Controllers/Snapshot/SnapshotUserController.cs

@@ -0,0 +1,65 @@
+using Hotline.Application.Snapshot.Contracts;
+using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Share.Dtos;
+using Hotline.Share.Dtos.Snapshot;
+using Hotline.Share.Tools;
+using Hotline.Snapshot.IRepository;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel;
+
+namespace Hotline.Api.Controllers.Snapshot;
+
+[Description("随手拍用户管理")]
+public class SnapshotUserController : BaseController
+{
+    private readonly ISnapshotUserApplication _snapshotUserApplication;
+    private readonly ISafetyTypeRepository _safetyTypeRepository;
+
+    public SnapshotUserController(ISnapshotUserApplication snapshotUserApplication, ISafetyTypeRepository safetyTypeRepository)
+    {
+        _snapshotUserApplication = snapshotUserApplication;
+        _safetyTypeRepository = safetyTypeRepository;
+    }
+
+    /// <summary>
+    /// 获取添加安全志愿者和安全员分类关系的基础数据
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet("citizen_relation/basedata")]
+    public async Task<Dictionary<string, object>> GetCitizenRelationSafetyTypeBase()
+    {
+        var safetyTypes = await _safetyTypeRepository.Queryable()
+            .Select(m => new { m.Id, m.Name})
+            .ToListAsync(HttpContext.RequestAborted);
+        return new Dictionary<string, object>
+        {
+            { "safetyTypes", safetyTypes }
+        };
+    }
+
+    /// <summary>
+    /// 安全志愿者列表
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet("citizen_relation")]
+    public async Task<PagedDto<CitizenRelationSafetyTypeOutDto>> GetCitizenRelationSafetyType([FromQuery] CitizenRelationSafetyTypeInDto dto)
+        => (await _snapshotUserApplication.GetCitizenRelationSafetyType(dto).ToPagedListAsync(dto)).ToPaged();
+
+    /// <summary>
+    /// 添加安全志愿者和安全员分类关系
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpPost("citizen_relation")]
+    public async Task AddCitizenRelationSafetyTypeInDto([FromBody]AddCitizenRelationSafetyTypeInDto dto)
+        => await _snapshotUserApplication.AddCitizenRelationSafetyType(dto, HttpContext.RequestAborted);
+
+    /// <summary>
+    /// 批量删除安全志愿者分类关系
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <returns></returns>
+    [HttpDelete("citizen_relation")]
+    public async Task DeleteCitizenRelationSafetyType([FromBody] DeleteCitizenRelationSafetyTypeInDto dto)
+        => await _snapshotUserApplication.DeleteCitizenRelationSafetyAsync(dto);
+}

src/Hotline.Api/Controllers/TestController.cs

@@ -74,6 +74,7 @@ using XF.Domain.Queues;
 using XF.Domain.Repository;
 using Order = Hotline.Orders.Order;
 using OrderDto = Hotline.Share.Dtos.Order.OrderDto;
+using Hotline.Schedulings;
 
 namespace Hotline.Api.Controllers;
 
@@ -135,7 +136,8 @@ public class TestController : BaseController
     private readonly IServiceProvider _serviceProvider;
     private readonly IRepository<OrderDelay> _orderDelayRepository;
     private readonly IRepository<OrderSecondaryHandling> _orderSecondaryHandlingRepository;
-    private readonly IRepository<Message> _messageRepository;
+    private readonly IRepository<Message> _messageRepository; 
+    private readonly IRepository<Scheduling> _schedulingRepository;
 
 
     public TestController(
@@ -195,7 +197,8 @@ public class TestController : BaseController
         IServiceProvider serviceProvider,
         IRepository<OrderSecondaryHandling> orderSecondaryHandlingRepository,
         IRepository<Message> messageRepository
-        )
+,
+        IRepository<Scheduling> schedulingRepository)
     {
         _logger = logger;
         _options = options;
@@ -249,7 +252,22 @@ public class TestController : BaseController
         _orderDelayRepository = orderDelayRepository;
         _orderSecondaryHandlingRepository = orderSecondaryHandlingRepository;
         _messageRepository = messageRepository;
+        _schedulingRepository = schedulingRepository;
     }
+    /// <summary>
+    /// 测试
+    /// </summary>
+    /// <returns></returns>
+    [AllowAnonymous]
+    [HttpGet("test")]
+    public async Task Test()
+    {
+        var schedulingList = await _schedulingRepository.Queryable().Includes(x => x.SchedulingUser).Where(x => x.SchedulingTime!.Value.Date == DateTime.Now.Date).ToListAsync();
+        Random random = new Random();
+        int randomNum = random.Next(schedulingList.Count);
+        var userId = schedulingList[randomNum].SchedulingUser.UserId;
+    }
+
 
     /// <summary>
     /// 测试获取电话号码

src/Hotline.Api/Program.cs

@@ -40,7 +40,7 @@ try
         .ReadFrom.Configuration(ctx.Configuration), true)
         ;
     //builder.Services.AddControllers().AddNewtonsoftJson();
-	builder
+    builder
         .ConfigureServices()
         .ConfigurePipelines()
         .Run();

src/Hotline.Api/StartupHelper.cs

@@ -327,14 +327,14 @@ namespace Hotline.Api
                             .WithCronSchedule("0/5 * * * * ?")
                         );
 
-                        //var getOperationsJobKey = new JobKey(nameof(XingTangTelOperationSyncJob));
-                        //d.AddJob<XingTangTelOperationSyncJob>(getOperationsJobKey);
-                        //d.AddTrigger(t => t
-                        //    .WithIdentity("get-operationsxt-trigger")
-                        //    .ForJob(getOperationsJobKey)
-                        //    .StartNow()
-                        //    .WithCronSchedule("0/10 * * * * ?")
-                        //);
+                        var getOperationsJobKey = new JobKey(nameof(XingTangTelOperationSyncJob));
+                        d.AddJob<XingTangTelOperationSyncJob>(getOperationsJobKey);
+                        d.AddTrigger(t => t
+                            .WithIdentity("get-operationsxt-trigger")
+                            .ForJob(getOperationsJobKey)
+                            .StartNow()
+                            .WithCronSchedule("0/10 * * * * ?")
+                        );
 
                         var getCallSatisfactionJobKey = new JobKey(nameof(XingTangCallSatisfactionSyncJob));
                         d.AddJob<XingTangCallSatisfactionSyncJob>(getCallSatisfactionJobKey);

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

@@ -1,7 +1,7 @@
 {
   "AllowedHosts": "*",
   "AppConfiguration": {
-    "AppScope": "LuZhou",
+    "AppScope": "YiBin",
     "YiBin": {
       "AreaCode": "511500",
       "CallCenterType": "TianRun", //XunShi、WeiErXin、TianRun、XingTang
@@ -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.Api/config/appsettings.shared.Development.json

@@ -58,17 +58,16 @@
       //    "outputTemplate": "[{Timestamp:HH:mm:ss} {Level}] {SourceContext} [{TraceId}]{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}",
       //  }
       //},
-      //{
-      //  "Name": "MongoDBBson",
-      //  "Args": {
-      //    "databaseUrl": "mongodb://dev:fw123kj@110.188.24.182:57017/hotline_log?authSource=admin",
-      //    "collectionName": "logs",
-      //    "cappedMaxSizeMb": "1024",
-      //    "cappedMaxDocuments": "50000",
-      //    "rollingInterval": "Month",
-      //    "outputTemplate": "[{Timestamp:HH:mm:ss} {Level}] {SourceContext} [{TraceId}]{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}"
-      //  }
-      //}
+      {
+        "Name": "MongoDBBson",
+        "Args": {
+          "databaseUrl": "mongodb://dev:fw123kj@110.188.24.182:57017/123_log?authSource=admin",
+          "collectionName": "logs",
+          "cappedMaxSizeMb": "1024",
+          "cappedMaxDocuments": "50000",
+          "rollingInterval": "Month"
+        }
+      }
     ],
     "Enrich": [ "FromLogContext", "WithSpan" ]
   }

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
 {
@@ -11,6 +11,8 @@ namespace Hotline.Application.Exam.Constants.ApiRoutes
 
         public const string GetTrainPractice = "GetTrainPractice";
 
+        public const string GetSimpleTrainPractice = "GetSimpleTrainPractice";
+
         public const string CompleteTrainKnowladge = "CompleteTrainKnowladge";
 
         public const string CompleteTrainRecord = "CompleteTrainRecord";

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,8 +1,7 @@
-using Exam.ExamManages;
-
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Exam;
-using Hotline.Repository.SqlSugar.Interface;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.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 Hotline.Repository.SqlSugar.Interface;
+using Exam.Share.ViewResponses.Exam;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.ExamManages;
+using Hotline.Repository.SqlSugar.Exam.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,17 +1,16 @@
-
-using Exam.Practices;
-using Exam.Share;
+using Exam.Share;
 using Exam.Share.ViewResponses.Practices;
-using Hotline.Repository.SqlSugar.Interface;
+using Hotline.Exams.Practices;
+using Hotline.Repository.SqlSugar.Exam.Interface;
 using Hotline.Share.Dtos.Practices;
 using Hotline.Share.Requests.Exam;
 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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Questions;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.TestPapers;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Questions;
+using Hotline.Repository.SqlSugar.Exam.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 Hotline.Repository.SqlSugar.Interface;
+using Exam.Share.ViewResponses.Question;
+using Hotline.Exams.Questions;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Practices;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Questions;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Exam.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 Hotline.Repository.SqlSugar.Interface;
-using Hotline.Share.Dtos.Questions;
+using Exam.Share.ViewResponses.TestPaper;
+using Hotline.Exams.TestPapers;
+using Hotline.Repository.SqlSugar.Exam.Interface;
 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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Trains;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Trains;
+using Hotline.Repository.SqlSugar.Exam.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.Repository.SqlSugar.Interface;
+using Hotline.Exams.Trains;
+using Hotline.Repository.SqlSugar.Exam.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>
         /// 结束培训
@@ -33,6 +32,13 @@ namespace Train.Application.Interface.Train
         /// <returns></returns>
         Task<TrainPracticeDto> GetTrainPracticeAsync(TrainPracticeRequest trainPracticeRequest);
 
+        /// <summary>
+        /// 获取培训习题
+        /// </summary>
+        /// <param name="trainPracticeRequest"></param>
+        /// <returns></returns>
+        Task<SimpleTrainPracticeDto> GetSimpleTrainPracticeAsync(TrainPracticeRequest trainPracticeRequest);
+
         /// <summary>
         /// 完成培训课件学习
         /// </summary>

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

@@ -1,13 +1,12 @@
-
-using Exam.Share.ViewResponses.Train;
-using Exam.Trains;
-using Hotline.Repository.SqlSugar.Interface;
+using Exam.Share.ViewResponses.Train;
+using Hotline.Exams.Trains;
+using Hotline.Repository.SqlSugar.Exam.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,17 +1,18 @@
-using Exam.ExamManages;
-using Exam.Questions;
-using Exam.Repository.Sqlsugar.Repositories;
-using Hotline.Exams.ExamManages;
-using Hotline.Repository.SqlSugar;
+using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Exams;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
-using Hotline.Repository.SqlSugar.Extensions;
-using Hotline.Repository.SqlSugar.Interface;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
 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 +54,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.ExamQuestionBak> examQuestions = await SyncQuestion(questions, testPaperId, cancellationToken);
 
             var examQuestionOptionses = await SyncQuestionOptions(examQuestions, cancellationToken);
             var examQuestionSourcewares = await SyncQuestionSourcewares(examQuestions, cancellationToken);
@@ -116,17 +117,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.ExamQuestionAnswerBak>> SyncQuestionAnswer(List<Exams.ExamManages.ExamQuestionBak> 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.ExamQuestionAnswerBak>();
 
             questionAnswers.ForEach(item =>
             {
-                var examQuestionAnswer = _mapper.Map<ExamQuestionAnswer>(item);
+                var examQuestionAnswer = _mapper.Map<Exams.ExamManages.ExamQuestionAnswerBak>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionAnswer.QuestionAnswerId = item.Id;
                 examQuestionAnswer.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -140,17 +141,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.ExamQuestionKnowladgeBak>> SyncQuestionKnowladge(List<Exams.ExamManages.ExamQuestionBak> 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.ExamQuestionKnowladgeBak>();
 
             questionKnowladges.ForEach(item =>
             {
-                var examQuestionKnowladge = _mapper.Map<ExamQuestionKnowladge>(item);
+                var examQuestionKnowladge = _mapper.Map<Exams.ExamManages.ExamQuestionKnowladgeBak>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionKnowladge.KnowladgeId = item.Id;
                 examQuestionKnowladge.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -164,17 +165,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.ExamQuestionSourcewareBak>> SyncQuestionSourcewares(List<Exams.ExamManages.ExamQuestionBak> 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.ExamQuestionSourcewareBak>();
 
             questionSourcewares.ForEach(item =>
             {
-                var examQuestionSourceware = _mapper.Map<ExamQuestionSourceware>(item);
+                var examQuestionSourceware = _mapper.Map<Exams.ExamManages.ExamQuestionSourcewareBak>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionSourceware.SourcewareId = item.Id;
                 examQuestionSourceware.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -188,17 +189,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.ExamQuestionOptionsBak>> SyncQuestionOptions(List<Exams.ExamManages.ExamQuestionBak> 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.ExamQuestionOptionsBak>();
 
             questionOptions.ForEach(item =>
             {
-                var examQuestionOption = _mapper.Map<ExamQuestionOptions>(item);
+                var examQuestionOption = _mapper.Map<Exams.ExamManages.ExamQuestionOptionsBak>(item);
                 var examQuestion = examQuestions.FirstOrDefault(x => x.QuestionId == item.QuestionId);
                 examQuestionOption.QuestionOptionId = item.Id;
                 examQuestionOption.ExamQuestionId = examQuestion?.Id ?? string.Empty;
@@ -212,14 +213,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.ExamQuestionBak>> SyncQuestion(List<ExamQuestion> questions, string testPaperId, CancellationToken cancellationToken)
         {
 
-            var examQuestions = new List<ExamQuestion>();
+            var examQuestions = new List<Exams.ExamManages.ExamQuestionBak>();
 
             questions.ForEach(item =>
             {
-                var examQuestion = _mapper.Map<ExamQuestion>(item);
+                var examQuestion = _mapper.Map<Exams.ExamManages.ExamQuestionBak>(item);
                 examQuestion.ExamId = testPaperId;
                 examQuestion.QuestionId = item.Id;
                 examQuestions.Add(examQuestion);

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

@@ -1,17 +1,16 @@
-using Exam.Questions;
-using Exam.Repository.Sqlsugar.Repositories;
-using Exam.TestPapers;
-using Hotline.Exams.TestPapers;
+using Hotline.Exams.TestPapers;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.TestPapers;
-using Hotline.Repository.SqlSugar.Extensions;
 using MapsterMapper;
 using SqlSugar;
 using System.Threading;
+using Hotline.Exams.Questions;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
 using XF.Domain.Authentications;
 using XF.Domain.Repository;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 namespace Hotline.Application.Exam.Proxy
 {
@@ -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
 {
@@ -26,11 +24,11 @@ namespace Hotline.Application.Exam.QueryExtensions.ExamManages
             return expression;
         }
 
-        public static Expression<Func<ExamQuestion, bool>> GetExpression(this ExamQuestionRequest examQuestionRequest)
+        public static Expression<Func<ExamQuestionBak, bool>> GetExpression(this ExamQuestionRequest examQuestionRequest)
         {
-            Expression<Func<ExamQuestion, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamQuestionBak, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<ExamQuestion>()
+            expression = ExpressionableUtility.CreateExpression<ExamQuestionBak>()
                 .AndIF(examQuestionRequest.QuestionId.IsNotNullOrEmpty(), x => x.QuestionId == examQuestionRequest.QuestionId)
                 .AndIF(examQuestionRequest.ExamId.IsNotNullOrEmpty(), x => x.ExamId == examQuestionRequest.ExamId)
                 .ToExpression();

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,32 @@ namespace Hotline.Application.Exam.QueryExtensions.Trains
             return expression;
         }
 
-        public static Expression<Func<TrainPractice, bool>> GetExpression(this TrainQuestionRequest trainQuestionRequest)
+        public static Expression<Func<ExamTrainRecord, bool>> GetTrainRecordExpression(this TrainRecordPagedRequest trainRecordPagedRequest)
         {
-            Expression<Func<TrainPractice, bool>> expression = m => m.Id != null;
+            Expression<Func<ExamTrainRecord, bool>> expression = m => m.Id != null;
 
-            expression = ExpressionableUtility.CreateExpression<TrainPractice>()
+            expression = ExpressionableUtility.CreateExpression<ExamTrainRecord>()
+                .AndIF(trainRecordPagedRequest.UserId.IsNotNull(), x => x.UserId == trainRecordPagedRequest.UserId)
+                .ToExpression();
+
+            return expression;
+        }
+
+        public static Expression<Func<ExamTrainPractice, bool>> GetExpression(this TrainQuestionRequest trainQuestionRequest)
+        {
+            Expression<Func<ExamTrainPractice, bool>> expression = m => m.Id != null;
+
+            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,47 +1,37 @@
-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;
 using Hotline.Application.Exam.Interface.ExamManages;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
-using Hotline.Repository.SqlSugar.Interface;
-using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Exam;
-using JiebaNet.Segmenter.Common;
 using MapsterMapper;
 using SqlSugar;
 using XF.Domain.Dependency;
 using XF.Domain.Entities;
-using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Application.Exam.QueryExtensions.ExamManages;
 using XF.Domain.Exceptions;
-using NetTaste;
-using Exam.Infrastructure.Validation.Validation;
 using Hotline.Application.Exam.Extensions;
 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;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
-using Microsoft.AspNetCore.Http;
-using Hotline.Tools;
 using Hotline.Users;
-using System.Buffers;
-using Exam.Repository.Sqlsugar.Repositories.TestPapers;
+using Hotline.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 Hotline.Repository.SqlSugar.Exam.Repositories;
+using ExamErrorMessage = Hotline.Exams.Validate.ExamErrorMessage;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
@@ -259,17 +249,17 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             await base.DeleteAsync(entityQueryRequest, cancellationToken);
 
-            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionScore>()
+            var tmpEntityQueryRequest = ExpressionableUtility.CreateExpression<ExamQuestionScoreBak>()
                 .AndIF(entityQueryRequest.Id.IsNotNullOrEmpty(), x => x.ExamManageId == entityQueryRequest.Id)
                 .AndIF(entityQueryRequest.Ids.IsNotNullOrEmpty(), x => entityQueryRequest.Ids.Contains(x.ExamManageId))
-                .ToEntityQueryRequest<ExamQuestionScore>();
+                .ToEntityQueryRequest<ExamQuestionScoreBak>();
 
             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 +299,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 +328,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 +341,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);
@@ -390,7 +380,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             actionRequest.ExamQuestionScoreDtos.ForEach(x => x.ExamManageId = id);
         }
 
-        private async Task<List<ExamQuestionScore>> AddExamQuestionScores(AddExamManageDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionScoreBak>> AddExamQuestionScores(AddExamManageDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.ExamQuestionScoreDtos == null) return null;
 
@@ -398,7 +388,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var examQuestionScoreDtos = actionRequest.ExamQuestionScoreDtos.Where(x => x.OperationStatus == EEOperationStatus.Add).ToList();
 
-            var examQuestionScores = _mapper.Map<List<ExamQuestionScore>>(examQuestionScoreDtos);
+            var examQuestionScores = _mapper.Map<List<ExamQuestionScoreBak>>(examQuestionScoreDtos);
 
             examQuestionScores.ToInsert(_sessionContext);
 
@@ -407,7 +397,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 +405,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 +420,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 +436,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);
@@ -456,7 +446,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return userExams;
         }
 
-        private async Task<List<ExamQuestionScore>> UpdateExamQuestionScores(UpdateExamManageDto actionRequest, List<ExamQuestionScore> all, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionScoreBak>> UpdateExamQuestionScores(UpdateExamManageDto actionRequest, List<ExamQuestionScoreBak> all, CancellationToken cancellationToken)
         {
             if (actionRequest.ExamQuestionScoreDtos == null) return null;
 
@@ -472,7 +462,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             {
                 var examQuestionScoreDto = examQuestionScoreDtos.FirstOrDefault(x => x.Id == item.Id);
                 if (examQuestionScoreDto != null)
-                    item = _mapper.Map<UpdateExamQuestionScoreDto, ExamQuestionScore>(examQuestionScoreDto, item);
+                    item = _mapper.Map<UpdateExamQuestionScoreDto, ExamQuestionScoreBak>(examQuestionScoreDto, item);
             });
 
             examQuestionScores.ToUpdate(_sessionContext);
@@ -492,7 +482,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 +490,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 +498,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);
 
@@ -516,13 +506,13 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
         }
 
-        private async Task<List<ExamQuestionScore>> ModifyExamQuestionScores(UpdateExamManageDto actionRequest, CancellationToken cancellationToken)
+        private async Task<List<ExamQuestionScoreBak>> ModifyExamQuestionScores(UpdateExamManageDto actionRequest, CancellationToken cancellationToken)
         {
             if (actionRequest.ExamQuestionScoreDtos == null) return null;
 
             var all = await _examQuestionScoreRepository.Queryable().Where(x => x.ExamManageId == actionRequest.Id).ToListAsync();
 
-            var examQuestionScores = new List<ExamQuestionScore>();
+            var examQuestionScores = new List<ExamQuestionScoreBak>();
 
             examQuestionScores.AddRangeExt(await AddExamQuestionScores(_addExamManageDto, cancellationToken));
 
@@ -530,7 +520,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
             var examQuestionScoreDtos = actionRequest.ExamQuestionScoreDtos.Where(x => x.OperationStatus == EEOperationStatus.Delete);
             var ids = examQuestionScoreDtos.Select(m => m.Id);
-            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionScore>(ids);
+            EntityQueryRequest entityQueryRequest = ResovleDelete<ExamQuestionScoreBak>(ids);
 
             await DeleteExamQuestionScores(entityQueryRequest, cancellationToken);
 
@@ -582,7 +572,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 +587,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 +618,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 +650,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,8 +1,6 @@
 using Exam.Application.Interface.Exam;
-using Exam.ExamManages;
 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;
@@ -17,8 +15,11 @@ 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;
+using Hotline.Repository.SqlSugar.Exam.Service;
 
 namespace Hotline.Application.Exam.Service.ExamManages
 {
@@ -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,23 +1,24 @@
 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;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
-using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
+using Hotline.Repository.SqlSugar.Exam.Service;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.Tools;
@@ -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

@@ -1,36 +1,20 @@
-using DocumentFormat.OpenXml.Drawing;
-using DocumentFormat.OpenXml.Drawing.Charts;
-using DocumentFormat.OpenXml.Office2010.Excel;
-using Exam.Application.Interface.Exam;
-using Exam.ExamManages;
+using Exam.Application.Interface.Exam;
 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;
 using Hotline.Application.Exam.QueryExtensions.ExamManages;
 using Hotline.Application.Exam.Strategy;
 using Hotline.Exams.ExamManages;
-using Hotline.Exams.TestPapers;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.ExamManages;
-using Hotline.Repository.SqlSugar.Extensions;
-using Hotline.Repository.SqlSugar.Interface;
-using Hotline.Settings;
 using Hotline.Share.Dtos.ExamManages;
-using Hotline.Share.Dtos.Org;
 using Hotline.Share.Exams.Extensions;
 using Hotline.Share.Requests.Exam;
 using Hotline.Share.ViewResponses;
@@ -38,18 +22,21 @@ using Hotline.Share.ViewResponses.Exam;
 using Hotline.Users;
 using JiebaNet.Segmenter.Common;
 using MapsterMapper;
-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.Validate;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 using XF.Domain.Repository;
+using ExamQuestion = Hotline.Exams.Questions.ExamQuestion;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 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 +78,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.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(expression).FirstAsync();
 
             if (quesetion != null)
             {
@@ -99,9 +86,9 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 if (examQuestionDto.QuestionType.CheckSelectType())
                 {
-                    var questionOptions = await new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamQuestionId == quesetion.Id).ToListAsync();
+                    var questionOptions = await new ExamRepository<ExamQuestionOptionsBak>(_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 +120,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 +128,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 +140,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.ExamQuestionBak 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 +163,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.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
@@ -199,12 +186,12 @@ 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.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
             var queryable = await examManageTable.InnerJoin(testPaperItemTable, (e, i) => e.Id == i.ExamId)
                 .Select((e, i) => i).ToListAsync();
 
-            var examQuestionScores = await new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamManageId == examQuestionGroupRequest.ExamId).ToListAsync();
+            var examQuestionScores = await new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.ExamManageId == examQuestionGroupRequest.ExamId).ToListAsync();
 
             var userExamItemTable = _userExamItemRepository.Queryable();
             var userExamTable = _repository.Queryable().Where(x => x.ExamId == examQuestionGroupRequest.ExamId && x.UserId == examQuestionGroupRequest.UserId);
@@ -225,7 +212,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.ExamQuestionBak n, List<ExamQuestionScoreBak> examQuestionScores, List<ExamUserExamItem> userExamItems)
         {
             var examQuestionScore = examQuestionScores.FirstOrDefault(x => x.QuestionType == n.QuestionType);
             var userItem = userExamItems.FirstOrDefault(x => x.QuestionId == n.QuestionId);
@@ -259,7 +246,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 +260,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 +268,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 +327,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 +345,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 +361,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 +382,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 +402,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 +422,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 +442,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 = () =>
                 {
@@ -504,14 +491,14 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var expression = gradingExamRequest.GetExpression();
             var userExamTable = _repository.Queryable().Where(expression);
 
-            var questionScoreRepository = new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var questionScoreRepository = new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
 
             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 quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
-            var testPaperItemAnswerTable = new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var questionTable = new ExamRepository<Exams.ExamManages.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var quesitonOptionTable = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+            var testPaperItemAnswerTable = new ExamRepository<ExamQuestionAnswerBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
             var questionScoreTable = questionScoreRepository.Queryable();
 
             var queryResult = await userExamTable.InnerJoin(userExamItemTable, (e, i) => e.Id == i.UserExamId)
@@ -644,10 +631,10 @@ namespace Hotline.Application.Exam.Service.ExamManages
         {
             if (!addUserExamItemDto.QuestionType.CheckSelectType()) return;
 
-            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemOptionsRepository = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var examManageRepository = new ExamRepository<ExamManage>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var testPaperItemRepository = new ExamRepository<ExamQuestion>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
-            var examQuestionScoreRepository = new ExamRepository<ExamQuestionScore>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var testPaperItemRepository = new ExamRepository<Exams.ExamManages.ExamQuestionBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var examQuestionScoreRepository = new ExamRepository<ExamQuestionScoreBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider);
             var testPaperOptionsTable = testPaperItemOptionsRepository.Queryable().Where(x => x.QuestionId == addUserExamItemDto.QuestionId && x.IsAnswer);
             var testPaperItemTable = testPaperItemRepository.Queryable();
             var userExamTable = _repository.Queryable().Where(x => x.Id == addUserExamItemDto.UserExamId);
@@ -669,13 +656,14 @@ 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);
 
             userExamItem.UserExamItemOptionses = await AddUserExamItemOptions(addUserExamItemDto, cancellationToken);
 
-            userExamItem.ExamAnswers = await AddExamAnswer(addUserExamItemDto, cancellationToken);
+            userExamItem.ExamAnswers = await AddExamAnswer(addUserExamItemDto, userExamItem.Id, cancellationToken);
+            
 
             await userExamItemRepository.AddNav(userExamItem)
                 .Include(x => x.UserExamItemOptionses)
@@ -683,7 +671,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,17 +694,17 @@ 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.ExamQuestionBak>(_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.ExamQuestionBak, GradingExamQuestionDto>(testPaperItem, gradingExamQuestionDto);
 
                 var examAnswer = new ExamRepository<ExamAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().Where(x => x.UserExamItemId == userExamItem.Id).First();
 
-                var testPaperItemAnswer = await new ExamRepository<ExamQuestionAnswer>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.ExamQuestionId == testPaperItem.Id);
+                var testPaperItemAnswer = await new ExamRepository<ExamQuestionAnswerBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable().FirstAsync(x => x.QuestionId == testPaperItem.QuestionId && x.ExamQuestionId == testPaperItem.Id);
 
                 gradingExamQuestionDto.Answer = examAnswer.Answer ?? string.Empty;
 
@@ -730,7 +718,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             return null;
         }
 
-        private async Task<List<ExamAnswer>> AddExamAnswer(AddUserExamItemDto addUserExamItemDto, CancellationToken cancellationToken)
+        private async Task<List<ExamAnswer>> AddExamAnswer(AddUserExamItemDto addUserExamItemDto,string id, CancellationToken cancellationToken)
         {
             if (addUserExamItemDto.QuestionType.CheckSelectType()) return null;
 
@@ -739,6 +727,7 @@ namespace Hotline.Application.Exam.Service.ExamManages
             var examAnswer = new ExamAnswer
             {
                 UserId = _sessionContext.UserId,
+                UserExamItemId = id,
                 Answer = addUserExamItemDto.Answer
             };
 
@@ -753,7 +742,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.ExamQuestionBak>(_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,12 +763,12 @@ namespace Hotline.Application.Exam.Service.ExamManages
 
                 var userExamQuestionDto = new UserExamQuestionDto();
 
-                userExamQuestionDto = _mapper.Map<ExamQuestion, UserExamQuestionDto>(question, userExamQuestionDto);
+                userExamQuestionDto = _mapper.Map<Exams.ExamManages.ExamQuestionBak, UserExamQuestionDto>(question, userExamQuestionDto);
 
                 if (question.QuestionType.CheckSelectType())
                 {
                     var userExamItemOptionTable = _userExamItemOptionRepository.Queryable().Where(x => x.UserExamItemId == userExamItem.Id);
-                    var quesitonOptionTable = new ExamRepository<ExamQuestionOptions>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
+                    var quesitonOptionTable = new ExamRepository<ExamQuestionOptionsBak>(_uow, _dataPermissionFilterBuilder, _serviceProvider).Queryable();
 
                     var queryResult = userExamItemOptionTable.InnerJoin(quesitonOptionTable, (u, q) => u.QuestionOptionId == q.Id)
                         .Select((u, q) => new UserExamItemOptionDto
@@ -854,14 +843,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 +881,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 +890,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 +904,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 +928,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 +938,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 +950,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,9 @@
-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;
@@ -25,7 +17,6 @@ using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Core.Constants;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Practices;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
-using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos.Practices;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Dtos.TestPapers;
@@ -40,12 +31,17 @@ 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 Hotline.Repository.SqlSugar.Exam.Repositories;
 using XF.Domain.Authentications;
 using XF.Domain.Dependency;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 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,17 +343,17 @@ 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);
 
-            return await practiceResultItems.ToListAsync();
+            return await practiceResultItems.Distinct().ToListAsync();
         }
 
         private async Task<List<PracticeQuestionKnowladgeDto>> GetPracticeQuestionKnowladge(PracticeQuestionRequest practiceQuestionRequest)
@@ -378,13 +374,13 @@ namespace Hotline.Application.Exam.Service.Practices
                 });
 
 
-            return await queryResult.ToListAsync();
+            return await queryResult.Distinct().ToListAsync();
         }
 
         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);
@@ -401,7 +397,7 @@ namespace Hotline.Application.Exam.Service.Practices
                 });
 
 
-            return await queryResult.ToListAsync();
+            return await queryResult.Distinct().ToListAsync();
         }
 
         private async Task<List<PracticeQuestionOptionsDto>> GetPracticeQuestionOptions(PracticeQuestionRequest practiceQuestionRequest)
@@ -419,7 +415,7 @@ namespace Hotline.Application.Exam.Service.Practices
                     QuestionOptionId = o.QuestionOptionId
                 });
 
-            return await queryResult.ToListAsync();
+            return await queryResult.Distinct().ToListAsync();
         }
         private SqlSugar.ISugarQueryable<PracticeViewResponse> QueryResult(PracticePagedRequest queryRequest)
         {
@@ -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,22 +1,14 @@
 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;
 using Hotline.Exams.Sourcewares;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
-using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Requests.Question;
 using JiebaNet.Segmenter.Common;
@@ -38,11 +30,23 @@ 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.Repository.SqlSugar.Exam.Repositories;
 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;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 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.Repository.SqlSugar.Exam.Service;
 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,11 +1,8 @@
 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;
 using Exam.Infrastructure.Validation.Constants;
-using Exam.Insfrastructure.Service.Service;
 using Hotline.Exams.Sourcewares;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
@@ -17,7 +14,10 @@ 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;
+using Hotline.Repository.SqlSugar.Exam.Service;
 
 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,10 @@
 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;
@@ -25,7 +16,6 @@ using Hotline.Repository.SqlSugar.Exam.Core.Constants;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.TestPapers;
 using Hotline.Repository.SqlSugar.Exam.Repositories.TestPapers;
-using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Dtos.TestPapers;
 using Hotline.Share.Dtos.Trains;
@@ -40,13 +30,25 @@ 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 Hotline.Repository.SqlSugar.Exam.Repositories;
 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;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 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 +235,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 +330,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 +355,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 +388,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 +434,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 +442,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 +457,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 +465,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 +479,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 +488,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 +499,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 +523,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 +555,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 +564,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 +574,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 +593,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 +603,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 +622,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 +632,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 +640,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 +653,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 +661,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 +677,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 +685,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 +704,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 +714,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 +801,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 +815,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 +829,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 +868,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 +888,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 +907,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 +925,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 +945,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 +965,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 +981,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 +1001,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 +1017,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 +1025,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 +1039,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 +1047,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 +1063,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 +1087,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,25 +1,23 @@
 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;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Core.Constants;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Trains;
-using Hotline.Repository.SqlSugar.Extensions;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
+using Hotline.Repository.SqlSugar.Exam.Service;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
 using Hotline.Users;
@@ -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,20 +1,16 @@
 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;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Trains;
-using Hotline.Repository.SqlSugar.Extensions;
 using Hotline.Share.Dtos.Questions;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Exam;
@@ -28,10 +24,17 @@ using XF.Domain.Dependency;
 using XF.Domain.Exceptions;
 using Hotline.Share.Exams.Extensions;
 using NPOI.SS.Formula.Functions;
+using Hotline.Repository.SqlSugar.Exam.Repositories.Trains;
+using static NPOI.HSSF.Util.HSSFColor;
+using DocumentFormat.OpenXml.Drawing.Charts;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
+using JiebaNet.Segmenter.Common;
+using Hotline.Repository.SqlSugar.Exam.Service;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 
 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 +66,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 +74,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);
 
@@ -131,14 +134,16 @@ namespace Hotline.Application.Exam.Service.Trains
 
         public async Task<TrainPracticeDto> GetTrainPracticeAsync(TrainPracticeRequest trainPracticeRequest)
         {
-            var trainPracticeRepostitory = new TrainPracticeRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            SqlSugar.ISugarQueryable<ExamTrainPractice> trainPractices = GetTrainPractices(trainPracticeRequest);
 
-            var trainPractice = await trainPracticeRepostitory.GetAsync(trainPracticeRequest.TrainPracticeId);
+            var trainPractice = await trainPractices.FirstAsync();
 
             if (trainPractice == null) return null;
 
             var trainPracticeDto = _mapper.Map<TrainPracticeDto>(trainPractice);
 
+            trainPracticeRequest.TrainPracticeId = trainPractice.Id;
+
             trainPracticeDto.TrainPracticeOptionsDtos = await GetTrainQuestionOptions(trainPracticeRequest);
 
             trainPracticeDto.TrainPracticeSourcewareDtos = await GetTrainPracticeSourcewares(trainPracticeRequest);
@@ -148,6 +153,23 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPracticeDto;
         }
 
+        public async Task<SimpleTrainPracticeDto> GetSimpleTrainPracticeAsync(TrainPracticeRequest trainPracticeRequest)
+        {
+            SqlSugar.ISugarQueryable<ExamTrainPractice> trainPractices = GetTrainPractices(trainPracticeRequest);
+
+            var trainPractice = await trainPractices.FirstAsync();
+
+            if (trainPractice == null) return null;
+
+            var trainPracticeDto = _mapper.Map<TrainPracticeDto>(trainPractice);
+
+            trainPracticeRequest.TrainPracticeId = trainPractice.Id;
+
+            trainPracticeDto.TrainPracticeOptionsDtos = await GetTrainQuestionOptions(trainPracticeRequest);
+
+            return trainPracticeDto;
+        }
+
         public async Task<TrainResultPagedViewResponse> AnalysisTrainResult(TrainResultReportPagedRequest trainResultReportPagedRequest)
         {
             trainResultReportPagedRequest.ResoleEndTime();
@@ -155,9 +177,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 +219,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 +256,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);
 
@@ -244,9 +266,11 @@ namespace Hotline.Application.Exam.Service.Trains
         private SqlSugar.ISugarQueryable<TrainRecordViewResponse> QueryResult(TrainRecordPagedRequest queryRequest)
         {
             var trainPlanRepository = new TrainPlanRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            queryRequest.UserId = _sessionContext.UserId;
             var expression = queryRequest.GetExpression();
             var trainPlanTable = trainPlanRepository.Queryable().Where(expression);
-            var trainRecordTable = _repository.Queryable();
+            var traiRecordExpression = queryRequest.GetTrainRecordExpression();
+            var trainRecordTable = _repository.Queryable().Where(traiRecordExpression);
 
             var queryResult = trainPlanTable.InnerJoin(trainRecordTable, (p, r) => p.Id == r.TrainPlanId)
                             .Select((p, r) => new TrainRecordViewResponse
@@ -273,9 +297,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 +320,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 +341,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 +360,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()
@@ -358,17 +382,41 @@ namespace Hotline.Application.Exam.Service.Trains
             return trainPracticeDto;
         }
 
+        private SqlSugar.ISugarQueryable<ExamTrainPractice> GetTrainPractices(TrainPracticeRequest trainPracticeRequest)
+        {
+            var trainPracticeRepostitory = new TrainPracticeRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanRepository = new TrainPlanRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+            var trainPlanTemplateRepository = new TrainPlanTemplateRepository(_uow, _dataPermissionFilterBuilder, _serviceProvider);
+
+            var trainRecordTable = _repository.Queryable().Where(x => x.Id == trainPracticeRequest.Id);
+            var trainPlanTable = trainPlanRepository.Queryable();
+            var trainPracticeTable = trainPracticeRepostitory.Queryable().WhereIF(!string.IsNullOrEmpty(trainPracticeRequest.TrainPracticeId),x=>x.Id == trainPracticeRequest.TrainPracticeId);
+            var tranPlanTemplateTable = trainPlanTemplateRepository.Queryable();
+
+            var trainPractices = trainPracticeTable.InnerJoin(tranPlanTemplateTable, (tp, tpt) => tp.TrainTemplateId == tpt.TrainTemplateId)
+                .InnerJoin(trainPlanTable, (tp, tpt, tpn) => tpt.TrainPlanId == tpn.Id)
+                .InnerJoin(trainRecordTable, (tp, tpt, tpn, tr) => tpn.Id == tr.TrainPlanId)
+                .Select((tp, tpt, tpn, tr) => tp)
+                .OrderBy(tp => tp.CreationTime);
+            return trainPractices;
+        }
+
         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 trainPracticeOptionsRepository = 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 trainPractices = GetTrainPractices(trainPracticeRequest);
+
+            var trainPracticeOptions = await trainPracticeOptionsRepository.Queryable()
+                .InnerJoin(trainPractices, (tpo, tp) => tpo.TrainPracticeId == tp.Id)
+                .Where((tpo, tp)=> tp.Id == trainPracticeRequest.TrainPracticeId)
+                .Select((tpo, tp) => tpo).ToListAsync();
 
             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 +437,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 +461,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,32 +1,23 @@
-using DocumentFormat.OpenXml.Office2010.Excel;
-using Exam.Application.Interface.Train;
-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.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.TestPapers;
+using Hotline.Exams.Questions;
 using Hotline.Exams.Trains;
 using Hotline.Repository.SqlSugar;
 using Hotline.Repository.SqlSugar.DataPermissions;
 using Hotline.Repository.SqlSugar.Exam.Core.Constants;
+using Hotline.Repository.SqlSugar.Exam.Extensions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Questions;
 using Hotline.Repository.SqlSugar.Exam.Interfaces.Trains;
-using Hotline.Repository.SqlSugar.Extensions;
-using Hotline.Repository.SqlSugar.Interface;
-using Hotline.Share.Dtos.Questions;
+using Hotline.Repository.SqlSugar.Exam.Repositories;
+using Hotline.Repository.SqlSugar.Exam.Service;
 using Hotline.Share.Dtos.Trains;
 using Hotline.Share.Requests.Train;
 using JiebaNet.Segmenter.Common;
@@ -37,7 +28,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 +108,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 +177,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 +210,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 +220,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 +237,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 +255,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 +270,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 +290,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 +307,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 +317,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 +332,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 +342,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 +357,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 +377,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 +411,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 +446,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 +454,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 +473,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 +481,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 +492,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 +508,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 +525,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 +537,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 +546,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 +562,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 +580,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 +592,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 +618,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 +636,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)