peis/src/Shentun.Peis.Application/DiagnosisFunctions/DiagnosisFunctionAppService.cs

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;
        }



    }
}