irc-netcore-api/IRaCIS.Core.Application/Service/Reading/ReadingImageTask/ReadingNoDicomTaskService.cs

using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Application.Filter;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Domain.Share;
using MassTransit;
using Microsoft.AspNetCore.Mvc;
using Panda.DynamicWebApi.Attributes;
using System.Linq.Dynamic.Core;

namespace IRaCIS.Core.Application.Service
{

    /// <summary>
    /// 非Dicom
    /// </summary>
    public partial class ReadingImageTaskService : BaseService, IReadingImageTaskService
    {
        /// <summary>
        /// 提交访视阅片问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<IResponseOutput> SubmitVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);
            await this.SaveVisitTaskQuestions(inDto);


            await this.SubmitTaskChangeState(inDto.VisitTaskId);
            return ResponseOutput.Ok(true);
        }


        /// <summary>
        /// 添加非Dicom标记
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddNoneDicomMark(AddNoneDicomMarkInDto inDto)
        {
            var entity = await _readingNoneDicomMarkRepository.InsertOrUpdateAsync(inDto, true);
            return ResponseOutput.Ok(entity.Id);
        }

        /// <summary>
        /// 获取非Dicom标记
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetNoneDicomMarkListOutDto> GetNoneDicomMarkListOutDto(GetNoneDicomMarkListInDtoDto inDto)
        {
            var result = await _readingNoneDicomMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId)

                .ProjectTo<AddNoneDicomMarkInDto>(_mapper.ConfigurationProvider)
                .ToListAsync();

