358 lines
14 KiB
C#
358 lines
14 KiB
C#
|
|
//--------------------------------------------------------------------
|
|
// 此代码由liquid模板自动生成 byzhouhang 20240909
|
|
// 生成时间 2026-03-10 06:17:28Z
|
|
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
|
|
//--------------------------------------------------------------------
|
|
using IRaCIS.Core.Domain.Models;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using IRaCIS.Core.Application.Interfaces;
|
|
using IRaCIS.Core.Application.ViewModel;
|
|
using IRaCIS.Core.Infrastructure.Extention;
|
|
using System.Threading.Tasks;
|
|
using IRaCIS.Core.Infra.EFCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace IRaCIS.Core.Application.Service;
|
|
|
|
/// <summary>
|
|
/// 分割
|
|
/// </summary>
|
|
/// <param name="_segmentationRepository"></param>
|
|
/// <param name="_mapper"></param>
|
|
/// <param name="_userInfo"></param>
|
|
/// <param name="_localizer"></param>
|
|
[ ApiExplorerSettings(GroupName = "Reading")]
|
|
public class SegmentationService(IRepository<Segmentation> _segmentationRepository,
|
|
IRepository<SegmentBinding> _segmentBindingRepository,
|
|
IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository,
|
|
IRepository<VisitTask> _visitTaskRepository,
|
|
IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
|
|
IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
|
|
IRepository<Segment> _segmentRepository,
|
|
IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer): BaseService, ISegmentationService
|
|
{
|
|
|
|
|
|
/// <summary>
|
|
/// 获取分割组
|
|
/// </summary>
|
|
/// <param name="inQuery"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<PageOutput<SegmentationView>> GetSegmentationList(SegmentationQuery inQuery)
|
|
{
|
|
|
|
var segmentationQueryable =_segmentationRepository
|
|
.WhereIf(inQuery.SegmentationName.IsNotNullOrEmpty(),x=>x.SegmentationName.Contains(inQuery.SegmentationName))
|
|
.WhereIf(inQuery.Id != null, x => x.Id == inQuery.Id)
|
|
.WhereIf(inQuery.TrialId != null, x => x.TrialId == inQuery.TrialId)
|
|
.WhereIf(inQuery.SeriesId != null, x => x.SeriesId == inQuery.SeriesId)
|
|
.WhereIf(inQuery.StudyId != null, x => x.StudyId == inQuery.StudyId)
|
|
.WhereIf(inQuery.SubjectId != null, x => x.SubjectId == inQuery.SubjectId)
|
|
.WhereIf(inQuery.SubjectVisitId != null, x => x.SubjectVisitId == inQuery.SubjectVisitId)
|
|
.WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
|
|
.ProjectTo<SegmentationView>(_mapper.ConfigurationProvider);
|
|
|
|
var pageList= await segmentationQueryable.ToPagedListAsync(inQuery);
|
|
|
|
return pageList;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 新增修改分割组
|
|
/// </summary>
|
|
/// <param name="addOrEditSegmentation"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddOrUpdateSegmentation(SegmentationAddOrEdit addOrEditSegmentation)
|
|
{
|
|
|
|
|
|
|
|
var entity = await _segmentationRepository.InsertOrUpdateAsync(addOrEditSegmentation, true);
|
|
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 删除分割组
|
|
/// </summary>
|
|
/// <param name="segmentationId"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{segmentationId:guid}")]
|
|
public async Task<IResponseOutput> DeleteSegmentation(Guid segmentationId)
|
|
{
|
|
await DeleteBindingsAndAnswersAsync(segmentationId, null);
|
|
var success = await _segmentationRepository.DeleteFromQueryAsync(t => t.Id == segmentationId,true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取分割
|
|
/// </summary>
|
|
/// <param name="inQuery"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<PageOutput<SegmentView>> GetSegmentList(SegmentQuery inQuery)
|
|
{
|
|
|
|
var segmentQueryable = _segmentRepository
|
|
|
|
.WhereIf(inQuery.SegmentationId != null, x => x.SegmentationId == inQuery.SegmentationId)
|
|
.WhereIf(inQuery.SegmentName.IsNotNullOrEmpty(), x => x.SegmentName.Contains(inQuery.SegmentName))
|
|
.WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
|
|
.WhereIf(inQuery.Id != null, x => x.Id == inQuery.Id)
|
|
.ProjectTo<SegmentView>(_mapper.ConfigurationProvider);
|
|
|
|
var pageList = await segmentQueryable.ToPagedListAsync(inQuery);
|
|
|
|
return pageList;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 新增修改分割
|
|
/// </summary>
|
|
/// <param name="addOrEditSegment"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<IResponseOutput> AddOrUpdateSegment(SegmentAddOrEdit addOrEditSegment)
|
|
{
|
|
|
|
|
|
|
|
var entity = await _segmentRepository.InsertOrUpdateAsync(addOrEditSegment, true);
|
|
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除分割
|
|
/// </summary>
|
|
/// <param name="inQuery"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{segmentId:guid}")]
|
|
public async Task<IResponseOutput> DeleteSegment(Guid segmentId)
|
|
{
|
|
await DeleteBindingsAndAnswersAsync(null, segmentId);
|
|
var success = await _segmentRepository.DeleteFromQueryAsync(t => t.Id == segmentId, true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取分割绑定
|
|
/// </summary>
|
|
/// <param name="inQuery"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<PageOutput<SegmentBindingView>> GetSegmentBindingList(SegmentBindingQuery inQuery)
|
|
{
|
|
|
|
var segmentBindingQueryable = _segmentBindingRepository
|
|
.WhereIf(inQuery.Id != null, x => x.Id == inQuery.Id)
|
|
.WhereIf(inQuery.QuestionId != null, x => x.QuestionId == inQuery.QuestionId)
|
|
.WhereIf(inQuery.RowId != null, x => x.RowId == inQuery.RowId)
|
|
.WhereIf(inQuery.SegmentId != null, x => x.SegmentId == inQuery.SegmentId)
|
|
.WhereIf(inQuery.SegmentationId != null, x => x.SegmentationId == inQuery.SegmentationId)
|
|
.WhereIf(inQuery.TableQuestionId != null, x => x.TableQuestionId == inQuery.TableQuestionId)
|
|
.WhereIf(inQuery.VisitTaskId != null, x => x.VisitTaskId == inQuery.VisitTaskId)
|
|
.ProjectTo<SegmentBindingView>(_mapper.ConfigurationProvider);
|
|
|
|
var pageList = await segmentBindingQueryable.ToPagedListAsync(inQuery);
|
|
|
|
return pageList;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 新增修改分割绑定
|
|
/// </summary>
|
|
/// <param name="addOrEditSegmentBinding"></param>
|
|
/// <returns></returns>
|
|
public async Task<IResponseOutput> AddOrUpdateSegmentBinding(SegmentBindingAddOrEdit addOrEditSegmentBinding)
|
|
{
|
|
|
|
|
|
|
|
var entity = await _segmentBindingRepository.InsertOrUpdateAsync(addOrEditSegmentBinding, true);
|
|
|
|
return ResponseOutput.Ok(entity.Id.ToString());
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除分割
|
|
/// </summary>
|
|
/// <param name="segmentBindingId"></param>
|
|
/// <returns></returns>
|
|
[HttpDelete("{segmentBindingId:guid}")]
|
|
public async Task<IResponseOutput> DeleteSegmentBinding(Guid segmentBindingId)
|
|
{
|
|
var success = await _segmentBindingRepository.DeleteFromQueryAsync(t => t.Id == segmentBindingId, true);
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存分割绑定和答案
|
|
/// </summary>
|
|
/// <param name="inDto"></param>
|
|
/// <returns></returns>
|
|
public async Task<IResponseOutput> SaveSegmentBindingAndAnswer(SaveSegmentBindingAndAnswerInDto inDto)
|
|
{
|
|
|
|
var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId)
|
|
.FirstNotNullAsync();
|
|
foreach (var item in inDto.BindingList)
|
|
{
|
|
// 处理绑定关系
|
|
var binding = await _segmentBindingRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == item.QuestionId && x.RowId == item.RowId && x.TableQuestionId == item.TableQuestionId)
|
|
.FirstOrDefaultAsync();
|
|
if (binding == null)
|
|
{
|
|
if (item.SegmentationId != null && item.SegmentId != null)
|
|
{
|
|
await _segmentBindingRepository.InsertFromDTOAsync(new SegmentBinding
|
|
{
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
QuestionId = item.QuestionId,
|
|
RowId = item.RowId,
|
|
TableQuestionId = item.TableQuestionId,
|
|
SegmentId = item.SegmentId.Value,
|
|
SegmentationId = item.SegmentationId.Value,
|
|
});
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (item.SegmentationId != null && item.SegmentId != null)
|
|
{
|
|
await _segmentBindingRepository.UpdatePartialFromQueryAsync(x => x.Id == binding.Id, t => new SegmentBinding
|
|
{
|
|
SegmentId = item.SegmentId.Value,
|
|
SegmentationId = item.SegmentationId.Value,
|
|
});
|
|
}
|
|
else
|
|
{
|
|
await _segmentBindingRepository.DeleteFromQueryAsync(x => x.Id == binding.Id);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// 处理问题
|
|
if (item.RowId != null && item.TableQuestionId != null)
|
|
{
|
|
var answer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.RowId == item.RowId && x.TableQuestionId == item.TableQuestionId)
|
|
.FirstOrDefaultAsync();
|
|
var rowinfo= await _readingTableAnswerRowInfoRepository.Where(x => x.Id==item.RowId)
|
|
.Include(x=>x.VisitTask)
|
|
.FirstNotNullAsync();
|
|
if (answer != null)
|
|
{
|
|
await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.Id == answer.Id, t => new ReadingTableQuestionAnswer
|
|
{
|
|
Answer = item.Answer
|
|
});
|
|
}
|
|
else
|
|
{
|
|
await _readingTableQuestionAnswerRepository.InsertFromDTOAsync(new ReadingTableQuestionAnswer
|
|
{
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
RowId = item.RowId.Value,
|
|
TableQuestionId = item.TableQuestionId.Value,
|
|
Answer = item.Answer,
|
|
TrialId= rowinfo.VisitTask.TrialId,
|
|
RowIndex= rowinfo.RowIndex,
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
var answer = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId &&x.ReadingQuestionTrialId==item.QuestionId)
|
|
.FirstOrDefaultAsync();
|
|
|
|
if (answer != null)
|
|
{
|
|
await _readingTaskQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.Id == answer.Id, t => new ReadingTaskQuestionAnswer
|
|
{
|
|
Answer = item.Answer
|
|
});
|
|
}
|
|
else
|
|
{
|
|
await _readingTaskQuestionAnswerRepository.InsertFromDTOAsync(new ReadingTaskQuestionAnswer
|
|
{
|
|
ReadingQuestionTrialId= item.QuestionId.Value,
|
|
ReadingQuestionCriterionTrialId=taskinfo.TrialReadingCriterionId,
|
|
TrialId= taskinfo.TrialId,
|
|
SubjectId= taskinfo.SubjectId,
|
|
VisitTaskId = inDto.VisitTaskId,
|
|
Answer=item.Answer,
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
await _segmentationRepository.SaveChangesAsync();
|
|
return ResponseOutput.Ok();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除分割组和分割时的关联数据删除逻辑
|
|
/// </summary>
|
|
/// <param name="segmentationId"></param>
|
|
/// <param name="segmentId"></param>
|
|
/// <returns></returns>
|
|
private async Task DeleteBindingsAndAnswersAsync(Guid? segmentationId, Guid? segmentId)
|
|
{
|
|
var bindingsQuery = _segmentBindingRepository
|
|
.WhereIf(segmentationId != null, x => x.SegmentationId == segmentationId)
|
|
.WhereIf(segmentId != null, x => x.SegmentId == segmentId);
|
|
|
|
var bindings = await bindingsQuery.ToListAsync();
|
|
|
|
foreach (var binding in bindings)
|
|
{
|
|
// 处理问题
|
|
if (binding.RowId != null && binding.TableQuestionId != null)
|
|
{
|
|
await _readingTableQuestionAnswerRepository.DeleteFromQueryAsync(x => x.VisitTaskId == binding.VisitTaskId && x.RowId == binding.RowId && x.TableQuestionId == binding.TableQuestionId);
|
|
}
|
|
else if (binding.QuestionId != null)
|
|
{
|
|
await _readingTaskQuestionAnswerRepository.DeleteFromQueryAsync(x => x.VisitTaskId == binding.VisitTaskId && x.ReadingQuestionTrialId == binding.QuestionId);
|
|
}
|
|
}
|
|
|
|
// 处理绑定关系
|
|
if (segmentationId != null)
|
|
{
|
|
await _segmentBindingRepository.DeleteFromQueryAsync(x => x.SegmentationId == segmentationId);
|
|
}
|
|
else if (segmentId != null)
|
|
{
|
|
await _segmentBindingRepository.DeleteFromQueryAsync(x => x.SegmentId == segmentId);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|