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.
1579 lines
66 KiB
1579 lines
66 KiB
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using NPOI.DDF;
|
|
using NUglify.Helpers;
|
|
using Shentun.Peis.Enums;
|
|
using Shentun.Peis.Models;
|
|
using Shentun.Peis.Sexs;
|
|
using Shentun.Peis.SumDiagnosises;
|
|
using Shentun.Peis.SysParmValues;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using TencentCloud.Cdn.V20180606.Models;
|
|
using TencentCloud.Pts.V20210728.Models;
|
|
using Volo.Abp;
|
|
using Volo.Abp.Application.Services;
|
|
using Volo.Abp.Domain.Repositories;
|
|
using Volo.Abp.Uow;
|
|
using Xceed.Document.NET;
|
|
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;
|
|
|
|
|
|
namespace Shentun.Peis.DiagnosisFunctions
|
|
{
|
|
[ApiExplorerSettings(GroupName = "Work")]
|
|
[Authorize]
|
|
public class DiagnosisFunctionAppService : ApplicationService
|
|
{
|
|
private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
|
|
private readonly IRepository<RegisterCheckAsbitem, Guid> _registerAsbitemRepository;
|
|
private readonly IRepository<Asbitem, Guid> _asbitemRepository;
|
|
private readonly IRepository<Item, Guid> _itemRepository;
|
|
private readonly IRepository<AsbitemDetail> _asbitemDetailRepository;
|
|
private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
|
|
private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
|
|
private readonly IRepository<Diagnosis, Guid> _diagnosisRepository;
|
|
private readonly IRepository<ItemResultTemplate, Guid> _itemResultTemplateRepository;
|
|
private readonly IRepository<ItemResultMatch, Guid> _itemResultMatchRepository;
|
|
private readonly IRepository<Suggestion, Guid> _suggestionRepository;
|
|
private readonly CacheService _cacheService;
|
|
private SysParmValueManager _sysParmValueManager;
|
|
private string _isAddAbnormalResult;
|
|
private string _isAddReferenceRange;
|
|
private string _isAutoAddSuffix;
|
|
private string _lowerSuffix;
|
|
private string _highSuffix;
|
|
string[] _numArry = { "①", "②", "③", "④", "⑤", "⑥", "⑦", "⑧", "⑨", "⑩",
|
|
"⑪", "⑫", "⑬", "⑭", "⑮", "⑯", "⑰", "⑱", "⑲", "⑳" };
|
|
public DiagnosisFunctionAppService(
|
|
IRepository<PatientRegister, Guid> patientRegisterRepository,
|
|
IRepository<RegisterCheckAsbitem, Guid> registerAsbitemRepository,
|
|
IRepository<Asbitem, Guid> asbitemRepository,
|
|
IRepository<Item, Guid> itemRepository,
|
|
IRepository<AsbitemDetail> asbitemDetailRepository,
|
|
IRepository<RegisterCheck, Guid> registerCheckRepository,
|
|
IRepository<RegisterCheckItem> registerCheckItemRepository,
|
|
IRepository<Diagnosis, Guid> diagnosisRepository,
|
|
IRepository<ItemResultTemplate, Guid> itemResultTemplateRepository,
|
|
IRepository<ItemResultMatch, Guid> itemResultMatchRepository,
|
|
IRepository<Suggestion, Guid> suggestionRepository,
|
|
CacheService cacheService,
|
|
SysParmValueManager sysParmValueManager)
|
|
|
|
{
|
|
this._patientRegisterRepository = patientRegisterRepository;
|
|
this._registerAsbitemRepository = registerAsbitemRepository;
|
|
this._asbitemRepository = asbitemRepository;
|
|
this._itemRepository = itemRepository;
|
|
this._asbitemDetailRepository = asbitemDetailRepository;
|
|
this._registerCheckRepository = registerCheckRepository;
|
|
this._registerCheckItemRepository = registerCheckItemRepository;
|
|
this._diagnosisRepository = diagnosisRepository;
|
|
this._itemResultTemplateRepository = itemResultTemplateRepository;
|
|
this._itemResultMatchRepository = itemResultMatchRepository;
|
|
this._suggestionRepository = suggestionRepository;
|
|
_cacheService = cacheService;
|
|
_sysParmValueManager = sysParmValueManager;
|
|
|
|
}
|
|
|
|
|
|
#region hide
|
|
///// <summary>
|
|
///// 医生诊台生成小结
|
|
///// </summary>
|
|
///// <param name="input"></param>
|
|
///// <returns></returns>
|
|
//[HttpPost("api/app/diagnosisfunction/getdiagnosisresult")]
|
|
//public async Task<List<GetDiagnosisResultDto>> GetDiagnosisResultAsync(GetDiagnosisResultRequestDto input)
|
|
//{
|
|
|
|
// var reslist = new List<GetDiagnosisResultDto>();
|
|
|
|
|
|
// var registerAsbitems = from a in await _registerAsbitemRepository.GetListAsync()
|
|
// join b in await _asbitemRepository.GetListAsync() on a.AsbitemId equals b.Id into bb
|
|
// from ab in bb.DefaultIfEmpty()
|
|
// where a.PatientRegisterId == input.PatientRegisterId
|
|
// select ab;
|
|
|
|
// foreach (var item in registerAsbitems)
|
|
// {
|
|
// if (item.IsDiagnosisFunction == 'Y' && !string.IsNullOrEmpty(item.DiagnosisFunction))
|
|
// {
|
|
// if (item.DisplayName == "身高体重")
|
|
// {
|
|
// var res = await GetDiagnosisResultInAsbitemHeightAsync(input, item.DiagnosisFunction, item.IsContinueProcess);
|
|
// if (res.Count > 0)
|
|
// {
|
|
// reslist.AddRange(res);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// return reslist;
|
|
//}
|
|
|
|
|
|
|
|
///// <summary>
|
|
///// 组合函数 身高体重 生成
|
|
///// </summary>
|
|
///// <param name="input"></param>
|
|
///// <param name="DiagnosisFunction">诊断函数</param>
|
|
///// <param name="IsContinueProcess">处理完是否继续执行项目的诊断函数</param>
|
|
///// <returns></returns>
|
|
//private async Task<List<GetDiagnosisResultDto>> GetDiagnosisResultInAsbitemHeightAsync(GetDiagnosisResultRequestDto input, string DiagnosisFunction, char IsContinueProcess)
|
|
//{
|
|
// var reslist = new List<GetDiagnosisResultDto>();
|
|
|
|
|
|
// if (input.Items.Count > 0)
|
|
// {
|
|
// var itemList = await _itemRepository.GetListAsync();
|
|
|
|
// string DiagnosisFunctionCode = DiagnosisFunction;
|
|
|
|
|
|
// foreach (var item in input.Items)
|
|
// {
|
|
// if (item.ItemId != null)
|
|
// {
|
|
// var itement = itemList.Where(m => m.Id == item.ItemId).FirstOrDefault();
|
|
// if (itement != null)
|
|
// {
|
|
// DiagnosisFunctionCode = DiagnosisFunctionCode.Replace($"[{itement.DisplayName}]", item.Result);
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
|
|
// ////拼接动态代码
|
|
// //string code = @"
|
|
// // using System;
|
|
|
|
// // namespace Shentun.Peis
|
|
// // {
|
|
// // public class DiagnosisResultInAsbitemHeight
|
|
// // {
|
|
// // public string AutoDiagnosisResultInAsbitemHeight()
|
|
// // {
|
|
// // var msg="""";"
|
|
// // + DiagnosisFunctionCode + @"
|
|
// // return msg;
|
|
// // }
|
|
// // }
|
|
// // }";
|
|
|
|
|
|
// //拼接动态代码
|
|
// string code = @"
|
|
|
|
// public class DiagnosisResultInAsbitemHeight
|
|
// {
|
|
// public string AutoDiagnosisResultInAsbitemHeight()
|
|
// {
|
|
// var msg="""";"
|
|
// + DiagnosisFunctionCode + @"
|
|
// return msg;
|
|
// }
|
|
// }";
|
|
|
|
// CompileHelper compileHelper = new CompileHelper();
|
|
|
|
// var assembly = compileHelper.GenerateAssemblyFromCode(code, Assembly.Load(new AssemblyName("System.Runtime")), typeof(object).Assembly);
|
|
|
|
// if (assembly != null)
|
|
// {
|
|
|
|
// // 反射获取程序集中 的类
|
|
// Type type = assembly.GetType("DiagnosisResultInAsbitemHeight");
|
|
|
|
// // 创建该类的实例
|
|
// object obj = Activator.CreateInstance(type);
|
|
|
|
// var msg = type.InvokeMember("AutoDiagnosisResultInAsbitemHeight",
|
|
// BindingFlags.Default | BindingFlags.InvokeMethod,
|
|
// null,
|
|
// obj,
|
|
// null);
|
|
|
|
// if (!string.IsNullOrEmpty(msg.ToString()))
|
|
// {
|
|
// reslist.Add(new GetDiagnosisResultDto { DiagnosisResult = msg.ToString() });
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
|
|
|
|
// return reslist;
|
|
//}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// 医生诊台生成小结
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/diagnosisfunction/getdiagnosisresult")]
|
|
public async Task<OkObjectResult> GetDiagnosisResultAsync(GetDiagnosisResultRequestDto input)
|
|
{
|
|
throw new Exception("禁止使用");
|
|
var reslist = new List<GetDiagnosisResult_Detail>();
|
|
var suggestionlist = new List<GetDiagnosisSuggestion_Detail>();
|
|
|
|
// await GetCalculationFunctionAsync(input); //取消计算函数计算
|
|
|
|
//根据检查单ID查询
|
|
var query = (from a in await _registerCheckRepository.GetQueryableAsync()
|
|
join b in await _registerAsbitemRepository.GetQueryableAsync() on a.Id equals b.RegisterCheckId
|
|
join c in await _registerCheckItemRepository.GetQueryableAsync() on a.Id equals c.RegisterCheckId
|
|
join d in await _asbitemRepository.GetQueryableAsync() on b.AsbitemId equals d.Id
|
|
join e in (await _itemRepository.GetQueryableAsync()).Include(x => x.ReferenceRanges) on c.ItemId equals e.Id
|
|
join f in await _patientRegisterRepository.GetQueryableAsync() on b.PatientRegisterId equals f.Id
|
|
where a.Id == input.RegisterCheckId
|
|
select new { a, b, c, d, e, f }).ToList();
|
|
|
|
|
|
List<string> diagnosisTrips = new List<string>(); //异常提示
|
|
|
|
if (query.Count() > 0)
|
|
{
|
|
|
|
|
|
//组合项目数据
|
|
// var asbitem_Data = query.GroupBy(g => g.b.Id).Select(s=>new )
|
|
|
|
var asbitem_Group = query.GroupBy(g => g.b.Id);
|
|
|
|
|
|
|
|
//正常是一个，合并过项目可能存在多个
|
|
foreach (var item in asbitem_Group)
|
|
{
|
|
var asbitem_data = item.Select(s => s.d).FirstOrDefault(); //组合项目信息
|
|
var item_datas = item.Select(s => s.e).ToList(); //项目信息
|
|
var patientRegister_data = item.Select(s => s.f).FirstOrDefault();
|
|
|
|
//是否开启组合项目诊断函数
|
|
if (asbitem_data.IsDiagnosisFunction == 'Y' && !string.IsNullOrEmpty(asbitem_data.DiagnosisFunction))
|
|
{
|
|
var res = await GetDiagnosisResultInAsbitemAsync(input, asbitem_data, item_datas, patientRegister_data, diagnosisTrips);
|
|
if (res.Count > 0)
|
|
{
|
|
reslist.AddRange(res);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//查找项目诊断函数
|
|
var itemResult = await GetDiagnosisResultInItemAsync(input, item_datas, patientRegister_data, diagnosisTrips); //执行项目诊断函数
|
|
if (itemResult.Any())
|
|
{
|
|
reslist.AddRange(itemResult);
|
|
}
|
|
}
|
|
|
|
|
|
if (!reslist.Any())
|
|
{
|
|
//未生成小结，继续根据参考范围生成
|
|
foreach (var item_data in item_datas)
|
|
{
|
|
if (item_data.IsProduceSummary == 'Y')
|
|
{
|
|
string itemResult_Request = input.Items.Where(m => m.ItemId == item_data.Id).FirstOrDefault()?.Result; //项目结果
|
|
|
|
string referenceRangesResult = await GetDiagnosisResultInReferenceRangesAsync(item_data, itemResult_Request, patientRegister_data, diagnosisTrips);
|
|
if (!string.IsNullOrEmpty(referenceRangesResult))
|
|
{
|
|
if (item_data.IsNameIntoSummary == 'Y')
|
|
referenceRangesResult = item_data.DisplayName + referenceRangesResult;
|
|
reslist.Add(new GetDiagnosisResult_Detail { DiagnosisResult = referenceRangesResult });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//无结果 加未见异常
|
|
if (!reslist.Any())
|
|
reslist.Add(new GetDiagnosisResult_Detail { DiagnosisResult = "未见异常" });
|
|
else
|
|
{
|
|
//小结内容去重
|
|
reslist = reslist.Where((x, i) => reslist.FindIndex(z => z.DiagnosisResult == x.DiagnosisResult) == i).ToList();
|
|
|
|
//生成建议
|
|
var suggestion_query = from a in await _suggestionRepository.GetQueryableAsync()
|
|
join b in await _diagnosisRepository.GetQueryableAsync() on a.DiagnosisId equals b.Id
|
|
where reslist.Select(s => s.DiagnosisResult).Contains(b.DisplayName)
|
|
select a;
|
|
if (suggestion_query.Count() > 0)
|
|
{
|
|
suggestionlist = suggestion_query.Select(s => new GetDiagnosisSuggestion_Detail
|
|
{
|
|
DiagnosisSuggestion = s.SuggestionContent
|
|
}).ToList();
|
|
}
|
|
}
|
|
|
|
string diagnosisTrip = "";
|
|
if (diagnosisTrips.Any())
|
|
{
|
|
diagnosisTrip = string.Join(",", diagnosisTrips.Distinct().ToList());
|
|
}
|
|
|
|
var resdto = new GetDiagnosisResultDto
|
|
{
|
|
DiagnosisResultDetails = reslist,
|
|
DiagnosisSuggestionDetails = suggestionlist,
|
|
};
|
|
|
|
|
|
if (!string.IsNullOrEmpty(diagnosisTrip))
|
|
{
|
|
return new OkObjectResult(CustomerReturnValue.CreateInstance(0, diagnosisTrip, resdto));
|
|
}
|
|
else
|
|
{
|
|
return new OkObjectResult(CustomerReturnValue.CreateInstance(1, "Success", resdto));
|
|
}
|
|
}
|
|
|
|
[HttpPost("api/app/DiagnosisFunction/GetDoctorCheckDiagnosisResultAsync")]
|
|
public async Task<GetDiagnosisResultDto> GetDoctorCheckDiagnosisResultAsync(GetDiagnosisResultRequestDto input)
|
|
{
|
|
var reslist = new List<GetDiagnosisResult_Detail>();
|
|
var suggestionlist = new List<GetDiagnosisSuggestion_Detail>();
|
|
|
|
|
|
//根据检查单ID查询
|
|
var query = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
|
|
join registerAsbitem in await _registerAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerAsbitem.RegisterCheckId
|
|
join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckItem.RegisterCheckId
|
|
join asbitem in await _asbitemRepository.GetQueryableAsync() on registerAsbitem.AsbitemId equals asbitem.Id
|
|
join item in (await _itemRepository.GetQueryableAsync()).Include(x => x.ReferenceRanges).Include(x => x.ItemResultMatches).Include(x => x.ItemResultTemplates)
|
|
on registerCheckItem.ItemId equals item.Id
|
|
join patientRegister in await _patientRegisterRepository.GetQueryableAsync() on registerCheck.PatientRegisterId equals patientRegister.Id
|
|
where registerCheck.Id == input.RegisterCheckId
|
|
select new { registerCheck, registerAsbitem, registerCheckItem, asbitem, item, patientRegister }).ToList();
|
|
|
|
var resultDto = new GetDiagnosisResultDto
|
|
{
|
|
DiagnosisResultDetails = reslist,
|
|
DiagnosisSuggestionDetails = suggestionlist,
|
|
};
|
|
if (query.Count() == 0)
|
|
{
|
|
return resultDto;
|
|
}
|
|
await LoadSysParm(query[0].patientRegister.MedicalCenterId);
|
|
/*处理逻辑:
|
|
* 1、处理组合项目诊断函数，如果继续处理走下一步,只处理不合并组合项目的，合并组合项目的不支持
|
|
* 2、处理项目诊断函数，如果继续处理走下一步
|
|
* 3、如果是数字型结果，并且有参考范围则处理数字型参考范围，处理完毕后后续几步不处理
|
|
* 4、如果是字符型结果则从结果模板和结果匹配中去找到对应的诊断，如果都没有生成诊断，则根据结果直接生成诊断
|
|
* 5、如果没有诊断，返回组合项目默认结果
|
|
* */
|
|
//设置基本参数
|
|
var doctorCheckDiagnosisInput = new DoctorCheckDiagnosisInput()
|
|
{
|
|
SexId = query[0].patientRegister.SexId,
|
|
SexName = _cacheService.GetSexNameAsync(query[0].patientRegister.SexId).Result,
|
|
Age = query[0].patientRegister.Age
|
|
};
|
|
foreach (var item in query)
|
|
{
|
|
//组合项目参数
|
|
if (doctorCheckDiagnosisInput.Asbitems.Where(o => o.AsbitemId == item.asbitem.Id).Count() == 0)
|
|
{
|
|
var asbitemInput = new AsbitemInput()
|
|
{
|
|
AsbitemId = item.asbitem.Id,
|
|
AsbitemName = item.asbitem.DisplayName,
|
|
IsDiagnosisFunction = item.asbitem.IsDiagnosisFunction,
|
|
DiagnosisFunction = item.asbitem.DiagnosisFunction,
|
|
IsContinueProcess = item.asbitem.IsContinueProcess,
|
|
DefaultResult = item.asbitem.DefaultResult,
|
|
};
|
|
doctorCheckDiagnosisInput.Asbitems.Add(asbitemInput);
|
|
}
|
|
//项目参数
|
|
if (doctorCheckDiagnosisInput.Items.Where(o => o.ItemId == item.item.Id).Count() == 0)
|
|
{
|
|
var inputItem = input.Items.Where(o => o.ItemId == item.item.Id).FirstOrDefault();
|
|
var inputResult = "";
|
|
if(inputItem != null)
|
|
{
|
|
inputResult = inputItem.Result;
|
|
}
|
|
var itemInput = new ItemInput()
|
|
{
|
|
ItemId = item.item.Id,
|
|
ItemName = item.item.DisplayName,
|
|
IsDiagnosisFunction = item.item.IsDiagnosisFunction,
|
|
DiagnosisFunction = item.item.DiagnosisFunction,
|
|
IsContinueProcess = item.item.IsContinueProcess,
|
|
IsNameIntoSummary = item.item.IsNameIntoSummary,
|
|
IsProduceSummary = item.item.IsProduceSummary,
|
|
ReferenceRangeTypeFlag = item.item.ReferenceRangeTypeFlag,
|
|
DefaultResult = item.item.DefaultResult,
|
|
Result = inputResult,
|
|
DisplayOrder = item.item.DisplayOrder,
|
|
ItemResultMatches = item.item.ItemResultMatches.ToList(),
|
|
ItemResultTemplates = item.item.ItemResultTemplates.ToList(),
|
|
ReferenceRanges = item.item.ReferenceRanges.ToList()
|
|
};
|
|
doctorCheckDiagnosisInput.Items.Add(itemInput);
|
|
}
|
|
}
|
|
doctorCheckDiagnosisInput.Items = doctorCheckDiagnosisInput.Items.OrderBy(o=>o.DisplayOrder).ToList();
|
|
|
|
//处理组合项目诊断函数
|
|
List<string> diagnosisList = new List<string>();
|
|
List<string> asbitemDiagnosisList;
|
|
var isContinueProcess = GetAsbitemDiagnosisByFunction(doctorCheckDiagnosisInput, out asbitemDiagnosisList);
|
|
diagnosisList.AddRange(asbitemDiagnosisList);
|
|
if (isContinueProcess)
|
|
{
|
|
//处理项目诊断
|
|
var itemDiagnosisList = await GetItemDiagnosis(doctorCheckDiagnosisInput);
|
|
var itemDiagnosisStringList = GetItemDiagnosisStringList(itemDiagnosisList);
|
|
diagnosisList.AddRange(itemDiagnosisStringList);
|
|
|
|
}
|
|
//设置返回值
|
|
//去掉空结果数据
|
|
diagnosisList = diagnosisList.Where(o => !string.IsNullOrWhiteSpace(o)).ToList();
|
|
//去掉重复结果数据
|
|
diagnosisList = diagnosisList.Distinct().ToList();
|
|
if (!diagnosisList.Any())
|
|
{
|
|
//设置组合项目默认小结
|
|
diagnosisList.Add(doctorCheckDiagnosisInput.Asbitems[0].DefaultResult);
|
|
}
|
|
foreach(var diagnosis in diagnosisList)
|
|
{
|
|
var getDiagnosisResult_Detail = new GetDiagnosisResult_Detail()
|
|
{
|
|
DiagnosisResult = diagnosis
|
|
};
|
|
resultDto.DiagnosisResultDetails.Add(getDiagnosisResult_Detail);
|
|
}
|
|
return resultDto;
|
|
|
|
}
|
|
private List<string> GetItemDiagnosisStringList(List<DoctorCheckItemDiagnosisResult> itemDiagnosisList)
|
|
{
|
|
var diagnosisList = new List<string>();
|
|
foreach (var itemDiagnosis in itemDiagnosisList)
|
|
{
|
|
if (!itemDiagnosis.ItemDiagnosisTypeResults.Any())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string diagnosis = "";
|
|
foreach (var itemDiagnosisType in itemDiagnosis.ItemDiagnosisTypeResults)
|
|
{
|
|
if (itemDiagnosisType.DiagnosisType == '1')
|
|
{
|
|
//数字型检验参考范围
|
|
diagnosisList.AddRange(itemDiagnosisType.Diagnosis);
|
|
}
|
|
else
|
|
{
|
|
if (itemDiagnosisType.Diagnosis.Count() > _numArry.Count())
|
|
{
|
|
throw new UserFriendlyException($"诊断数量超过{_numArry.Count()}个，不支持");
|
|
}
|
|
if (itemDiagnosisType.Diagnosis.Count() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int i = 0; i < itemDiagnosisType.Diagnosis.Count(); i++)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(itemDiagnosisType.Diagnosis[i]))
|
|
{
|
|
continue;
|
|
}
|
|
diagnosis = diagnosis + _numArry[i] + itemDiagnosisType.Diagnosis[i] + ";";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(diagnosis))
|
|
{
|
|
diagnosis = itemDiagnosis.ItemName + ";" + diagnosis;
|
|
diagnosisList.Add(diagnosis);
|
|
}
|
|
|
|
}
|
|
|
|
return diagnosisList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 加载系统参数
|
|
/// </summary>
|
|
/// <param name="medicalCenterId"></param>
|
|
/// <returns></returns>
|
|
private async Task LoadSysParm(Guid medicalCenterId)
|
|
{
|
|
_isAddAbnormalResult = await _sysParmValueManager.GetSysParmValueInMedicalCenterId(
|
|
medicalCenterId, "doctor_check_lis_summary_mode_add_abnormal_result");
|
|
_isAddReferenceRange = await _sysParmValueManager.GetSysParmValueInMedicalCenterId(
|
|
medicalCenterId, "doctor_check_lis_summary_mode_add_reference_range");
|
|
_isAutoAddSuffix = await _sysParmValueManager.GetSysParmValueInMedicalCenterId(
|
|
medicalCenterId, "doctor_check_lis_summary_mode_auto_add_suffix");
|
|
_lowerSuffix = await _sysParmValueManager.GetSysParmValueInMedicalCenterId(
|
|
medicalCenterId, "doctor_check_lis_summary_mode_lower_suffix");
|
|
_highSuffix = await _sysParmValueManager.GetSysParmValueInMedicalCenterId(
|
|
medicalCenterId, "doctor_check_lis_summary_mode_high_suffix");
|
|
}
|
|
/// <summary>
|
|
/// 获取组合项目诊断通过诊断函数
|
|
/// </summary>
|
|
/// <param name="doctorCheckDiagnosisInput"></param>
|
|
/// <param name="diagnosisList"></param>
|
|
/// <returns></returns>
|
|
private bool GetAsbitemDiagnosisByFunction(DoctorCheckDiagnosisInput doctorCheckDiagnosisInput, out List<string> diagnosisList)
|
|
{
|
|
var patientAsbitemDiagnosisInput = new PatientAsbitemDiagnosisInput()
|
|
{
|
|
SexName = doctorCheckDiagnosisInput.SexName,
|
|
Age = doctorCheckDiagnosisInput.Age
|
|
};
|
|
|
|
foreach (var item in doctorCheckDiagnosisInput.Items)
|
|
{
|
|
var itemResult = new ItemResultInput()
|
|
{
|
|
ItemId = item.ItemId,
|
|
ItemName = item.ItemName,
|
|
Result = item.Result
|
|
};
|
|
patientAsbitemDiagnosisInput.Items.Add(itemResult);
|
|
}
|
|
var diagnosisBuilder = new DiagnosisBuilder();
|
|
diagnosisList = new List<string>();
|
|
bool isContinueProcess = true;
|
|
foreach (var asbitem in doctorCheckDiagnosisInput.Asbitems)
|
|
{
|
|
if (asbitem.IsDiagnosisFunction == 'Y' && !string.IsNullOrWhiteSpace(asbitem.DiagnosisFunction))
|
|
{
|
|
var diagnosis = diagnosisBuilder.GetAsbitemDiagnosisResult(patientAsbitemDiagnosisInput, asbitem.DiagnosisFunction);
|
|
diagnosisList.Add(diagnosis);
|
|
if (asbitem.IsContinueProcess != 'Y')
|
|
{
|
|
//有一个不允许继续处理，则不允许继续处理
|
|
isContinueProcess = false;
|
|
}
|
|
}
|
|
}
|
|
return isContinueProcess;
|
|
|
|
}
|
|
/// <summary>
|
|
/// 获取项目诊断
|
|
/// </summary>
|
|
/// <param name="doctorCheckDiagnosisInput"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<DoctorCheckItemDiagnosisResult>> GetItemDiagnosis(DoctorCheckDiagnosisInput doctorCheckDiagnosisInput)
|
|
{
|
|
var patientItemDiagnosisInput = new PatientItemDiagnosisInput()
|
|
{
|
|
SexName = doctorCheckDiagnosisInput.SexName,
|
|
Age = doctorCheckDiagnosisInput.Age
|
|
};
|
|
|
|
var diagnosisBuilder = new DiagnosisBuilder();
|
|
var diagnosisList = new List<DoctorCheckItemDiagnosisResult>();
|
|
foreach (var item in doctorCheckDiagnosisInput.Items)
|
|
{
|
|
|
|
if (string.IsNullOrWhiteSpace(item.Result))
|
|
{
|
|
continue;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(item.DefaultResult) && item.Result == item.DefaultResult)
|
|
{
|
|
continue;
|
|
}
|
|
if (item.IsProduceSummary != 'Y')
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var doctorCheckItemDiagnosisResult = new DoctorCheckItemDiagnosisResult()
|
|
{
|
|
ItemName = item.ItemName,
|
|
};
|
|
diagnosisList.Add(doctorCheckItemDiagnosisResult);
|
|
if (item.IsDiagnosisFunction == 'Y' && !string.IsNullOrWhiteSpace(item.DiagnosisFunction))
|
|
{
|
|
var itemResult = new ItemResultInput()
|
|
{
|
|
ItemId = item.ItemId,
|
|
ItemName = item.ItemName,
|
|
Result = item.Result
|
|
};
|
|
patientItemDiagnosisInput.Item = itemResult;
|
|
|
|
//通过计算获取诊断
|
|
var diagnosis = diagnosisBuilder.GetItemDiagnosisResult(patientItemDiagnosisInput, item.DiagnosisFunction);
|
|
|
|
var itemDiagnosisTypeResult = new ItemDiagnosisTypeResult()
|
|
{
|
|
DiagnosisType = '0'
|
|
};
|
|
itemDiagnosisTypeResult.Diagnosis.Add(diagnosis);
|
|
doctorCheckItemDiagnosisResult.ItemDiagnosisTypeResults.Add(itemDiagnosisTypeResult);
|
|
|
|
|
|
}
|
|
if (item.IsDiagnosisFunction == 'Y' && item.IsContinueProcess != 'Y')
|
|
{
|
|
continue;
|
|
}
|
|
//通过参考范围获取诊断
|
|
if(item.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number)
|
|
{
|
|
var referenceRangeDiagnosis = await GetItemDiagnosisByReferenceRanges(doctorCheckDiagnosisInput.SexId, doctorCheckDiagnosisInput.Age, item);
|
|
if (!string.IsNullOrWhiteSpace(referenceRangeDiagnosis))
|
|
{
|
|
var itemDiagnosisTypeResult = new ItemDiagnosisTypeResult()
|
|
{
|
|
DiagnosisType = '1'
|
|
};
|
|
itemDiagnosisTypeResult.Diagnosis.Add(referenceRangeDiagnosis);
|
|
doctorCheckItemDiagnosisResult.ItemDiagnosisTypeResults.Add(itemDiagnosisTypeResult);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
//通过结果模板获取诊断
|
|
var templateList = await GetItemDiagnosisByTemplate(item);
|
|
var itemDiagnosisTypeResult = new ItemDiagnosisTypeResult()
|
|
{
|
|
DiagnosisType = '2'
|
|
};
|
|
|
|
itemDiagnosisTypeResult.Diagnosis.AddRange(templateList);
|
|
|
|
//通过匹配关系获取诊断
|
|
var matcheList = await GetItemDiagnosisByMatche(item);
|
|
itemDiagnosisTypeResult.Diagnosis.AddRange(matcheList);
|
|
if (!templateList.Any() && !matcheList.Any())
|
|
{
|
|
//获取异常结果
|
|
itemDiagnosisTypeResult.Diagnosis.Add(item.Result);
|
|
|
|
}
|
|
//去掉重复诊断
|
|
itemDiagnosisTypeResult.Diagnosis = itemDiagnosisTypeResult.Diagnosis.Distinct().ToList();
|
|
doctorCheckItemDiagnosisResult.ItemDiagnosisTypeResults.Add(itemDiagnosisTypeResult);
|
|
|
|
|
|
}
|
|
|
|
}
|
|
return diagnosisList;
|
|
|
|
}
|
|
/// <summary>
|
|
/// 通过参考范围获取项目诊断列表
|
|
/// </summary>
|
|
/// <param name="sexId"></param>
|
|
/// <param name="age"></param>
|
|
/// <param name="itemInput"></param>
|
|
/// <returns></returns>
|
|
private async Task<string> GetItemDiagnosisByReferenceRanges(char sexId, short? age, ItemInput itemInput)
|
|
{
|
|
var diagnosisList = new List<string>();
|
|
if (string.IsNullOrWhiteSpace(itemInput.Result))
|
|
{
|
|
return null;
|
|
}
|
|
decimal resultDecimal;
|
|
if (!decimal.TryParse(itemInput.Result, out resultDecimal))
|
|
{
|
|
return null;
|
|
}
|
|
var referenceRangeList = itemInput.ReferenceRanges.Where(o => o.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number).ToList();
|
|
if (!referenceRangeList.Any())
|
|
{
|
|
return null;
|
|
}
|
|
if (age == null)
|
|
{
|
|
age = 30;
|
|
}
|
|
var referenceRange = referenceRangeList.Where(o => o.ForSexId == sexId && age >= o.AgeLowerLimit && age <= o.AgeUpperLimit).FirstOrDefault();
|
|
if (referenceRange == null)
|
|
{
|
|
referenceRange = referenceRangeList.Where(o => o.ForSexId == ForSexFlag.All && age >= o.AgeLowerLimit && age <= o.AgeUpperLimit).FirstOrDefault();
|
|
if (referenceRange == null)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
string lowReferenceRangeValueStr;
|
|
string hegihtReferenceRangeValueStr;
|
|
decimal lowReferenceRangeValue;
|
|
decimal hegihtReferenceRangeValue;
|
|
string diagnosis = null;
|
|
var pos = referenceRange.ReferenceRangeValue.IndexOf("-");
|
|
if (pos > 0)
|
|
{
|
|
//参考范围形式：10-30
|
|
lowReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(0, pos);
|
|
hegihtReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(pos + 1);
|
|
if (!decimal.TryParse(lowReferenceRangeValueStr, out lowReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (!decimal.TryParse(hegihtReferenceRangeValueStr, out hegihtReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (resultDecimal < lowReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, true, referenceRange);
|
|
}
|
|
else if (resultDecimal > hegihtReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, false, referenceRange);
|
|
}
|
|
|
|
return diagnosis;
|
|
}
|
|
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf(">=");
|
|
var charLength = ">=".Length;
|
|
if (pos == 0)
|
|
{
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("≥");
|
|
charLength = "≥".Length;
|
|
if (pos == 0)
|
|
{
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("≧");
|
|
charLength = "≧".Length;
|
|
}
|
|
}
|
|
if (pos > 0)
|
|
{
|
|
//参考范围形式：>=
|
|
lowReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(pos + charLength);
|
|
|
|
if (!decimal.TryParse(lowReferenceRangeValueStr, out lowReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (resultDecimal < lowReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, true, referenceRange);
|
|
}
|
|
return diagnosis;
|
|
}
|
|
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf(">");
|
|
charLength = ">".Length;
|
|
if (pos > 0)
|
|
{
|
|
//参考范围形式：>
|
|
lowReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(pos + charLength);
|
|
|
|
if (!decimal.TryParse(lowReferenceRangeValueStr, out lowReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (resultDecimal <= lowReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, true, referenceRange);
|
|
}
|
|
return diagnosis;
|
|
}
|
|
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("<=");
|
|
charLength = "<=".Length;
|
|
if (pos == 0)
|
|
{
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("≤");
|
|
charLength = "≤".Length;
|
|
if (pos == 0)
|
|
{
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("≦");
|
|
charLength = "≦".Length;
|
|
}
|
|
}
|
|
if (pos > 0)
|
|
{
|
|
//参考范围形式：<=
|
|
hegihtReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(pos + charLength);
|
|
|
|
if (!decimal.TryParse(hegihtReferenceRangeValueStr, out hegihtReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (resultDecimal >= hegihtReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, false, referenceRange);
|
|
}
|
|
return diagnosis;
|
|
}
|
|
pos = referenceRange.ReferenceRangeValue.IndexOf("<");
|
|
charLength = "<".Length;
|
|
if (pos > 0)
|
|
{
|
|
//参考范围形式：<
|
|
hegihtReferenceRangeValueStr = referenceRange.ReferenceRangeValue.Substring(pos + charLength);
|
|
|
|
if (!decimal.TryParse(hegihtReferenceRangeValueStr, out hegihtReferenceRangeValue))
|
|
{
|
|
return null;
|
|
}
|
|
if (resultDecimal >= hegihtReferenceRangeValue)
|
|
{
|
|
diagnosis = await GetNumberDiagnosis(itemInput.ItemName, itemInput.Result, false, referenceRange);
|
|
}
|
|
return diagnosis;
|
|
}
|
|
return diagnosis;
|
|
}
|
|
|
|
|
|
private async Task<string> GetNumberDiagnosis(string itemName, string result, bool isLower,
|
|
ReferenceRange referenceRange)
|
|
{
|
|
string diagnosis = null;
|
|
if (isLower)
|
|
{
|
|
if (referenceRange.LowerDiagnosisId != null && referenceRange.LowerDiagnosisId != Guid.Empty)
|
|
{
|
|
var diagnosisEntity = await _diagnosisRepository.FindAsync(o => o.Id == referenceRange.LowerDiagnosisId);
|
|
if (diagnosisEntity != null)
|
|
{
|
|
diagnosis = diagnosisEntity.DisplayName + "↓";
|
|
}
|
|
else
|
|
{
|
|
if (_isAutoAddSuffix == "Y")
|
|
{
|
|
diagnosis = itemName + _lowerSuffix + "↓";
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (_isAutoAddSuffix == "Y")
|
|
{
|
|
diagnosis = itemName + _lowerSuffix + "↓";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (referenceRange.UpperDiagnosisId != null && referenceRange.UpperDiagnosisId != Guid.Empty)
|
|
{
|
|
var diagnosisEntity = await _diagnosisRepository.FindAsync(o => o.Id == referenceRange.UpperDiagnosisId);
|
|
if (diagnosisEntity != null)
|
|
{
|
|
diagnosis = diagnosisEntity.DisplayName + "↑";
|
|
}
|
|
else
|
|
{
|
|
if (_isAutoAddSuffix == "Y")
|
|
{
|
|
diagnosis = itemName + _highSuffix + "↑";
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (_isAutoAddSuffix == "Y")
|
|
{
|
|
diagnosis = itemName + _highSuffix + "↑";
|
|
}
|
|
}
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(diagnosis))
|
|
{
|
|
if (_isAddAbnormalResult == "Y")
|
|
{
|
|
diagnosis = diagnosis + "(结果:" + result + ",参考范围:" + referenceRange.ReferenceRangeValue + ")";
|
|
}
|
|
}
|
|
return diagnosis;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 通过模板获取诊断
|
|
/// </summary>
|
|
/// <param name="itemInput"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<string>> GetItemDiagnosisByTemplate(ItemInput itemInput)
|
|
{
|
|
List<string> diagnosisList = new List<string>();
|
|
//将结果解析到数组中
|
|
string[] resultArry = GetResultArry(itemInput.Result);
|
|
//结果模板中的结果去掉数字，* /等符号
|
|
foreach (var template in itemInput.ItemResultTemplates)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(template.Result))
|
|
{
|
|
|
|
template.Result = Regex.Replace(template.Result, @"\d+", "").Replace("*", "").Replace("/", "").Replace(" ", "");
|
|
}
|
|
}
|
|
foreach (var resultSplit in resultArry)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(resultSplit) || resultSplit.StartsWith("余未见异常"))
|
|
{
|
|
continue;
|
|
}
|
|
var templatesList = itemInput.ItemResultTemplates.Where(o => o.Result == resultSplit && o.IsResultIntoSummary == 'Y').ToList();
|
|
foreach (var template in templatesList)
|
|
{
|
|
if (template != null && template.DiagnosisId != null && template.DiagnosisId != Guid.Empty)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == template.DiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
diagnosisList.Add(temp_diagnosis.DisplayName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
diagnosisList.Add(resultSplit);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return diagnosisList.Distinct().ToList();
|
|
}
|
|
/// <summary>
|
|
/// 获取项目诊断通过匹配关系
|
|
/// </summary>
|
|
/// <param name="itemInput"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<string>> GetItemDiagnosisByMatche(ItemInput itemInput)
|
|
{
|
|
List<string> diagnosisList = new List<string>();
|
|
//将结果解析到数组中
|
|
string[] resultArry = GetResultArry(itemInput.Result);
|
|
|
|
foreach (var resultSplit in resultArry)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(resultSplit) || resultSplit.StartsWith("余未见异常"))
|
|
{
|
|
continue;
|
|
}
|
|
var templatesList = itemInput.ItemResultMatches.Where(o => resultSplit.Contains(o.Result)).ToList();
|
|
foreach (var template in templatesList)
|
|
{
|
|
if (template != null && template.DiagnosisId != Guid.Empty)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == template.DiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
diagnosisList.Add(temp_diagnosis.DisplayName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return diagnosisList.Distinct().ToList();
|
|
}
|
|
/// <summary>
|
|
/// 去掉结果中的数字符号和分号
|
|
/// </summary>
|
|
/// <param name="result"></param>
|
|
/// <returns></returns>
|
|
private string[] GetResultArry(string result)
|
|
{
|
|
result = result.Trim().Replace("；", ";");
|
|
foreach (var num in _numArry)
|
|
{
|
|
result = result.Replace(num, "");
|
|
}
|
|
//将结果通过英文；解析到数组中
|
|
string[] resultArry = result.Split(";");
|
|
return resultArry;
|
|
}
|
|
#region 执行项目计算函数
|
|
|
|
/// <summary>
|
|
/// 生成计算函数值
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <returns></returns>
|
|
[HttpPost("api/app/diagnosisfunction/getcalculationfunctionresult")]
|
|
public async Task<GetDiagnosisResultRequestDto> GetCalculationFunctionResultAsync(GetDiagnosisResultRequestDto input)
|
|
{
|
|
await GetItemResultByCalculationFunctionAsync(input);
|
|
return input;
|
|
}
|
|
|
|
private async Task GetItemResultByCalculationFunctionAsync(GetDiagnosisResultRequestDto input)
|
|
{
|
|
//根据检查单ID查询
|
|
var list = (
|
|
from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
|
|
join registerCheck in await _registerCheckRepository.GetQueryableAsync()
|
|
on patientRegister.Id equals registerCheck.PatientRegisterId
|
|
join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
|
|
on registerCheck.Id equals registerCheckItem.RegisterCheckId
|
|
join item in await _itemRepository.GetQueryableAsync()
|
|
on registerCheckItem.ItemId equals item.Id
|
|
where registerCheck.Id == input.RegisterCheckId
|
|
select new
|
|
{
|
|
PatientRegister = patientRegister,
|
|
Item = item
|
|
}
|
|
).ToList();
|
|
|
|
var diagnosisBuilder = new DiagnosisBuilder();
|
|
var patientItemCalculateInput = new PatientItemCalculateInput()
|
|
{
|
|
SexName = _cacheService.GetSexNameAsync(list[0].PatientRegister.SexId).Result,
|
|
Age = list[0].PatientRegister.Age
|
|
};
|
|
foreach (var item in input.Items)
|
|
{
|
|
var itemResult = new ItemResultInput()
|
|
{
|
|
ItemId = item.ItemId,
|
|
Result = item.Result
|
|
};
|
|
itemResult.ItemName = list.Where(o => o.Item.Id == item.ItemId).First().Item.DisplayName;
|
|
patientItemCalculateInput.Items.Add(itemResult);
|
|
}
|
|
|
|
foreach (var item in list)
|
|
{
|
|
if (item.Item.IsCalculationItem == 'Y' && !string.IsNullOrEmpty(item.Item.CalculationFunction))
|
|
{
|
|
//计算函数
|
|
//计算结果
|
|
|
|
string CalculationFunctionValue = diagnosisBuilder.GetItemCalculateResult(patientItemCalculateInput, item.Item.CalculationFunction);
|
|
//CalculationFunctionValue = GetCodeResult(input, item.CalculationFunction, list);
|
|
|
|
input.Items.Where(m => m.ItemId == item.Item.Id).FirstOrDefault().Result = CalculationFunctionValue; //赋值
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
/// <summary>
|
|
/// 执行组合项目 诊断函数
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="asbitem_data"></param>
|
|
/// <param name="item_datas"></param>
|
|
/// <param name="patientRegister_data"></param>
|
|
/// <param name="diagnosisTrips"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<GetDiagnosisResult_Detail>> GetDiagnosisResultInAsbitemAsync(GetDiagnosisResultRequestDto input, Asbitem asbitem_data, List<Item> item_datas, PatientRegister patientRegister_data, List<string> diagnosisTrips)
|
|
{
|
|
var reslist = new List<GetDiagnosisResult_Detail>();
|
|
|
|
if (input.Items.Count > 0)
|
|
{
|
|
//执行函数 返回结果
|
|
string DiagnosisFunctionResult_Asbitem = GetCodeResult(input, asbitem_data.DiagnosisFunction, item_datas);
|
|
|
|
if (!string.IsNullOrEmpty(DiagnosisFunctionResult_Asbitem))
|
|
{
|
|
reslist.Add(new GetDiagnosisResult_Detail
|
|
{
|
|
DiagnosisResult = DiagnosisFunctionResult_Asbitem
|
|
});
|
|
}
|
|
//是否继续执行项目诊断函数
|
|
if (asbitem_data.IsContinueProcess == 'Y')
|
|
{
|
|
var itemResult = await GetDiagnosisResultInItemAsync(input, item_datas, patientRegister_data, diagnosisTrips); //执行项目诊断函数
|
|
if (itemResult.Any())
|
|
{
|
|
reslist.AddRange(itemResult);
|
|
}
|
|
}
|
|
}
|
|
|
|
return reslist;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 执行项目 诊断函数
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="item_datas"></param>
|
|
/// <param name="patientRegister_data"></param>
|
|
/// <param name="diagnosisTrips"></param>
|
|
/// <returns></returns>
|
|
private async Task<List<GetDiagnosisResult_Detail>> GetDiagnosisResultInItemAsync(GetDiagnosisResultRequestDto input, List<Item> item_datas, PatientRegister patientRegister_data, List<string> diagnosisTrips)
|
|
{
|
|
var reslist = new List<GetDiagnosisResult_Detail>();
|
|
|
|
if (input.Items.Count > 0)
|
|
{
|
|
foreach (var item_data in item_datas)
|
|
{
|
|
if (item_data.IsDiagnosisFunction == 'Y' && !string.IsNullOrEmpty(item_data.DiagnosisFunction))
|
|
{
|
|
var DiagnosisFunctionResult_Item = GetCodeResult(input, item_data.DiagnosisFunction, item_datas);
|
|
|
|
if (!string.IsNullOrEmpty(DiagnosisFunctionResult_Item))
|
|
{
|
|
reslist.Add(new GetDiagnosisResult_Detail
|
|
{
|
|
DiagnosisResult = DiagnosisFunctionResult_Item
|
|
});
|
|
}
|
|
|
|
//是否继续执行参考范围规则
|
|
if (item_data.IsContinueProcess == 'Y' && item_data.IsProduceSummary == 'Y')
|
|
{
|
|
string itemResult_Request = input.Items.Where(m => m.ItemId == item_data.Id).FirstOrDefault().Result; //项目结果
|
|
|
|
//执行参考范围
|
|
string referenceRangesResult = await GetDiagnosisResultInReferenceRangesAsync(item_data, itemResult_Request, patientRegister_data, diagnosisTrips);
|
|
if (!string.IsNullOrEmpty(referenceRangesResult))
|
|
{
|
|
if (item_data.IsNameIntoSummary == 'Y')
|
|
DiagnosisFunctionResult_Item = item_data.DisplayName + DiagnosisFunctionResult_Item;
|
|
reslist.Add(new GetDiagnosisResult_Detail { DiagnosisResult = referenceRangesResult });
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return reslist;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 执行项目 参考范围获取结果
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <param name="itemResult"></param>
|
|
/// <param name="patientRegister_data"></param>
|
|
/// <param name="diagnosisTrips"></param>
|
|
/// <returns></returns>
|
|
private async Task<string> GetDiagnosisResultInReferenceRangesAsync(Item item, string itemResult, PatientRegister patientRegister_data, List<string> diagnosisTrips)
|
|
{
|
|
|
|
string referenceRangesResult = "";
|
|
string diagnosisTrip = ""; //诊断提示，参考范围性别、年龄 异常时出现
|
|
|
|
var item_ReferenceRangeList = item.ReferenceRanges.Where(m => m.ReferenceRangeTypeFlag == item.ReferenceRangeTypeFlag).ToList();
|
|
if (item_ReferenceRangeList.Any() && item.ReferenceRangeTypeFlag == ItemReferenceRangeTypeFlag.Number)
|
|
{
|
|
//数字参考范围
|
|
|
|
|
|
List<ReferenceRange> referenceRanges = new List<ReferenceRange>();
|
|
|
|
if (patientRegister_data.Age != null)
|
|
{
|
|
referenceRanges = item_ReferenceRangeList.Where(m => m.AgeLowerLimit <= patientRegister_data.Age
|
|
&& m.AgeUpperLimit >= patientRegister_data.Age).ToList();
|
|
|
|
}
|
|
else
|
|
{
|
|
//if (string.IsNullOrEmpty(DiagnosisTrip))
|
|
//{
|
|
// DiagnosisTrip += "未登记年龄";
|
|
//}
|
|
//else
|
|
//{
|
|
// DiagnosisTrip += ",未登记年龄";
|
|
//}
|
|
|
|
diagnosisTrip = "未登记年龄";
|
|
|
|
//找出默认的0-200
|
|
referenceRanges = item_ReferenceRangeList.Where(m => m.AgeLowerLimit == 0
|
|
&& m.AgeUpperLimit == 200).ToList();
|
|
}
|
|
|
|
if (referenceRanges.Any())
|
|
{
|
|
//比对性别
|
|
var referenceRanges2 = referenceRanges.Where(m => patientRegister_data.SexId != null && m.ForSexId == patientRegister_data.SexId).ToList();
|
|
|
|
if (!referenceRanges2.Any())
|
|
{
|
|
//未找到，去匹配适用性别为A的
|
|
referenceRanges2 = referenceRanges.Where(m => m.ForSexId == ForSexFlag.All).ToList();
|
|
|
|
if (referenceRanges2.Any())
|
|
{
|
|
//数字参考范围类型
|
|
referenceRangesResult = await GetDiagnosisResultInNumRangeAsync(item, itemResult, referenceRanges2[0]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////符合条件的参考范围
|
|
//var item_ReferenceRange = item_ReferenceRangeList.Where(m =>
|
|
//(m.ForSexId.ToString() == ForSexFlag.All || (patientRegister_data.SexId != null && m.ForSexId == patientRegister_data.SexId))
|
|
// && patientRegister_data.Age != null
|
|
// && m.AgeLowerLimit <= patientRegister_data.Age
|
|
// && m.AgeUpperLimit >= patientRegister_data.Age).ToList();
|
|
|
|
//if (item_ReferenceRange.Count > 0)
|
|
//{
|
|
// if (item_ReferenceRange.Count == 1)
|
|
// {
|
|
// //数字参考范围类型
|
|
// result = await GetDiagnosisResultInNumRangeAsync(item, itemResult, item_ReferenceRange[0]);
|
|
// }
|
|
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
//无参考范围或者字符参考范围
|
|
referenceRangesResult = await GetDiagnosisResultInItemResultTemplateAsync(item, itemResult);
|
|
if (string.IsNullOrEmpty(referenceRangesResult))
|
|
{
|
|
//未匹配上，继续
|
|
referenceRangesResult = await GetDiagnosisResultInItemResultMatchAsync(item, itemResult);
|
|
|
|
if (string.IsNullOrEmpty(referenceRangesResult))
|
|
{
|
|
//未匹配上，继续
|
|
//对比项目默认结果，如果不是默认结果则直接用结果做为小结。
|
|
if (item.DefaultResult != itemResult)
|
|
{
|
|
referenceRangesResult = itemResult;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if (!string.IsNullOrEmpty(diagnosisTrip))
|
|
diagnosisTrips.Add(diagnosisTrip);
|
|
|
|
|
|
return referenceRangesResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 根据项目结果模板生成
|
|
/// 检查项目结果模板，如果和项目结果模板一致，则根据对应的诊断生成小结 完全匹配
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task<string> GetDiagnosisResultInItemResultTemplateAsync(Item item, string itemResult)
|
|
{
|
|
string result = "";
|
|
var temp_itemResultTemplate = await _itemResultTemplateRepository.FirstOrDefaultAsync(m => m.ItemId == item.Id && m.Result == itemResult);
|
|
if (temp_itemResultTemplate != null && temp_itemResultTemplate.DiagnosisId != null && temp_itemResultTemplate.DiagnosisId != Guid.Empty)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == temp_itemResultTemplate.DiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
result = temp_diagnosis.DisplayName;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 根据项目项目结果匹配（诊断匹配） 生成
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private async Task<string> GetDiagnosisResultInItemResultMatchAsync(Item item, string itemResult)
|
|
{
|
|
string result = "";
|
|
var temp_itemResultMatch = await _itemResultMatchRepository.FirstOrDefaultAsync(m => m.ItemId == item.Id && itemResult.Contains(m.Result));
|
|
if (temp_itemResultMatch != null && temp_itemResultMatch.DiagnosisId != Guid.Empty)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == temp_itemResultMatch.DiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
result = temp_diagnosis.DisplayName;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 根据数字型范围值对应的诊断匹配 生成
|
|
/// 如果在范围外又没有设置诊断，则用项目名称加偏高偏低后缀生成小结(需要根据系统参数)。
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <param name="itemResult"></param>
|
|
/// <param name="item_ReferenceRange">当前匹配的参考范围</param>
|
|
/// <returns></returns>
|
|
private async Task<string> GetDiagnosisResultInNumRangeAsync(Item item, string itemResult, ReferenceRange item_ReferenceRange)
|
|
{
|
|
|
|
string result = "";
|
|
|
|
|
|
string diagnosisFlag = "1"; //1=正常 2=偏高 0=偏低
|
|
|
|
|
|
#region 处理异常结果 > < = 剔除
|
|
|
|
itemResult = itemResult.Replace(">", "").Replace("<", "").Replace("=", "");
|
|
|
|
try
|
|
{
|
|
var tempConvert = Convert.ToDecimal(itemResult);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 匹配参考范围
|
|
|
|
string item_referenceRangeValue = item_ReferenceRange.ReferenceRangeValue;
|
|
if (item_referenceRangeValue.IndexOf("-") > -1)
|
|
{
|
|
var value_ary = item_referenceRangeValue.Split('-');
|
|
if (value_ary.Length == 2)
|
|
{
|
|
decimal minvalue = Convert.ToDecimal(value_ary[0]);
|
|
decimal maxvalue = Convert.ToDecimal(value_ary[1]);
|
|
|
|
|
|
|
|
if (Convert.ToDecimal(itemResult) > maxvalue)
|
|
{
|
|
//偏高
|
|
diagnosisFlag = "2";
|
|
}
|
|
else if (Convert.ToDecimal(itemResult) < minvalue)
|
|
{
|
|
//偏低
|
|
diagnosisFlag = "0";
|
|
}
|
|
}
|
|
}
|
|
else if (item_referenceRangeValue.IndexOf(">=") > -1)
|
|
{
|
|
if (Convert.ToDecimal(itemResult) < Convert.ToDecimal(item_referenceRangeValue.Replace(">=", "")))
|
|
{
|
|
//偏低
|
|
diagnosisFlag = "0";
|
|
}
|
|
}
|
|
else if (item_referenceRangeValue.IndexOf("<=") > -1)
|
|
{
|
|
if (Convert.ToDecimal(itemResult) > Convert.ToDecimal(item_referenceRangeValue.Replace("<=", "")))
|
|
{
|
|
//偏高
|
|
diagnosisFlag = "2";
|
|
}
|
|
}
|
|
else if (item_referenceRangeValue.IndexOf(">") > -1)
|
|
{
|
|
if (Convert.ToDecimal(itemResult) <= Convert.ToDecimal(item_referenceRangeValue.Replace(">", "")))
|
|
{
|
|
//偏低
|
|
diagnosisFlag = "0";
|
|
}
|
|
}
|
|
else if (item_referenceRangeValue.IndexOf("<") > -1)
|
|
{
|
|
if (Convert.ToDecimal(itemResult) >= Convert.ToDecimal(item_referenceRangeValue.Replace("<", "")))
|
|
{
|
|
//偏高
|
|
diagnosisFlag = "2";
|
|
}
|
|
}
|
|
|
|
|
|
if (diagnosisFlag == "2")
|
|
{
|
|
//偏高
|
|
if (item_ReferenceRange.UpperDiagnosisId != null)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == item_ReferenceRange.UpperDiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
result = temp_diagnosis.DisplayName;
|
|
}
|
|
else
|
|
{
|
|
result = $"{item.DisplayName}偏高";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = $"{item.DisplayName}偏高";
|
|
}
|
|
}
|
|
else if (diagnosisFlag == "0")
|
|
{
|
|
//偏低
|
|
if (item_ReferenceRange.LowerDiagnosisId != null)
|
|
{
|
|
var temp_diagnosis = await _diagnosisRepository.FirstOrDefaultAsync(m => m.Id == item_ReferenceRange.LowerDiagnosisId);
|
|
if (temp_diagnosis != null)
|
|
{
|
|
result = temp_diagnosis.DisplayName;
|
|
}
|
|
else
|
|
{
|
|
result = $"{item.DisplayName}偏低";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = $"{item.DisplayName}偏低";
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 动态编译代码 返回string
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="DiagnosisFunctionCode"></param>
|
|
/// <param name="item_datas"></param>
|
|
/// <returns></returns>
|
|
private string GetCodeResult(GetDiagnosisResultRequestDto input, string DiagnosisFunctionCode, List<Item> item_datas)
|
|
{
|
|
string result = "";
|
|
|
|
string DiagnosisFunctionCode_Replace = ReplaceFunctionLabel(input, DiagnosisFunctionCode, item_datas);
|
|
|
|
//拼接动态代码
|
|
string code = @"
|
|
|
|
public class DiagnosisResultInAsbitemHeight
|
|
{
|
|
public string AutoDiagnosisResultInAsbitemHeight()
|
|
{
|
|
var msg="""";"
|
|
+ DiagnosisFunctionCode_Replace + @"
|
|
return msg;
|
|
}
|
|
}";
|
|
|
|
CompileHelper compileHelper = new CompileHelper();
|
|
|
|
var assembly = compileHelper.GenerateAssemblyFromCode(code, Assembly.Load(new AssemblyName("System.Runtime")), typeof(object).Assembly);
|
|
|
|
if (assembly != null)
|
|
{
|
|
|
|
// 反射获取程序集中 的类
|
|
Type type = assembly.GetType("DiagnosisResultInAsbitemHeight");
|
|
|
|
// 创建该类的实例
|
|
object obj = Activator.CreateInstance(type);
|
|
|
|
var msg = type.InvokeMember("AutoDiagnosisResultInAsbitemHeight",
|
|
BindingFlags.Default | BindingFlags.InvokeMethod,
|
|
null,
|
|
obj,
|
|
null);
|
|
|
|
if (!string.IsNullOrEmpty(msg.ToString()))
|
|
{
|
|
result = msg.ToString();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 替换函数中的标签
|
|
/// </summary>
|
|
/// <param name="input"></param>
|
|
/// <param name="DiagnosisFunctionCode"></param>
|
|
/// <param name="item_datas"></param>
|
|
/// <returns></returns>
|
|
private string ReplaceFunctionLabel(GetDiagnosisResultRequestDto input, string DiagnosisFunctionCode, List<Item> item_datas)
|
|
{
|
|
string tempcode = DiagnosisFunctionCode;
|
|
|
|
//替换诊断函数中的标签
|
|
foreach (var item in input.Items)
|
|
{
|
|
if (item.ItemId != null)
|
|
{
|
|
var itement = item_datas.Where(m => m.Id == item.ItemId).FirstOrDefault(); //查询项目信息
|
|
if (itement != null)
|
|
{
|
|
//根据项目的名称 替换对应传过来的值
|
|
tempcode = tempcode.Replace($"[{itement.DisplayName}]", item.Result);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (tempcode.IndexOf('[') != -1)
|
|
{
|
|
throw new UserFriendlyException("函数中有未识别的语法");
|
|
}
|
|
|
|
return tempcode;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|