            return new GetNoneDicomMarkListOutDto()
            {
                NoneDicomMarkList = result
            };
        }

        /// <summary>
        /// 删除非Dicom标记
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("{id:guid}")]
        public async Task<IResponseOutput> DeleteTrialFileType(Guid id)
        {
            var success = await _readingNoneDicomMarkRepository.DeleteFromQueryAsync(t => t.Id == id, true);
            return ResponseOutput.Ok();
        }

        /// <summary>
        /// 保存任务问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TrialGlobalLimit("AfterStopCannNotOpt")]
        public async Task<IResponseOutput> SaveVisitTaskQuestions(SubmitVisitTaskQuestionsInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);
            var subjectId = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.SubjectId).FirstOrDefaultAsync();
            await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId);
            List<ReadingTaskQuestionAnswer> readingTaskAnswerList = inDto.AnswerList.Select(x => new ReadingTaskQuestionAnswer()
            {
                Id = NewId.NextGuid(),
                SubjectId = subjectId,
                Answer = x.Answer,
                ReadingQuestionCriterionTrialId = inDto.ReadingQuestionCriterionTrialId,
                ReadingQuestionTrialId = x.ReadingQuestionTrialId,
                VisitTaskId = inDto.VisitTaskId,
                TrialId = inDto.TrialId
            }).ToList();

            await _readingTaskQuestionAnswerRepository.AddRangeAsync(readingTaskAnswerList);
            var result = await _visitTaskRepository.SaveChangesAsync();
            return ResponseOutput.Ok(result);
        }

        /// <summary>
        /// 获取阅片非Dicom文件
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput<List<NoneDicomStudyView>>> GetReadingImageFile(GetReadingImgInDto inDto)
        {
            var task = await GetNextTask(new GetNextTaskInDto()
            {
                TrialId = inDto.TrialId,
                SubjectId = inDto.SubjectId,
                VisitTaskId = inDto.VisistTaskId,
            });
            List<Guid> visitIds = new List<Guid>();
            if (task.ReadingCategory == ReadingCategory.Visit)
            {
                visitIds.Add(task.VisistId);
            }
            else
            {
                // 阅片期取前面所有的图像
                visitIds.AddRange(await _subjectVisitRepository.Where(x => x.VisitNum <= task.VisitNum && x.SubjectId == task.SubjectId).Select(x => x.Id).ToListAsync());
            }

            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisistTaskId).Select(t => new { t.BlindSubjectCode, t.ReadingTaskState, t.TrialReadingCriterionId, t.TrialReadingCriterion.IsImageFilter, t.TrialReadingCriterion.CriterionModalitys }).FirstNotNullAsync();



            IQueryable<NoneDicomStudyView> noneDicomStudyQueryable = default;

            noneDicomStudyQueryable = _noneDicomStudyRepository.Where(t => t.IsReading)
                .Where(t => visitIds.Contains(t.SubjectVisitId) && t.NoneDicomFileList.Any(t => !t.FileType.Contains(StaticData.FileType.Zip)))
                .WhereIf(taskinfo.IsImageFilter == true, t => taskinfo.CriterionModalitys.Contains(t.Modality))
                .ProjectTo<NoneDicomStudyView>(_mapper.ConfigurationProvider, new { isFilterZip = true, isReading = true });

            if (inDto.VisistTaskId != null && _noneDicomStudyFileSystem.Any(t => t.VisitTaskId == inDto.VisistTaskId))
            {
                noneDicomStudyQueryable = _noneDicomStudyRepository.Where(t => t.IsReading)
                    .Where(t => t.TaskNoneDicomFileList.Any(t => t.VisitTaskId == inDto.VisistTaskId))
                .Where(t => taskinfo.IsImageFilter ? ("|" + taskinfo.CriterionModalitys + "|").Contains("|" + t.Modality + "|") : true)
                .Where(t => visitIds.Contains(t.SubjectVisitId))
                     .ProjectTo<TaskDicomStudyView>(_mapper.ConfigurationProvider, new { isFilterZip = true, isReading = true, visiTaskId = inDto.VisistTaskId });
            }

            List<NoneDicomStudyView> result = await noneDicomStudyQueryable.OrderBy(x => x.ImageDate).ThenBy(x => x.CreateTime).ToListAsync();


            var nonoDicomStudyFileIds = await _readingNoneDicomMarkRepository.Where(x => x.VisitTaskId == inDto.VisistTaskId).ToListAsync();
            if (nonoDicomStudyFileIds.Count > 0 && taskinfo.ReadingTaskState == ReadingTaskState.HaveSigned)
            {
                var studyId = nonoDicomStudyFileIds.Select(x => x.StudyId).FirstOrDefault();

                var noneDicomids = nonoDicomStudyFileIds.Select(x => x.NoneDicomFileId).ToList();
                var noneDicomStudyViewMark = new NoneDicomStudyView() { Id = Guid.NewGuid() };
                noneDicomStudyViewMark.IsCriticalSequence = true;
                noneDicomStudyViewMark.NoneDicomStudyFileList = await _noneDicomStudyFileRepository.Where(x => noneDicomids.Contains(x.Id)).ProjectTo<NoneDicomStudyFileView>(_mapper.ConfigurationProvider).ToListAsync();

                foreach (var item in noneDicomStudyViewMark.NoneDicomStudyFileList)
                {
                    item.MarkTime = nonoDicomStudyFileIds.Where(x => x.NoneDicomFileId == item.Id).Select(x => x.CreateTime).FirstOrDefault();
                }

                noneDicomStudyViewMark.NoneDicomStudyFileList= noneDicomStudyViewMark.NoneDicomStudyFileList.OrderBy(x => x.MarkTime).ToList();
                result.Insert(0, noneDicomStudyViewMark);
            }



            var trialInfo = await _trialRepository.Where(x => x.Id == inDto.TrialId).Select(x => new
            {
                x.ClinicalInformationTransmissionEnum,
            }).FirstOrDefaultAsync();


            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskinfo.TrialReadingCriterionId).Select(x => new
            {
                x.IsReadingShowPreviousResults,
                x.IsReadingShowSubjectInfo,
                x.CriterionName,
                x.Id,
                x.ReadingTool,

            }).FirstOrDefaultAsync();


            bool isExistsClinicalData = false;
            if (trialInfo.ClinicalInformationTransmissionEnum == 1)
            {
                isExistsClinicalData = (await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
                {

                    SubjectId = task.SubjectId,
                    TrialId = inDto.TrialId,
                    VisitTaskId = task.VisitTaskId,
                })).Count() > 0;
            }


            var taskInfo = await _visitTaskRepository.Where(x => x.Id == task.VisitTaskId).FirstNotNullAsync();

            return ResponseOutput.Ok(result, new
            {
                VisitTaskId = task.VisitTaskId,
                SubjectId = task.SubjectId,
                SubjectCode = taskInfo.BlindSubjectCode.IsNullOrEmpty() ? task.SubjectCode : taskInfo.BlindSubjectCode,
                ReadingCategory = task.ReadingCategory,
                TaskBlindName = task.TaskBlindName,
                IsReadingShowPreviousResults = criterionInfo.IsReadingShowPreviousResults,
                IsReadingShowSubjectInfo = criterionInfo.IsReadingShowSubjectInfo,
                IsExistsClinicalData = isExistsClinicalData,
                TrialCriterionName = criterionInfo.CriterionName,
                TrialCriterionId = criterionInfo.Id

            });
        }



    }
}