修改

IRaCIS.Core.Application/Service/Reading/Dto/ReadingCalculateViewModel.cs

@@ -205,6 +205,8 @@ namespace IRaCIS.Core.Application.Service.Reading.Dto
     {
         public Guid RowId { get; set; }
 
+        public Guid AnswerId { get; set; }
+
         /// <summary>
         /// 答案
         /// </summary>

IRaCIS.Core.Application/Service/ReadingCalculate/GeneralCalculateService.cs

@@ -83,6 +83,7 @@ namespace IRaCIS.Core.Application.Service.ReadingCalculate
             var tableQuestion = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == visitTaskId).Include(x => x.ReadingTableQuestionTrial).Select(x => new TableQuestionInfo()
             {
                 Answer = x.Answer,
+                AnswerId=x.Id,
                 QuestionMark = x.ReadingTableQuestionTrial.QuestionMark,
                 TableQuestionId = x.TableQuestionId,
                 QuestionId = x.QuestionId,

IRaCIS.Core.Application/Service/ReadingCalculate/PCWG3CalculateService.cs

@@ -292,6 +292,7 @@ namespace IRaCIS.Core.Application.Service.ReadingCalculate
                 {
                     var LastVisitTaskId = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
                     x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
+                     x.IsAnalysisCreate == taskinfo.IsAnalysisCreate &&
                     x.SubjectId == taskinfo.SubjectId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTaskNum < taskinfo.VisitTaskNum && x.TaskState == TaskState.Effect && x.ArmEnum == taskinfo.ArmEnum
                     ).OrderByDescending(x => x.VisitTaskNum).Select(x => x.Id).FirstOrDefaultAsync();
 

IRaCIS.Core.Application/Service/ReadingCalculate/RECIST1Point1CalculateService.cs

@@ -588,6 +588,7 @@ namespace IRaCIS.Core.Application.Service.ReadingCalculate
 
                     var LastVisitTaskId = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
                     x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
+                    x.IsAnalysisCreate== taskinfo.IsAnalysisCreate&&
                     x.SubjectId == taskinfo.SubjectId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTaskNum < taskinfo.VisitTaskNum && x.TaskState == TaskState.Effect && x.ArmEnum == taskinfo.ArmEnum
                     ).OrderByDescending(x => x.VisitTaskNum).Select(x => x.Id).FirstOrDefaultAsync();
 

IRaCIS.Core.Application/Service/ReadingCalculate/ReadingCalculateService.cs

@@ -17,7 +17,8 @@ namespace IRaCIS.Core.Application.Service.ReadingCalculate
         Dictionary<CriterionType, Type> CalculateServiceDic = new Dictionary<CriterionType, Type>()
         {
             {CriterionType.RECIST1Pointt1,typeof(RECIST1Point1CalculateService) }, //RECIST1.1
-            {CriterionType.PCWG3,typeof(PCWG3CalculateService) } 
+            {CriterionType.PCWG3,typeof(PCWG3CalculateService) },
+            {CriterionType.SelfDefine,typeof(SelfDefineCalculateService) }
         };
 
        

IRaCIS.Core.Application/Service/ReadingCalculate/SelfDefineCalculateService.cs

@@ -0,0 +1,330 @@
+using IRaCIS.Core.Application.Service.Reading.Dto;
+using IRaCIS.Core.Domain.Share;
+using Microsoft.AspNetCore.Mvc;
+using IRaCIS.Core.Domain.Models;
+using Microsoft.AspNetCore.Mvc;
+using IRaCIS.Core.Application.Interfaces;
+using IRaCIS.Core.Application.ViewModel;
+using Panda.DynamicWebApi.Attributes;
+using IRaCIS.Core.Infra.EFCore.Common;
+using Microsoft.Extensions.Caching.Memory;
+
+using IRaCIS.Core.Infrastructure;
+using MassTransit;
+
+namespace IRaCIS.Core.Application.Service.ReadingCalculate
+{
+    [ApiExplorerSettings(GroupName = "Reading")]
+    public class SelfDefineCalculateService : BaseService, ICriterionCalculateService
+    {
+        private readonly IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository;
+        private readonly IRepository<VisitTask> _visitTaskRepository;
+        private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
+        private readonly IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository;
+        private readonly IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository;
+        private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;
+        private readonly IRepository<SubjectVisit> _subjectVisitRepository;
+        private readonly IRepository<DicomStudy> _dicomStudyRepository;
+        private readonly IRepository<NoneDicomStudy> _noneDicomStudyRepository;
+        private readonly IRepository<TumorAssessment> _tumorAssessmentRepository;
+        private readonly IGeneralCalculateService _generalCalculateService;
+        private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository;
+
+        public SelfDefineCalculateService(
+            IRepository<ReadingTableQuestionAnswer> readingTableQuestionAnswerRepository,
+            IRepository<VisitTask> visitTaskRepository,
+            IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
+            IRepository<ReadingTableQuestionTrial> readingTableQuestionTrialRepository,
+            IRepository<ReadingTableAnswerRowInfo> readingTableAnswerRowInfoRepository,
+            IRepository<ReadingQuestionTrial> readingQuestionTrialRepository,
+            IRepository<SubjectVisit> subjectVisitRepository,
+              IRepository<DicomStudy> dicomStudyRepository,
+                IRepository<NoneDicomStudy> noneDicomStudyRepository,
+            IRepository<TumorAssessment> tumorAssessmentRepository,
+            IGeneralCalculateService generalCalculateService,
+            IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswerRepository
+            )
+        {
+            this._readingTableQuestionAnswerRepository = readingTableQuestionAnswerRepository;
+            this._visitTaskRepository = visitTaskRepository;
+            this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
+            this._readingTableQuestionTrialRepository = readingTableQuestionTrialRepository;
+            this._readingTableAnswerRowInfoRepository = readingTableAnswerRowInfoRepository;
+            this._readingQuestionTrialRepository = readingQuestionTrialRepository;
+            this._subjectVisitRepository = subjectVisitRepository;
+            this._dicomStudyRepository = dicomStudyRepository;
+            this._noneDicomStudyRepository = noneDicomStudyRepository;
+            this._tumorAssessmentRepository = tumorAssessmentRepository;
+            this._generalCalculateService = generalCalculateService;
+            this._readingTaskQuestionAnswerRepository = readingTaskQuestionAnswerRepository;
+        }
+
+        private List<SiteVisitForTumor> siteVisitForTumorList = null;
+
+
+        #region 删除病灶获取起始病灶序号
+        /// <summary>
+        /// 删除病灶获取起始病灶序号
+        /// </summary>
+        /// <returns></returns>
+        public async Task<int> GetDeleteLesionStatrIndex(DeleteReadingRowAnswerInDto inDto)
+        {
+            return 1;
+
+
+        }
+        #endregion
+
+        #region 获取阅片报告
+        /// <summary>
+        /// 获取阅片报告
+        /// </summary>
+        /// <param name="indto"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public async Task<GetReadingReportEvaluationOutDto> GetReadingReportEvaluation(GetReadingReportEvaluationInDto indto)
+        {
+            GetReadingReportEvaluationOutDto result = new GetReadingReportEvaluationOutDto();
+
+            result.CalculateResult = await this.GetReportVerify(new GetReportVerifyInDto()
+            {
+                VisitTaskId = indto.VisitTaskId
+            });
+
+            var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == indto.VisitTaskId).FirstNotNullAsync();
+
+
+            result.ReadingTaskState = visitTaskInfo.ReadingTaskState;
+            var taskInfoList = await _generalCalculateService.GetReadingReportTaskList(indto.VisitTaskId);
+
+            result.VisitTaskList = taskInfoList;
+
+            var visitTaskIds = taskInfoList.Select(x => x.VisitTaskId).ToList();
+
+            var criterionId = visitTaskInfo.TrialReadingCriterionId;
+            var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == criterionId).ToListAsync();
+            var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == criterionId).OrderBy(x => x.ShowOrder).ToListAsync();
+            var tableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == indto.VisitTaskId).ProjectTo<TableAnsweRowInfo>(_mapper.ConfigurationProvider).ToListAsync();
+
+            var answers = await _readingTaskQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
+            var tableAnswers = await _readingTableQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
+
+
+            // 第一级
+
+            #region 构造问题
+            List<ReadingReportDto> questions = questionList.Where(x => x.Type == ReadingQestionType.Group).OrderBy(x => x.ShowOrder).Select(x => new ReadingReportDto()
+            {
+                QuestionId = x.Id,
+                GroupName = x.GroupName,
+                IsShowInDicom = x.IsShowInDicom,
+                Type = x.Type,
+                QuestionType = x.QuestionType,
+                LesionType = x.LesionType,
+                QuestionGenre = x.QuestionGenre,
+                DictionaryCode = x.DictionaryCode,
+                TypeValue = x.TypeValue,
+                QuestionName = x.QuestionName,
+                ShowOrder = x.ShowOrder,
+                ValueType = x.ValueType,
+                Unit = x.Unit,
+                ReportLayType = ReportLayType.Group,
+            }).ToList();
+
+            // 分组
+            foreach (var item in questions)
+            {
+                item.Childrens = questionList.Where(x => x.GroupName == item.GroupName && x.Type != ReadingQestionType.Group).OrderBy(x => x.ShowOrder).Select(x => new ReadingReportDto()
+                {
+                    GroupName = x.GroupName,
+                    QuestionId = x.Id,
+                    IsShowInDicom = x.IsShowInDicom,
+                    QuestionName = x.QuestionName,
+                    LesionType = x.LesionType,
+                    QuestionGenre = x.QuestionGenre,
+                    DictionaryCode = x.DictionaryCode,
+                    Type = x.Type,
+                    QuestionType = x.QuestionType,
+                    TypeValue = x.TypeValue,
+                    ShowOrder = x.ShowOrder,
+                    OrderMark = x.OrderMark,
+                    ValueType = x.ValueType,
+                    Unit = x.Unit,
+                    ReportLayType = ReportLayType.Question,
+                }).ToList();
+
+                // 问题
+                foreach (var question in item.Childrens)
+                {
+
+                    foreach (var task in taskInfoList)
+                    {
+
+                        question.Answer.Add(new TaskQuestionAnswer()
+                        {
+                            Answer = answers.Where(x => x.VisitTaskId == task.VisitTaskId && x.ReadingQuestionTrialId == question.QuestionId).Select(x => x.Answer).FirstIsNullReturnEmpty(),
+                            TaskName = task.TaskName,
+                            VisitTaskId = task.VisitTaskId,
+                        });
+                    }
+
+                    // 构造表格行数据
+
+
+                    var rowlist = tableAnsweRowInfos.Where(x => x.QuestionId == question.QuestionId).OrderBy(x => x.RowIndex).ToList();
+
+
+                    question.Childrens = rowlist.Select(x => new ReadingReportDto()
+                    {
+                        QuestionName = question.OrderMark + x.RowIndex.GetLesionMark(),
+                        SplitOrMergeLesionName = x.MergeName.IsNullOrEmpty() ? x.SplitName : x.MergeName,
+                        SplitOrMergeType = x.SplitOrMergeType,
+                        LesionType = question.LesionType,
+                        IsCanEditPosition = x.IsCanEditPosition,
+                        RowIndex = x.RowIndex,
+                        BlindName = x.BlindName,
+                        ReportLayType = ReportLayType.Lesions,
+                    }).ToList();
+
+
+                    foreach (var row in question.Childrens)
+                    {
+                        // tableQuestion
+                        row.Childrens = tableQuestionList.Where(x => x.ReadingQuestionId == question.QuestionId).Select(x => new ReadingReportDto()
+                        {
+                            QuestionName = x.QuestionName,
+                            QuestionId = x.ReadingQuestionId,
+                            TableQuestionId = x.Id,
+                            Type = x.Type,
+                            LesionType = question.LesionType,
+                            TableQuestionType = x.TableQuestionType,
+                            DictionaryCode = x.DictionaryCode,
+                            QuestionMark = x.QuestionMark,
+                            TypeValue = x.TypeValue,
+                            RowIndex = row.RowIndex,
+                            ShowOrder = x.ShowOrder,
+                            ValueType = x.ValueType,
+                            Unit = x.Unit,
+                            ReportLayType = ReportLayType.TableQuestion,
+                        }).ToList();
+
+
+                        foreach (var tableQuestion in row.Childrens)
+                        {
+                            foreach (var task in taskInfoList)
+                            {
+
+                                tableQuestion.Answer.Add(new TaskQuestionAnswer()
+                                {
+                                    Answer = tableAnswers.Where(x => x.VisitTaskId == task.VisitTaskId && x.QuestionId == tableQuestion.QuestionId && x.RowIndex == tableQuestion.RowIndex && x.TableQuestionId == tableQuestion.TableQuestionId).Select(x => x.Answer).FirstIsNullReturnEmpty(),
+                                    TaskName = task.TaskName,
+                                    VisitTaskId = task.VisitTaskId,
+                                });
+                            }
+                        }
+
+
+                    }
+
+
+                };
+            }
+            #endregion
+
+
+
+            result.TaskQuestions = questions;
+
+
+
+            return result;
+
+
+        }
+        #endregion
+
+        /// <summary>
+        /// 将上一次的病灶信息添加到这一次
+        /// </summary>
+        /// <param name="inDto"></param>
+        /// <returns></returns>
+        public async Task<AddTaskLesionAnswerFromLastTaskOutDto> AddTaskLesionAnswerFromLastTask(AddTaskLesionAnswerFromLastTaskInDto inDto)
+        {
+
+            var visitTaskId = inDto.VisitTaskId;
+
+            var taskinfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();
+
+            var baseLineVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == taskinfo.SubjectId && x.IsBaseLine).Select(x => x.Id).FirstOrDefaultAsync();
+
+
+            return new AddTaskLesionAnswerFromLastTaskOutDto()
+            {
+
+                IsBaseLine = taskinfo.SourceSubjectVisitId == baseLineVisitId,
+            };
+        }
+
+        /// <summary>
+        /// 测试计算
+        /// </summary>
+        /// <param name="visitTaskId"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public async Task TestCalculate(Guid visitTaskId, QuestionType type)
+        {
+            ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(visitTaskId);
+            await ReadingCalculate(readingData, new List<QuestionType>() { type });
+        }
+
+        /// <summary>
+        /// 计算任务
+        /// </summary>
+        /// <param name="inDto"></param>
+        /// <returns></returns>
+        [HttpPost]
+        public async Task CalculateTask(CalculateTaskInDto inDto)
+        {
+            ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(inDto.VisitTaskId);
+            readingData.IsChangeOtherTask = inDto.IsChangeOtherTask;
+            await ReadingCalculate(readingData);
+        }
+
+
+        /// <summary>
+        /// 自动计算
+        /// </summary>
+        /// <param name="inDto"></param>
+        /// <param name="calculateType"></param>
+        /// <returns></returns>
+        public async Task ReadingCalculate(ReadingCalculateDto inDto, List<QuestionType> calculateType = null)
+        {
+            //var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.CriterionId && x.CustomCalculateMark != null).ToListAsync();
+            //var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == inDto.CriterionId && x.CustomCalculateMark != null).ToListAsync();
+
+
+          
+
+
+        }
+
+
+   
+
+     
+
+
+        public async Task<object> GetReportVerify(GetReportVerifyInDto inDto)
+        {
+            return new() { 
+            
+            };
+        }
+
+        public async Task VerifyVisitTaskQuestions(VerifyVisitTaskQuestionsInDto inDto)
+        {
+           
+        }
+    }
+}