You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
827 lines
41 KiB
827 lines
41 KiB
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using NPOI.SS.Formula.Functions;
|
|
using NPOI.Util;
|
|
using Shentun.Peis.ColumnReferenceCodes;
|
|
using Shentun.Peis.DiagnosisFunctions;
|
|
using Shentun.Peis.Enums;
|
|
using Shentun.Peis.Items;
|
|
using Shentun.Peis.LisRequests;
|
|
using Shentun.Peis.Models;
|
|
using Shentun.Peis.PatientRegisters;
|
|
using Shentun.Peis.PlugIns.ImportLisResults;
|
|
using Shentun.Peis.PlugIns.LisRequests;
|
|
using Shentun.Peis.ReferenceRanges;
|
|
using Shentun.Peis.RegisterCheckItems;
|
|
using Shentun.Peis.RegisterChecks;
|
|
using Shentun.Peis.SysParmValues;
|
|
using Shentun.Peis.Units;
|
|
using SqlSugar;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using Volo.Abp;
|
|
using Volo.Abp.Application.Services;
|
|
using Volo.Abp.Domain.Repositories;
|
|
using Volo.Abp.Guids;
|
|
using Volo.Abp.Identity;
|
|
using Volo.Abp.Users;
|
|
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
|
|
|
|
namespace Shentun.Peis.ImportLisResults
|
|
{
|
|
[ApiExplorerSettings(GroupName = "Work")]
|
|
[Authorize]
|
|
public class ImportLisResultAppService : ApplicationService, IImportLisResultAppService
|
|
{
|
|
private readonly IRepository<ThirdInterface> _thirdInterfaceRepository;
|
|
private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
|
|
private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
|
|
private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
|
|
private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
|
|
private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
|
|
private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
|
|
private readonly IRepository<Item, Guid> _itemRepository;
|
|
private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
|
|
private readonly IRepository<RegisterCheckSuggestion, Guid> _registerCheckSuggestionRepository;
|
|
private readonly IRepository<IdentityUser, Guid> _userRepository;
|
|
private readonly IRepository<Unit, Guid> _unitRepository;
|
|
private readonly RegisterCheckManager _registerCheckManager;
|
|
private readonly RegisterCheckItemManager _registerCheckItemManager;
|
|
private readonly CacheService _cacheService;
|
|
private readonly IGuidGenerator _guidGenerator;
|
|
private readonly IConfiguration _configuration;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly IRepository<UserItemType> _userItemTypeRepository;
|
|
private readonly IRepository<Asbitem, Guid> _asbitemRepository;
|
|
private readonly DiagnosisFunctionAppService _diagnosisFunctionAppService;
|
|
private readonly ReferenceRangeManager _referenceRangeManager;
|
|
private readonly ItemManager _itemManager;
|
|
private readonly UnitManager _unitManager;
|
|
private readonly RegisterCheckAppService _registerCheckAppService;
|
|
private List<Unit> _units;
|
|
private List<ReferenceRange> _referenceRanges;
|
|
private static bool _isRunning = false;
|
|
private static readonly object lockObject = new object();
|
|
private readonly ColumnReferenceCodeManager _columnReferenceCodeManager;
|
|
private readonly SysParmValueManager _sysParmValueManager;
|
|
public ImportLisResultAppService(IRepository<RegisterCheck, Guid> registerCheckRepository,
|
|
IRepository<RegisterCheckItem> registerCheckItemRepository,
|
|
IRepository<PatientRegister, Guid> patientRegisterRepository,
|
|
IRepository<ReferenceRange, Guid> referenceRangeRepository,
|
|
IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
|
|
IRepository<RegisterCheckSuggestion, Guid> registerCheckSuggestionRepository,
|
|
IRepository<IdentityUser, Guid> userRepository,
|
|
RegisterCheckManager registerCheckManager,
|
|
RegisterCheckItemManager registerCheckItemManager,
|
|
CacheService cacheService,
|
|
IGuidGenerator guidGenerator,
|
|
IConfiguration configuration,
|
|
ICurrentUser currentUser,
|
|
IRepository<UserItemType> userItemTypeRepository,
|
|
IRepository<Asbitem, Guid> asbitemRepository,
|
|
IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
|
|
IRepository<LisRequest, Guid> lisRequestRepository,
|
|
IRepository<Unit, Guid> unitRepository,
|
|
DiagnosisFunctionAppService diagnosisFunctionAppService,
|
|
ReferenceRangeManager referenceRangeManager,
|
|
IRepository<Item, Guid> itemRepository,
|
|
ItemManager itemManager,
|
|
UnitManager unitManager,
|
|
RegisterCheckAppService registerCheckAppService,
|
|
IRepository<ThirdInterface> thirdInterfaceRepository,
|
|
ColumnReferenceCodeManager columnReferenceCodeManager,
|
|
SysParmValueManager sysParmValueManager)
|
|
{
|
|
_registerCheckRepository = registerCheckRepository;
|
|
_userRepository = userRepository;
|
|
_registerCheckManager = registerCheckManager;
|
|
_patientRegisterRepository = patientRegisterRepository;
|
|
_referenceRangeRepository = referenceRangeRepository;
|
|
_registerCheckItemRepository = registerCheckItemRepository;
|
|
_registerCheckSummaryRepository = registerCheckSummaryRepository;
|
|
_registerCheckSuggestionRepository = registerCheckSuggestionRepository;
|
|
_registerCheckItemManager = registerCheckItemManager;
|
|
_cacheService = cacheService;
|
|
_guidGenerator = guidGenerator;
|
|
_configuration = configuration;
|
|
_currentUser = currentUser;
|
|
_userItemTypeRepository = userItemTypeRepository;
|
|
_asbitemRepository = asbitemRepository;
|
|
_registerCheckAsbitemRepository = registerCheckAsbitemRepository;
|
|
_lisRequestRepository = lisRequestRepository;
|
|
_diagnosisFunctionAppService = diagnosisFunctionAppService;
|
|
_referenceRangeManager = referenceRangeManager;
|
|
_itemRepository = itemRepository;
|
|
_itemManager = itemManager;
|
|
_unitRepository = unitRepository;
|
|
_units = _unitRepository.GetListAsync().Result;
|
|
_unitManager = unitManager;
|
|
_registerCheckAppService = registerCheckAppService;
|
|
_thirdInterfaceRepository = thirdInterfaceRepository;
|
|
_columnReferenceCodeManager = columnReferenceCodeManager;
|
|
_sysParmValueManager = sysParmValueManager;
|
|
}
|
|
/// <summary>
|
|
/// 从第三方接口导入结果
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="UserFriendlyException"></exception>
|
|
[HttpPost("api/app/ImportLisResult/ImportResult")]
|
|
public async Task ImportResultAsync(List<CreateImportLisResultDto> input)
|
|
{
|
|
//设置结果
|
|
|
|
var list = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
|
|
join registerCheck in await _registerCheckRepository.GetQueryableAsync()
|
|
on patientRegister.Id equals registerCheck.PatientRegisterId
|
|
join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
|
|
on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
|
|
join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
|
|
on registerCheck.Id equals registerCheckItem.RegisterCheckId
|
|
join item in await _itemRepository.GetQueryableAsync()
|
|
on registerCheckItem.ItemId equals item.Id
|
|
join lisRequest in await _lisRequestRepository.GetQueryableAsync()
|
|
on registerCheckAsbitem.LisRequestId equals lisRequest.Id
|
|
where input.Select(o => o.LisRequestNo).ToList().Contains(lisRequest.LisRequestNo)
|
|
select new
|
|
{
|
|
patientRegister,
|
|
registerCheck,
|
|
registerCheckAsbitem,
|
|
registerCheckItem,
|
|
item,
|
|
lisRequest,
|
|
}).ToList();
|
|
|
|
var lisRequestNos = input.Select(o => o.LisRequestNo).Distinct().ToList();
|
|
var registerChecks = new List<RegisterCheck>();
|
|
_referenceRanges = _referenceRangeRepository.GetListAsync().Result;
|
|
|
|
input = input.Where(o => !string.IsNullOrWhiteSpace(o.Result)
|
|
&& !string.IsNullOrWhiteSpace(o.LisRequestNo)
|
|
&& o.ItemId != Guid.Empty).ToList();
|
|
|
|
foreach (var inputItem in input)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(inputItem.CheckDoctorName))
|
|
{
|
|
throw new UserFriendlyException("检查医生不能为空");
|
|
}
|
|
var lisRequestItems = list.Where(o => o.lisRequest.LisRequestNo == inputItem.LisRequestNo
|
|
&& o.registerCheckItem.ItemId == inputItem.ItemId).ToList();
|
|
foreach (var lisRequestItem in lisRequestItems)
|
|
{
|
|
if (lisRequestItem == null)
|
|
{
|
|
continue;
|
|
}
|
|
lisRequestItem.registerCheckItem.Result = inputItem.Result;
|
|
//var itemSource = new RegisterCheckItem()
|
|
//{
|
|
// Result = inputItem.Result,
|
|
// ReferenceRangeValue = inputItem.ReferenceRangeValue,
|
|
// Unit = inputItem.Unit,
|
|
// CriticalRangeValue = inputItem.CriticalRangeValue
|
|
//};
|
|
|
|
//项目如果是性激素参考范围,不更新
|
|
if (lisRequestItem.item.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.SexHormone)
|
|
{
|
|
//修改参考范围
|
|
await UpdateItemReferenceRangeValueAsync(inputItem.ItemId, lisRequestItem.patientRegister.SexId,
|
|
lisRequestItem.patientRegister.Age, inputItem.ReferenceRangeValue, inputItem.CriticalRangeValue);
|
|
}
|
|
//修改单位
|
|
await UpdateItemUnitAsync(inputItem.ItemId, inputItem.Unit);
|
|
|
|
//await _registerCheckItemManager.UpdateRegisterCheckItemAsync(itemSource, lisRequestItem.registerCheckItem);
|
|
//await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem,true);
|
|
if (!registerChecks.Where(o => o.Id == lisRequestItem.registerCheck.Id).ToList().Any())
|
|
{
|
|
lisRequestItem.registerCheck.CheckDoctorId = inputItem.CheckDoctorName;
|
|
lisRequestItem.registerCheck.CheckDate = inputItem.CheckDate;
|
|
lisRequestItem.registerCheck.ExecOrganizationUnitId = inputItem.ExecOrganizationUnitId;
|
|
lisRequestItem.registerCheck.AuditorName = inputItem.AuditorName;
|
|
lisRequestItem.registerCheck.LisSampleNo = inputItem.LisSampleNo;
|
|
lisRequestItem.registerCheck.AuditorTime = inputItem.AuditorTime;
|
|
lisRequestItem.registerCheck.SubmissionTime = inputItem.SubmissionTime;
|
|
registerChecks.Add(lisRequestItem.registerCheck);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
List<RegisterCheckAsbitem> updateRegisterCheckAsbitem = new List<RegisterCheckAsbitem>();
|
|
|
|
//更新参考范围和单位
|
|
foreach (var registerCheck in registerChecks)
|
|
{
|
|
var lisRequestItems = list.Where(o => o.registerCheck.Id == registerCheck.Id).ToList();
|
|
foreach (var lisRequestItem in lisRequestItems)
|
|
{
|
|
var referenceRange = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(_referenceRanges,
|
|
lisRequestItem.item, lisRequestItem.patientRegister.SexId, lisRequestItem.patientRegister.Age, lisRequestItem.patientRegister.SexHormoneTermId);
|
|
if (referenceRange != null)
|
|
{
|
|
lisRequestItem.registerCheckItem.ReferenceRangeValue = referenceRange.ReferenceRangeValue;
|
|
lisRequestItem.registerCheckItem.CriticalRangeValue = referenceRange.CriticalRangeValue;
|
|
}
|
|
else
|
|
{
|
|
lisRequestItem.registerCheckItem.ReferenceRangeValue = "";
|
|
lisRequestItem.registerCheckItem.CriticalRangeValue = "";
|
|
}
|
|
var unit = _units.Where(o => o.Id == lisRequestItem.item.UnitId).FirstOrDefault();
|
|
if (unit != null)
|
|
{
|
|
lisRequestItem.registerCheckItem.Unit = unit.DisplayName;
|
|
}
|
|
else
|
|
{
|
|
lisRequestItem.registerCheckItem.Unit = "";
|
|
}
|
|
await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem);
|
|
}
|
|
|
|
}
|
|
await CurrentUnitOfWork.SaveChangesAsync();
|
|
//保存结果
|
|
|
|
foreach (var registerCheck in registerChecks)
|
|
{
|
|
var updateCheckResultDto = new UpdateCheckResultDto()
|
|
{
|
|
RegisterCheckId = registerCheck.Id,
|
|
CheckDoctorId = registerCheck.CheckDoctorId,
|
|
CheckDate = registerCheck.CheckDate,
|
|
ExecOrganizationUnitId = registerCheck.ExecOrganizationUnitId,
|
|
RegisterCheckItems = list.Where(o => o.registerCheck.Id == registerCheck.Id)
|
|
.Select(o => new UpdateRegisterCheckItemDetail()
|
|
{
|
|
ItemId = o.registerCheckItem.ItemId,
|
|
Result = o.registerCheckItem.Result,
|
|
|
|
}).ToList(),
|
|
LisSampleNo = registerCheck.LisSampleNo,
|
|
AuditorName = registerCheck.AuditorName,
|
|
AuditorTime = registerCheck.AuditorTime,
|
|
SubmissionTime = registerCheck.SubmissionTime
|
|
};
|
|
|
|
var getDiagnosisResultRequestDto = new GetDiagnosisResultRequestDto()
|
|
{
|
|
RegisterCheckId = registerCheck.Id,
|
|
Items = list.Where(o => o.registerCheck.Id == registerCheck.Id)
|
|
.Select(o => new GetDiagnosisResultRequest_Item()
|
|
{
|
|
ItemId = o.registerCheckItem.ItemId,
|
|
Result = o.registerCheckItem.Result,
|
|
}).ToList()
|
|
};
|
|
//生成小结
|
|
var summarry = await _diagnosisFunctionAppService.GetDoctorCheckDiagnosisResultAsync(getDiagnosisResultRequestDto);
|
|
|
|
for (var i = 0; i < summarry.DiagnosisResultDetails.Count; i++)
|
|
{
|
|
updateCheckResultDto.Summarys.Add(new UpdateRegisterCheckSummaryDetail()
|
|
{
|
|
Summary = summarry.DiagnosisResultDetails[i].DiagnosisResult,
|
|
SummaryFlag = '0'
|
|
});
|
|
}
|
|
|
|
await _registerCheckAppService.UpdateCheckResult(updateCheckResultDto);
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
/// 导入某个人的结果
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/ImportLisResult/ImportResultByPatientRegisterId")]
|
|
public async Task ImportResultByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
|
|
{
|
|
var patientRegister = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
|
|
var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o =>
|
|
o.ThirdInterfaceType == ThirdInterfaceTypeFlag.ImportLisResult
|
|
&& o.MedicalCenterId == patientRegister.MedicalCenterId
|
|
&& o.IsActive == 'Y');
|
|
foreach (var thirdInterface in thirdInterfaces)
|
|
{
|
|
var parmValue = thirdInterface.ParmValue;
|
|
var configurationBuilder = new ConfigurationBuilder()
|
|
.AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
|
|
var config = configurationBuilder.Build();
|
|
var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
|
|
var className = config.GetSection("Interface").GetSection("ClassName").Value;
|
|
object[] objects = new object[] { input.PatientRegisterId };
|
|
var pluginsOut = await Utilities.ReflectionHelper.InvokeAsync<ImportLisResultPlugInsOut>(assemblyName,
|
|
className, [thirdInterface.Id], "ImportResultByPatientRegisterIdAsync", objects);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 导入迪安、艾迪康结果 外检
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/ImportLisResult/ImportDianResultByPatientRegisterId")]
|
|
public async Task ImportDianResultByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
|
|
{
|
|
var patientRegister = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
|
|
var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o =>
|
|
o.ThirdInterfaceType == ThirdInterfaceTypeFlag.OutSend
|
|
&& o.MedicalCenterId == patientRegister.MedicalCenterId
|
|
&& o.IsActive == 'Y');
|
|
foreach (var thirdInterface in thirdInterfaces)
|
|
{
|
|
var parmValue = thirdInterface.ParmValue;
|
|
var configurationBuilder = new ConfigurationBuilder()
|
|
.AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
|
|
var config = configurationBuilder.Build();
|
|
var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
|
|
var className = config.GetSection("Interface").GetSection("ClassName").Value;
|
|
object[] objects = new object[] { input.PatientRegisterId };
|
|
|
|
var pluginsOut = await Utilities.ReflectionHelper.InvokeAsync<ImportLisResultPlugInsOut>(assemblyName,
|
|
className, [thirdInterface.Id], "ImportOueSendResultByPatientRegisterIdAsync", objects);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 根据lis传过来的参考范围更新体检系统的值
|
|
/// </summary>
|
|
/// <param name="itemId"></param>
|
|
/// <param name="sexId"></param>
|
|
/// <param name="age"></param>
|
|
/// <param name="referenceRangeValue"></param>
|
|
/// <param name="criticalRangeValue"></param>
|
|
/// <returns></returns>
|
|
private async Task UpdateItemReferenceRangeValueAsync(Guid itemId, char sexId, int? age, string referenceRangeValue, string criticalRangeValue)
|
|
{
|
|
var referenceRanges = _referenceRanges.Where(o => o.ItemId == itemId).ToList();
|
|
if (age == null) age = 30;
|
|
if (string.IsNullOrWhiteSpace(referenceRangeValue))
|
|
{
|
|
return;
|
|
}
|
|
var item = await _itemRepository.GetAsync(itemId);
|
|
ReferenceRange referenceRange = null;
|
|
if (_referenceRangeManager.IsNumberReferenceRange(referenceRangeValue))
|
|
{
|
|
//数字型
|
|
item.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
|
|
await _itemRepository.UpdateAsync(item);
|
|
|
|
referenceRange = referenceRanges.Where(o => o.ForSexId == sexId
|
|
&& age >= o.AgeLowerLimit && age <= o.AgeUpperLimit
|
|
&& o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number).FirstOrDefault();
|
|
if (referenceRange != null)
|
|
{
|
|
referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
|
|
referenceRange.ReferenceRangeValue = referenceRangeValue;
|
|
if (!string.IsNullOrWhiteSpace(criticalRangeValue))
|
|
{
|
|
referenceRange.CriticalRangeValue = criticalRangeValue;
|
|
referenceRange.FollowUpRangeValue = criticalRangeValue;
|
|
}
|
|
await _referenceRangeRepository.UpdateAsync(referenceRange);
|
|
return;
|
|
}
|
|
|
|
referenceRange = referenceRanges.Where(o => o.ForSexId == ForSexFlag.All
|
|
&& age >= o.AgeLowerLimit && age <= o.AgeUpperLimit
|
|
&& o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number).FirstOrDefault();
|
|
if (referenceRange != null)
|
|
{
|
|
referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number;
|
|
referenceRange.ReferenceRangeValue = referenceRangeValue;
|
|
if (!string.IsNullOrWhiteSpace(criticalRangeValue))
|
|
{
|
|
referenceRange.CriticalRangeValue = criticalRangeValue;
|
|
referenceRange.FollowUpRangeValue = criticalRangeValue;
|
|
}
|
|
await _referenceRangeRepository.UpdateAsync(referenceRange);
|
|
return;
|
|
}
|
|
referenceRange = new ReferenceRange()
|
|
{
|
|
ItemId = itemId,
|
|
AgeLowerLimit = 0,
|
|
AgeUpperLimit = 200,
|
|
ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number,
|
|
ReferenceRangeValue = referenceRangeValue,
|
|
CriticalRangeValue = criticalRangeValue,
|
|
ForSexId = ForSexFlag.All
|
|
};
|
|
referenceRange = _referenceRangeManager.Create(referenceRange);
|
|
await _referenceRangeRepository.InsertAsync(referenceRange);
|
|
referenceRanges.Add(referenceRange);
|
|
return;
|
|
}
|
|
|
|
item.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character;
|
|
await _itemRepository.UpdateAsync(item);
|
|
referenceRange = referenceRanges.Where(o => o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Character).FirstOrDefault();
|
|
if (referenceRange != null)
|
|
{
|
|
referenceRange.ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character;
|
|
referenceRange.ReferenceRangeValue = referenceRangeValue;
|
|
await _referenceRangeRepository.UpdateAsync(referenceRange);
|
|
return;
|
|
}
|
|
|
|
referenceRange = new ReferenceRange()
|
|
{
|
|
ItemId = itemId,
|
|
AgeLowerLimit = 0,
|
|
AgeUpperLimit = 200,
|
|
ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character,
|
|
ReferenceRangeValue = referenceRangeValue,
|
|
ForSexId = ForSexFlag.All
|
|
};
|
|
referenceRange = _referenceRangeManager.Create(referenceRange);
|
|
await _referenceRangeRepository.InsertAsync(referenceRange);
|
|
referenceRanges.Add(referenceRange);
|
|
return;
|
|
}
|
|
|
|
private async Task UpdateItemUnitAsync(Guid itemId, string unitName)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(unitName))
|
|
{
|
|
return;
|
|
}
|
|
unitName = unitName.Trim();
|
|
var item = await _itemRepository.GetAsync(itemId);
|
|
var unit = _units.Where(o => o.DisplayName.Trim().ToLower() == unitName.ToLower()).FirstOrDefault();
|
|
if (unit != null)
|
|
{
|
|
if (item.UnitId == unit.Id)
|
|
{
|
|
return;
|
|
}
|
|
item.UnitId = unit.Id;
|
|
await _itemRepository.UpdateAsync(item);
|
|
return;
|
|
}
|
|
unit = new Unit()
|
|
{
|
|
DisplayName = unitName,
|
|
|
|
};
|
|
unit = await _unitManager.CreateAsync(unit);
|
|
await _unitRepository.InsertAsync(unit);
|
|
_units.Add(unit);
|
|
}
|
|
|
|
|
|
#region 蓝豚lis结果导入
|
|
/// <summary>
|
|
/// 根据lis检验单号导入结果
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/ImportLisResult/ImportResultByLisRequestNo")]
|
|
public async Task ImportResultByLisRequestNoAsync(List<ImportResultByLisRequestNoInputDto> input)
|
|
{
|
|
if (!input.Any())
|
|
throw new UserFriendlyException("请求参数无效");
|
|
|
|
|
|
var thirdInterface = await _thirdInterfaceRepository.FirstOrDefaultAsync(o => o.ThirdInterfaceType == ThirdInterfaceTypeFlag.ImportLisResult);
|
|
if (thirdInterface == null)
|
|
throw new UserFriendlyException($"未配置检验导入的参数");
|
|
|
|
var parmValue = thirdInterface.ParmValue;
|
|
var configurationBuilder = new ConfigurationBuilder()
|
|
.AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
|
|
var config = configurationBuilder.Build();
|
|
Guid execOrganizationUnitId = Guid.Parse(config.GetSection("Interface").GetSection("ExecOrganizationUnitId").Value);
|
|
Guid columnReferenId = Guid.Parse(config.GetSection("Interface").GetSection("ColumnReferenId").Value);
|
|
Guid userColumnReferenId = Guid.Parse(config.GetSection("Interface").GetSection("UserColumnReferenId").Value);
|
|
|
|
List<CreateImportLisResultDto> inputDtoList = new List<CreateImportLisResultDto>();
|
|
|
|
foreach (var item in input)
|
|
{
|
|
var codeValues = await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(columnReferenId, item.ItemId);
|
|
if (!codeValues.Any())
|
|
{
|
|
throw new UserFriendlyException($"项目编号:{item.ItemId}没有对照");
|
|
}
|
|
|
|
//转换检查医生ID
|
|
var checkDoctorUserId = (await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(userColumnReferenId, item.CheckDoctorName)).FirstOrDefault();
|
|
if (!string.IsNullOrWhiteSpace(checkDoctorUserId))
|
|
{
|
|
item.CheckDoctorName = checkDoctorUserId;
|
|
}
|
|
|
|
//转换审核医生ID
|
|
var lisAuditorDoctorUserId = (await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(userColumnReferenId, item.AuditorName)).FirstOrDefault();
|
|
if (!string.IsNullOrWhiteSpace(lisAuditorDoctorUserId))
|
|
{
|
|
item.AuditorName = lisAuditorDoctorUserId;
|
|
}
|
|
|
|
foreach (var codeValue in codeValues)
|
|
{
|
|
Guid itemId = Guid.Parse(codeValue);
|
|
var inputDto = new CreateImportLisResultDto
|
|
{
|
|
CheckDate = item.CheckDate,
|
|
CheckDoctorName = item.CheckDoctorName,
|
|
CriticalRangeValue = item.CriticalRangeValue,
|
|
CriticalValue = item.CriticalValue,
|
|
ExecOrganizationUnitId = execOrganizationUnitId,
|
|
ItemId = itemId,
|
|
ItemName = item.ItemName,
|
|
LisRequestNo = item.LisRequestNo,
|
|
ReferenceRangeValue = item.ReferenceRangeValue,
|
|
ReportPrompt = "",
|
|
ResultStatusId = null,
|
|
Result = item.Result,
|
|
Unit = item.Unit,
|
|
AuditorName = item.AuditorName,
|
|
LisSampleNo = item.LisSampleNo,
|
|
AuditorTime = item.AuditorTime,
|
|
SubmissionTime = item.SubmissionTime
|
|
};
|
|
inputDtoList.Add(inputDto);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
var lisRequestNoPrintMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "lis_request_no_print_mode");
|
|
if (string.IsNullOrWhiteSpace(lisRequestNoPrintMode))
|
|
lisRequestNoPrintMode = "0";
|
|
|
|
if (lisRequestNoPrintMode == "0")
|
|
await ImportResultAsync(inputDtoList);
|
|
else
|
|
await ImportResultByPatientRegisterNoAsync(inputDtoList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 从第三方接口导入结果
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="UserFriendlyException"></exception>
|
|
private async Task ImportResultByPatientRegisterNoAsync(List<CreateImportLisResultDto> input)
|
|
{
|
|
//设置结果
|
|
|
|
var list = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
|
|
join registerCheck in await _registerCheckRepository.GetQueryableAsync()
|
|
on patientRegister.Id equals registerCheck.PatientRegisterId
|
|
join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
|
|
on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
|
|
join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
|
|
on registerCheck.Id equals registerCheckItem.RegisterCheckId
|
|
join item in await _itemRepository.GetQueryableAsync()
|
|
on registerCheckItem.ItemId equals item.Id
|
|
join lisRequest in await _lisRequestRepository.GetQueryableAsync()
|
|
on registerCheckAsbitem.LisRequestId equals lisRequest.Id
|
|
where input.Select(o => o.LisRequestNo).FirstOrDefault() == patientRegister.PatientRegisterNo
|
|
select new
|
|
{
|
|
patientRegister,
|
|
registerCheck,
|
|
registerCheckAsbitem,
|
|
registerCheckItem,
|
|
item,
|
|
lisRequest,
|
|
}).ToList();
|
|
|
|
|
|
var registerChecks = new List<RegisterCheck>();
|
|
_referenceRanges = _referenceRangeRepository.GetListAsync().Result;
|
|
|
|
input = input.Where(o => !string.IsNullOrWhiteSpace(o.Result)
|
|
&& !string.IsNullOrWhiteSpace(o.LisRequestNo)
|
|
&& o.ItemId != Guid.Empty).ToList();
|
|
|
|
foreach (var inputItem in input)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(inputItem.CheckDoctorName))
|
|
{
|
|
throw new UserFriendlyException("检查医生不能为空");
|
|
}
|
|
var lisRequestItems = list.Where(o => o.patientRegister.PatientRegisterNo == inputItem.LisRequestNo
|
|
&& o.registerCheckItem.ItemId == inputItem.ItemId).ToList();
|
|
foreach (var lisRequestItem in lisRequestItems)
|
|
{
|
|
if (lisRequestItem == null)
|
|
{
|
|
continue;
|
|
}
|
|
lisRequestItem.registerCheckItem.Result = inputItem.Result;
|
|
//var itemSource = new RegisterCheckItem()
|
|
//{
|
|
// Result = inputItem.Result,
|
|
// ReferenceRangeValue = inputItem.ReferenceRangeValue,
|
|
// Unit = inputItem.Unit,
|
|
// CriticalRangeValue = inputItem.CriticalRangeValue
|
|
//};
|
|
if (lisRequestItem.item.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.SexHormone)
|
|
{
|
|
//修改参考范围
|
|
await UpdateItemReferenceRangeValueAsync(inputItem.ItemId, lisRequestItem.patientRegister.SexId,
|
|
lisRequestItem.patientRegister.Age, inputItem.ReferenceRangeValue, inputItem.CriticalRangeValue);
|
|
}
|
|
//修改单位
|
|
await UpdateItemUnitAsync(inputItem.ItemId, inputItem.Unit);
|
|
|
|
//await _registerCheckItemManager.UpdateRegisterCheckItemAsync(itemSource, lisRequestItem.registerCheckItem);
|
|
//await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem,true);
|
|
if (!registerChecks.Where(o => o.Id == lisRequestItem.registerCheck.Id).ToList().Any())
|
|
{
|
|
lisRequestItem.registerCheck.CheckDoctorId = inputItem.CheckDoctorName;
|
|
lisRequestItem.registerCheck.CheckDate = inputItem.CheckDate;
|
|
lisRequestItem.registerCheck.ExecOrganizationUnitId = inputItem.ExecOrganizationUnitId;
|
|
lisRequestItem.registerCheck.AuditorName = inputItem.AuditorName;
|
|
lisRequestItem.registerCheck.LisSampleNo = inputItem.LisSampleNo;
|
|
lisRequestItem.registerCheck.SubmissionTime = inputItem.SubmissionTime;
|
|
lisRequestItem.registerCheck.AuditorTime = inputItem.AuditorTime;
|
|
registerChecks.Add(lisRequestItem.registerCheck);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
List<RegisterCheckAsbitem> updateRegisterCheckAsbitem = new List<RegisterCheckAsbitem>();
|
|
|
|
//更新参考范围和单位
|
|
foreach (var registerCheck in registerChecks)
|
|
{
|
|
var lisRequestItems = list.Where(o => o.registerCheck.Id == registerCheck.Id).ToList();
|
|
foreach (var lisRequestItem in lisRequestItems)
|
|
{
|
|
var referenceRange = _referenceRangeManager.GetReferenceRangeBySexAgeTemp(_referenceRanges,
|
|
lisRequestItem.item, lisRequestItem.patientRegister.SexId, lisRequestItem.patientRegister.Age, lisRequestItem.patientRegister.SexHormoneTermId);
|
|
if (referenceRange != null)
|
|
{
|
|
lisRequestItem.registerCheckItem.ReferenceRangeValue = referenceRange.ReferenceRangeValue;
|
|
lisRequestItem.registerCheckItem.CriticalRangeValue = referenceRange.CriticalRangeValue;
|
|
}
|
|
else
|
|
{
|
|
lisRequestItem.registerCheckItem.ReferenceRangeValue = "";
|
|
lisRequestItem.registerCheckItem.CriticalRangeValue = "";
|
|
}
|
|
var unit = _units.Where(o => o.Id == lisRequestItem.item.UnitId).FirstOrDefault();
|
|
if (unit != null)
|
|
{
|
|
lisRequestItem.registerCheckItem.Unit = unit.DisplayName;
|
|
}
|
|
else
|
|
{
|
|
lisRequestItem.registerCheckItem.Unit = "";
|
|
}
|
|
await _registerCheckItemRepository.UpdateAsync(lisRequestItem.registerCheckItem);
|
|
}
|
|
|
|
}
|
|
await CurrentUnitOfWork.SaveChangesAsync();
|
|
//保存结果
|
|
|
|
foreach (var registerCheck in registerChecks)
|
|
{
|
|
var updateCheckResultDto = new UpdateCheckResultDto()
|
|
{
|
|
RegisterCheckId = registerCheck.Id,
|
|
CheckDoctorId = registerCheck.CheckDoctorId,
|
|
CheckDate = registerCheck.CheckDate,
|
|
ExecOrganizationUnitId = registerCheck.ExecOrganizationUnitId,
|
|
RegisterCheckItems = list.Where(o => o.registerCheck.Id == registerCheck.Id)
|
|
.Select(o => new UpdateRegisterCheckItemDetail()
|
|
{
|
|
ItemId = o.registerCheckItem.ItemId,
|
|
Result = o.registerCheckItem.Result,
|
|
|
|
}).ToList(),
|
|
LisSampleNo = registerCheck.LisSampleNo,
|
|
AuditorName = registerCheck.AuditorName,
|
|
AuditorTime = registerCheck.AuditorTime,
|
|
SubmissionTime = registerCheck.SubmissionTime
|
|
};
|
|
|
|
var getDiagnosisResultRequestDto = new GetDiagnosisResultRequestDto()
|
|
{
|
|
RegisterCheckId = registerCheck.Id,
|
|
Items = list.Where(o => o.registerCheck.Id == registerCheck.Id)
|
|
.Select(o => new GetDiagnosisResultRequest_Item()
|
|
{
|
|
ItemId = o.registerCheckItem.ItemId,
|
|
Result = o.registerCheckItem.Result,
|
|
}).ToList()
|
|
};
|
|
//生成小结
|
|
var summarry = await _diagnosisFunctionAppService.GetDoctorCheckDiagnosisResultAsync(getDiagnosisResultRequestDto);
|
|
|
|
for (var i = 0; i < summarry.DiagnosisResultDetails.Count; i++)
|
|
{
|
|
updateCheckResultDto.Summarys.Add(new UpdateRegisterCheckSummaryDetail()
|
|
{
|
|
Summary = summarry.DiagnosisResultDetails[i].DiagnosisResult,
|
|
SummaryFlag = '0'
|
|
});
|
|
}
|
|
|
|
await _registerCheckAppService.UpdateCheckResult(updateCheckResultDto);
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region 批量导入lis结果 需要单独对照
|
|
|
|
/// <summary>
|
|
/// 按excel批量导入检验结果
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="UserFriendlyException"></exception>
|
|
[HttpPost("api/app/ImportLisResult/ImportResultExcelByLisRequestNo")]
|
|
public async Task ImportResultExcelByLisRequestNoAsync(ImportResultExcelByLisRequestNoInputDto input)
|
|
{
|
|
List<CreateImportLisResultDto> inputDtoList = new List<CreateImportLisResultDto>();
|
|
|
|
//对照主表Id
|
|
var columnReferenceId = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "import_file_lis_result");
|
|
if (string.IsNullOrWhiteSpace(columnReferenceId))
|
|
throw new UserFriendlyException("未找到对照主表Id，请到系统参数配置");
|
|
foreach (var item in input.Details)
|
|
{
|
|
var codeValues = await _columnReferenceCodeManager.GetColumnReferenCodeValueAsync(Guid.Parse(columnReferenceId), item.ItemName);
|
|
if (!codeValues.Any())
|
|
{
|
|
throw new UserFriendlyException($"项目名称:{item.ItemName}没有对照");
|
|
}
|
|
|
|
|
|
foreach (var codeValue in codeValues)
|
|
{
|
|
Guid itemId = Guid.Parse(codeValue);
|
|
var inputDto = new CreateImportLisResultDto
|
|
{
|
|
CheckDate = string.IsNullOrWhiteSpace(item.CheckDate) ? null : Convert.ToDateTime(item.CheckDate),
|
|
CheckDoctorName = item.CheckDoctorName,
|
|
CriticalRangeValue = "",
|
|
CriticalValue = "",
|
|
ExecOrganizationUnitId = Guid.Empty,
|
|
ItemId = itemId,
|
|
ItemName = item.ItemName,
|
|
LisRequestNo = input.BarCode,
|
|
ReferenceRangeValue = "",
|
|
ReportPrompt = "",
|
|
ResultStatusId = null,
|
|
Result = item.ItemResult,
|
|
Unit = "",
|
|
AuditorName = "",
|
|
LisSampleNo = input.SampleNo
|
|
};
|
|
inputDtoList.Add(inputDto);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if (input.BarcodeMode == '0')
|
|
{
|
|
if (await _patientRegisterRepository.CountAsync(f => f.PatientRegisterNo == input.BarCode) == 0)
|
|
throw new UserFriendlyException($"条码号{input.BarCode}不正确");
|
|
await ImportResultByPatientRegisterNoAsync(inputDtoList);
|
|
}
|
|
else if (input.BarcodeMode == '1')
|
|
{
|
|
var isBarCode = await (from registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
|
|
join lisRequest in await _lisRequestRepository.GetQueryableAsync() on registerCheckAsbitem.LisRequestId equals lisRequest.Id
|
|
where lisRequest.LisRequestNo == input.BarCode
|
|
select lisRequest.LisRequestNo).CountAsync();
|
|
if (isBarCode == 0)
|
|
throw new UserFriendlyException($"条码号{input.BarCode}不正确");
|
|
await ImportResultAsync(inputDtoList);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|