peis/src/Shentun.Peis.Application/PrintReports/PrintReportAppService.cs

using IdentityModel.Client;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Npgsql.Internal.TypeHandlers.DateTimeHandlers;
using NPOI.POIFS.Properties;
using NUglify.Helpers;
using Shentun.Peis.AsbitemGuides;
using Shentun.Peis.DiagnosisFunctions;
using Shentun.Peis.Enums;
using Shentun.Peis.LisRequests;
using Shentun.Peis.Models;
using Shentun.Peis.OcCheckTypes;
using Shentun.Peis.OccupationalDiseases;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.Reports;
using Shentun.Peis.Reports.ConvertRpt;
using Shentun.Peis.SumSuggestionContents;
using Shentun.Peis.SumSuggestionHeaders;
using Shentun.Peis.SumSummaryContents;
using Shentun.Peis.SumSummaryHeaders;
using Shentun.Peis.SumSummaryReports;
using Shentun.Peis.SysParmValues;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Uow;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace Shentun.Peis.PrintReports
{
    /// <summary>
    /// 打印报告服务
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class PrintReportAppService : ApplicationService
    {
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private static IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemStaticRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<RegisterCheckSummary> _registerCheckSummaryRepository;
        private readonly IRepository<RegisterCheckPicture, Guid> _registerCheckPictureRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<MedicalPackage, Guid> _medicalPackageRepository;
        private readonly IRepository<MedicalReportType, char> _medicalReportTypeRepository;
        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly IRepository<SampleGroup, Guid> _sampleGroupRepository;
        private readonly IRepository<SampleGroupDetail> _sampleGroupDetailRepository;
        private readonly IRepository<SampleContainer, Guid> _sampleContainerRepository;
        private readonly IRepository<SampleType, Guid> _sampleTypeRepository;
        private readonly IRepository<Sex> _sexRegisterRepository;
        private readonly IRepository<ResultStatus> _resultStatusRepository;
        private readonly IRepository<SumSummaryHeader, Guid> _sumSummaryHeaderRepository;
        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
        private readonly IRepository<SumSuggestionHeader, Guid> _sumSuggestionHeaderRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;
        //private readonly IOrganizationUnitRepository _organizationUnitRepository;
        private readonly IRepository<OrganizationUnit, Guid> _organizationUnitRepository;
        private readonly IPatientRegisterGuideReportRepository _patientRegisterGuideReportRepository;
        private readonly ILisRequestReportRepository _lisRequestReportRepository;
        //private readonly ICheckRequestNoReportRepository _checkRequestNoReportRepository;
        private readonly IChargeReportRepository _chargeReportRepository;
        private readonly SysParmValueManager _sysParmValueManager;
        private readonly CacheService _cacheService;
        private readonly LisRequestManager _lisRequestManager;
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        private static AsbitemGuideManager _asbitemGuideManager;
        private readonly IConfiguration _configuration;
        private readonly IRepository<PatientOccupationalDisease, Guid> _patientOccupationalDiseaseRepository;
        private readonly IRepository<PatientOccupationalHistory, Guid> _patientOccupationalHistoryRepository;
        private readonly IRepository<PatientPoison> _patientPoisonRepository;
        private readonly IRepository<PatientSymptom> _patientSymptomRepository;
        private readonly IRepository<PatientOccupationalMedicalHistory, Guid> _patientOccupationalMedicalHistoryRepository;
        private readonly IRepository<PatientPastMedicalHistory, Guid> _patientPastMedicalHistoryRepository;
        private readonly IRepository<OcCheckType, Guid> _ocCheckTypeRepository;
        private readonly IRepository<Poison, Guid> _poisonRepository;
        private readonly IRepository<OccupationalAbnormal, Guid> _occupationalAbnormalRepository;
        private readonly IRepository<Symptom, Guid> _symptomRepository;


        public PrintReportAppService(
            IRepository<Patient, Guid> patientRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            IRepository<RegisterCheckSummary> registerCheckSummaryRepository,
            IRepository<RegisterCheckPicture, Guid> registerCheckPictureRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<MedicalPackage, Guid> medicalPackageRepository,
            IRepository<MedicalReportType, char> medicalReportTypeRepository,
            IRepository<ItemType, Guid> itemTypeRepository,
            IRepository<LisRequest, Guid> lisRequestRepository,
            IRepository<SampleGroup, Guid> sampleGroupRepository,
            IRepository<SampleContainer, Guid> sampleContainerRepository,
            IRepository<SampleType, Guid> sampleTypeRepository,
            IRepository<Sex> sexRegisterRepository,
            IRepository<PersonnelType, Guid> personnelTypeRepository,
            IRepository<ResultStatus> resultStatusRepository,
            IRepository<SumSummaryHeader, Guid> sumSummaryHeaderRepository,
            IRepository<IdentityUser, Guid> identityUserRepository,
            IRepository<SumSuggestionHeader, Guid> sumSuggestionHeaderRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            //IOrganizationUnitRepository organizationUnitRepository,
            IRepository<OrganizationUnit, Guid> organizationUnitRepository,
            IPatientRegisterGuideReportRepository patientRegisterGuideReportRepository,
            ILisRequestReportRepository lisRequestReportRepository,
            //ICheckRequestNoReportRepository checkRequestNoReportRepository,
            IChargeReportRepository chargeReportRepository,

           SysParmValueManager sysParmValueManager,
           CacheService cacheService,
           LisRequestManager lisRequestManager,
           IUnitOfWorkManager unitOfWorkManager,
           AsbitemGuideManager asbitemGuideManager,
           IConfiguration configuration,
           IRepository<PatientOccupationalDisease, Guid> patientOccupationalDiseaseRepository,
           IRepository<PatientOccupationalHistory, Guid> patientOccupationalHistoryRepository,
           IRepository<PatientPoison> patientPoisonRepository,
           IRepository<PatientSymptom> patientSymptomRepository,
           IRepository<PatientOccupationalMedicalHistory, Guid> patientOccupationalMedicalHistoryRepository,
           IRepository<PatientPastMedicalHistory, Guid> patientPastMedicalHistoryRepository
,
           IRepository<OcCheckType, Guid> ocCheckTypeRepository,
           IRepository<Poison, Guid> poisonRepository,
           IRepository<OccupationalAbnormal, Guid> occupationalAbnormalRepository,
           IRepository<Symptom, Guid> symptomRepository,
           IRepository<SampleGroupDetail> sampleGroupDetailRepository)
        {
            this._customerOrgRepository = customerOrgRepository;
            this._patientRegisterRepository = patientRegisterRepository;
            this._sexRegisterRepository = sexRegisterRepository;
            this._resultStatusRepository = resultStatusRepository;
            this._sumSummaryHeaderRepository = sumSummaryHeaderRepository;
            this._identityUserRepository = identityUserRepository;
            this._sumSuggestionHeaderRepository = sumSuggestionHeaderRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._organizationUnitRepository = organizationUnitRepository;
            this._patientRegisterGuideReportRepository = patientRegisterGuideReportRepository;
            this._lisRequestReportRepository = lisRequestReportRepository;
            //this._checkRequestNoReportRepository = checkRequestNoReportRepository;
            this._chargeReportRepository = chargeReportRepository;
            this._sysParmValueManager = sysParmValueManager;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _registerCheckAsbitemStaticRepository = registerCheckAsbitemRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _registerCheckPictureRepository = registerCheckPictureRepository;
            _asbitemRepository = asbitemRepository;
            _itemRepository = itemRepository;
            _medicalReportTypeRepository = medicalReportTypeRepository;
            _itemTypeRepository = itemTypeRepository;
            _lisRequestRepository = lisRequestRepository;
            _sampleGroupRepository = sampleGroupRepository;
            _sampleContainerRepository = sampleContainerRepository;
            _sampleTypeRepository = sampleTypeRepository;
            _cacheService = cacheService;
            _lisRequestManager = lisRequestManager;
            _unitOfWorkManager = unitOfWorkManager;
            _patientRepository = patientRepository;
            _asbitemGuideManager = asbitemGuideManager;
            _customerOrgGroupRepository = customerOrgGroupRepository;
            _medicalPackageRepository = medicalPackageRepository;
            _personnelTypeRepository = personnelTypeRepository;
            _configuration = configuration;
            _organizationUnitRepository = organizationUnitRepository;
            _patientOccupationalDiseaseRepository = patientOccupationalDiseaseRepository;
            _patientOccupationalHistoryRepository = patientOccupationalHistoryRepository;
            _patientPoisonRepository = patientPoisonRepository;
            _patientSymptomRepository = patientSymptomRepository;
            _patientOccupationalMedicalHistoryRepository = patientOccupationalMedicalHistoryRepository;
            _patientPastMedicalHistoryRepository = patientPastMedicalHistoryRepository;
            _ocCheckTypeRepository = ocCheckTypeRepository;
            _poisonRepository = poisonRepository;
            _occupationalAbnormalRepository = occupationalAbnormalRepository;
            _symptomRepository = symptomRepository;
            _sampleGroupDetailRepository = sampleGroupDetailRepository;
        }


        /// <summary>
        /// 获取体检人员指引单报告数据
        /// </summary>
        /// <param name="PatientRegisterId"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/getpatientregisterguidereport")]
        public async Task<PatientRegisterGuideReportDto> GetPatientRegisterGuideReportAsync(Guid PatientRegisterId)
        {
            //return await _patientRegisterGuideReportRepository.GetPatientRegisterGuideReportAsync(PatientRegisterId);

            //_cacheService.GetMedicalTypeNameAsync

            var apiUrl = _configuration.GetValue<string>("HostUrl:ApiUrl") + "/";
            var patientRegister = await _patientRegisterRepository.GetAsync(o => o.Id == PatientRegisterId);
            Guid medicalCenterId = patientRegister.MedicalCenterId;


            #region 系统参数配置
            var MedicalCenterAddress = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "medical_center_address");
            var MedicalCenterFax = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "medical_center_fax");
            var MedicalCenterTelphone = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "medical_center_telphone");
            #endregion

            //var customerOrgList = await _customerOrgRepository.GetListAsync();

            var query = from a in await _patientRegisterRepository.GetQueryableAsync()
                        join b in await _sexRegisterRepository.GetQueryableAsync()
                        on a.SexId equals b.Id
                        join c in await _customerOrgGroupRepository.GetQueryableAsync()
                        on a.CustomerOrgGroupId equals c.Id into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _medicalPackageRepository.GetQueryableAsync()
                        on a.MedicalPackageId equals d.Id into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _patientRepository.GetQueryableAsync()
                        on a.PatientId equals e.Id
                        join f in await _personnelTypeRepository.GetQueryableAsync()
                        on a.PersonnelTypeId equals f.Id into ff
                        from af in ff.DefaultIfEmpty()
                        join g in await _organizationUnitRepository.GetQueryableAsync()
                        on a.MedicalCenterId equals g.Id into gg
                        from ag in gg.DefaultIfEmpty()
                        where (a.Id == PatientRegisterId)
                        select new PatientRegisterGuideReportDto
                        {
                            Age = a.Age,
                            PatientRegisterId = a.Id,
                            CustomerOrgGroupName = ac.DisplayName,
                            CustomerOrgName = _cacheService.GetTopCustomerOrgNameAsync(a.CustomerOrgId).GetAwaiter().GetResult(),
                            CustomerOrgShortName = _cacheService.GetTopCustomerOrgAsync(a.CustomerOrgId).GetAwaiter().GetResult().ShortName,
                            DepartmentName = _cacheService.GetAllDepartmentNameAsync(a.CustomerOrgId).GetAwaiter().GetResult(),
                            IdNo = e.IdNo,
                            JobCardNo = a.JobCardNo,
                            MedicalCardNo = a.MedicalCardNo,
                            MedicalCenterAddress = MedicalCenterAddress,
                            MedicalCenterFax = MedicalCenterFax,
                            MedicalCenterTelphone = MedicalCenterTelphone,
                            MedicalPackageName = ad.DisplayName,
                            MedicalTimes = a.MedicalTimes,
                            MobileTelephone = e.MobileTelephone,
                            PatientName = a.PatientName,
                            PatientNo = e.PatientNo,
                            PatientRegisterNo = a.PatientRegisterNo,
                            PersonnelTypeName = af.DisplayName,
                            SexName = b.DisplayName,
                            // Photo = string.IsNullOrEmpty(a.Photo) ? "" : ImageHelper.GetImageBase64StringAsync( a.Photo),
                            Photo = string.IsNullOrEmpty(a.Photo) ? "" : apiUrl + a.Photo,
                            MedicalStartDate = Convert.ToDateTime(a.MedicalStartDate.ToString()).ToString("yyyy-MM-dd"),
                            OrganizationUnitId = a.MedicalCenterId,
                            OrganizationUnitName = ag.DisplayName,
                            Detail = PatientRegisterGuideAsbitem(a.Id, a.PatientRegisterNo, medicalCenterId, a.SexId),
                            HisPatientId = a.HisPatientId,
                            MedicalTypeName = _cacheService.GetMedicalTypeNameAsync(a.MedicalTypeId).Result,
                        };

            return query.FirstOrDefault();

        }


        /// <summary>
        /// 获取体检人员指引单报告数据  不需要转换版本
        /// </summary>
        /// <param name="PatientRegisterId"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetPatientRegisterGuideReportConvertToReport")]
        public async Task<Rpt0001Dto> GetPatientRegisterGuideReportConvertToReportAsync(Guid PatientRegisterId)
        {
            var oldDto = await GetPatientRegisterGuideReportAsync(PatientRegisterId);
            var entDto = await ConvertToReport.ToPatientGuideReportDataAsync(oldDto);
            return entDto;
        }

        /// <summary>
        /// 批量获取体检人员指引单报告数据
        /// </summary>
        /// <param name="PatientRegisterIds"></param>
        /// <returns></returns>
        [HttpPost("api/app/printreport/getpatientregisterguidereportmany")]
        public async Task<List<PatientRegisterGuideReportDto>> GetPatientRegisterGuideReportManyAsync(List<Guid> PatientRegisterIds)
        {
            return await _patientRegisterGuideReportRepository.GetPatientRegisterGuideReportManyAsync(PatientRegisterIds);
        }



        /// <summary>
        /// 打印检验申请单
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetLisRequestReportByPatientRegisterId")]
        public async Task<List<LisRequestReportDto>> GetLisRequestReportByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            //生成LIS条码
            var lisRequests = await _lisRequestManager.SetLisRequestAsync(input.PatientRegisterId);
            await _unitOfWorkManager.Current.SaveChangesAsync();
            await _unitOfWorkManager.Current.CompleteAsync();

            var entlist = new List<LisRequestReportDto>();

            //检索条码数据
            using (var uow = _unitOfWorkManager.Begin(
                requiresNew: false, isTransactional: false
            ))
            {
                var query = (from patient in await _patientRepository.GetQueryableAsync()
                             join patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                             on patient.Id equals patientRegister.PatientId
                             join sex in await _sexRegisterRepository.GetQueryableAsync() on patientRegister.SexId equals sex.Id
                             join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on patientRegister.Id equals registerCheckAsbitem.PatientRegisterId
                             join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id
                             join lisRequest in await _lisRequestRepository.GetQueryableAsync() on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                             join sampleContainer in await _sampleContainerRepository.GetQueryableAsync() on lisRequest.SampleContainerId equals sampleContainer.Id into dd
                             from sampleContainerHaveEmpty in dd.DefaultIfEmpty()
                             join sampleType in await _sampleTypeRepository.GetQueryableAsync() on lisRequest.SampleTypeId equals sampleType.Id into ee
                             from sampleTypeHaveEmpty in ee.DefaultIfEmpty()
                             join sampleGroupDetail in await _sampleGroupDetailRepository.GetQueryableAsync() on asbitem.Id equals sampleGroupDetail.AsbitemId into sampleGroupDetailTemp
                             from sampleTypeHaveEmptyHaveEmpty in sampleGroupDetailTemp.DefaultIfEmpty()
                             join sampleGroup in await _sampleGroupRepository.GetQueryableAsync()
                             on sampleTypeHaveEmptyHaveEmpty.SampleGroupId equals sampleGroup.Id into sampleGroupTemp
                             from sampleGroupHaveEmpty in sampleGroupTemp.DefaultIfEmpty()
                             where (patientRegister.Id == input.PatientRegisterId && registerCheckAsbitem.LisRequestId != null)
                             select new
                             {
                                 patient,
                                 patientRegister,
                                 sex,
                                 registerCheckAsbitem,
                                 asbitem,
                                 lisRequest,
                                 sampleContainerHaveEmpty,
                                 sampleTypeHaveEmpty,
                                 sampleGroupName = sampleGroupHaveEmpty != null ? sampleGroupHaveEmpty.DisplayName : "",
                                 samplePrintCount = sampleGroupHaveEmpty != null ? sampleGroupHaveEmpty.SamplePrintCount : 0
                             }
                          ).ToList();

                if (query.Count == 0)
                {
                    return new List<LisRequestReportDto>();
                }

                lisRequests = query.Select(o => o.lisRequest).Distinct().ToList();
                //发送第三方LIS申请
                if (lisRequests != null)
                {
                    foreach (var lisRequest in lisRequests)
                    {
                        await _lisRequestManager.SendThirdLisRequestAsync(lisRequest.Id);
                    }
                }

                var lisRequestReportDtoList = query.Select(o => new LisRequestReportDto
                {
                    LisRequestId = o.lisRequest.Id,
                    PatientNo = o.patient.PatientNo,
                    Age = o.patientRegister.Age,
                    AsbitemNames = string.IsNullOrEmpty(o.asbitem.ShortName) ? o.asbitem.DisplayName : o.asbitem.ShortName,
                    LisRequestNo = o.lisRequest.LisRequestNo,
                    PatientName = o.patientRegister.PatientName,
                    PatientRegisterNo = o.patientRegister.PatientRegisterNo,
                    SampleContainerName = (o.sampleContainerHaveEmpty == null) ? "" : o.sampleContainerHaveEmpty.DisplayName,
                    ContainerColor = (o.sampleContainerHaveEmpty == null) ? 16777215 : o.sampleContainerHaveEmpty.ContainerColor,
                    SampleContainerRemark = (o.sampleContainerHaveEmpty == null) ? "" : o.sampleContainerHaveEmpty.ContainerRemark,
                    SampleTypeName = (o.sampleTypeHaveEmpty == null) ? "" : o.sampleTypeHaveEmpty.DisplayName,
                    SexName = o.sex.DisplayName,
                    CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(o.patientRegister.CustomerOrgId).Result,
                    DepartmentName = _cacheService.GetAllDepartmentNameAsync(o.patientRegister.CustomerOrgId).Result,
                    IsPrint = o.lisRequest.IsPrint,
                    IsSignIn = o.lisRequest.IsSignIn,
                    SamplingTime = o.lisRequest.SamplingTime,
                    SignInOrder = o.lisRequest.SignInOrder,
                    SignInPerson = o.lisRequest.SignInPerson,
                    SignInTime = o.lisRequest.SignInTime,
                    SampleGroupName = o.sampleGroupName,
                    MobileTelephone = o.patient.MobileTelephone,
                    SamplePrintCount = o.samplePrintCount,
                    DeviceLisRequestPrintTimes = o.lisRequest.DeviceLisRequestPrintTimes
                }).ToList();


                var lisRequestNoPrintMode = await _sysParmValueManager.GetSysParmValueAsync(query.FirstOrDefault().patientRegister.MedicalCenterId, "lis_request_no_print_mode");
                if (string.IsNullOrWhiteSpace(lisRequestNoPrintMode))
                    lisRequestNoPrintMode = "0";

                //var entlist = lisRequestReportDtoList.GroupBy(g => new
                //{
                //    g.LisRequestNo,
                //    g.SampleGroupName
                //})
                //  .Select(s => new LisRequestReportDto
                //  {
                //      PatientNo = s.FirstOrDefault().PatientNo,
                //      LisRequestId = s.FirstOrDefault().LisRequestId,
                //      SexName = s.FirstOrDefault().SexName,
                //      SampleTypeName = s.FirstOrDefault().SampleTypeName,
                //      SampleContainerRemark = s.FirstOrDefault().SampleContainerRemark,
                //      SampleContainerName = s.FirstOrDefault().SampleContainerName,
                //      ContainerColor = s.FirstOrDefault().ContainerColor,
                //      PatientRegisterNo = s.FirstOrDefault().PatientRegisterNo,
                //      PatientName = s.FirstOrDefault().PatientName,
                //      Age = s.FirstOrDefault().Age,
                //      LisRequestNo = lisRequestNoPrintMode == "0" ? s.Key.LisRequestNo : s.FirstOrDefault().PatientRegisterNo,
                //      CustomerOrgName = s.FirstOrDefault().CustomerOrgName,
                //      DepartmentName = s.FirstOrDefault().DepartmentName,
                //      AsbitemNames = string.Join(",", s.Select(d => d.AsbitemNames)),
                //      IsPrint = s.FirstOrDefault().IsPrint,
                //      IsSignIn = s.FirstOrDefault().IsSignIn,
                //      SamplingTime = s.FirstOrDefault().SamplingTime,
                //      SignInOrder = s.FirstOrDefault().SignInOrder,
                //      SignInPerson = s.FirstOrDefault().SignInPerson,
                //      SignInTime = s.FirstOrDefault().SignInTime,
                //      SampleGroupName = s.Key.SampleGroupName,
                //      MobileTelephone = s.FirstOrDefault().MobileTelephone,
                //      SamplePrintCount = s.FirstOrDefault().SamplePrintCount
                //  }).ToList();

                entlist = lisRequestReportDtoList.GroupBy(g => new
                {
                    g.PatientNo,
                    g.LisRequestId,
                    g.LisRequestNo,
                    g.Age,
                    g.PatientName,
                    g.PatientRegisterNo,
                    g.SampleContainerName,
                    g.ContainerColor,
                    g.SampleContainerRemark,
                    g.SampleTypeName,
                    g.SexName,
                    g.CustomerOrgName,
                    g.DepartmentName,
                    g.IsPrint,
                    g.IsSignIn,
                    g.SamplingTime,
                    g.SignInOrder,
                    g.SignInPerson,
                    g.SignInTime,
                    g.MobileTelephone,
                    g.SampleGroupName
                })
                  .Select(s => new LisRequestReportDto
                  {
                      PatientNo = s.Key.PatientNo,
                      LisRequestId = s.Key.LisRequestId,
                      SexName = s.Key.SexName,
                      SampleTypeName = s.Key.SampleTypeName,
                      SampleContainerRemark = s.Key.SampleContainerRemark,
                      SampleContainerName = s.Key.SampleContainerName,
                      ContainerColor = s.Key.ContainerColor,
                      PatientRegisterNo = s.Key.PatientRegisterNo,
                      PatientName = s.Key.PatientName,
                      Age = s.Key.Age,
                      LisRequestNo = lisRequestNoPrintMode == "0" ? s.Key.LisRequestNo : s.Key.PatientRegisterNo,
                      CustomerOrgName = s.Key.CustomerOrgName,
                      DepartmentName = s.Key.DepartmentName,
                      AsbitemNames = string.Join(",", s.Select(d => d.AsbitemNames)),
                      IsPrint = s.Key.IsPrint,
                      IsSignIn = s.Key.IsSignIn,
                      SamplingTime = s.Key.SamplingTime,
                      SignInOrder = s.Key.SignInOrder,
                      SignInPerson = s.Key.SignInPerson,
                      SignInTime = s.Key.SignInTime,
                      SampleGroupName = s.Key.SampleGroupName,
                      MobileTelephone = s.Key.MobileTelephone,
                      SamplePrintCount = s.FirstOrDefault().SamplePrintCount,
                      DeviceLisRequestPrintTimes = s.FirstOrDefault().DeviceLisRequestPrintTimes
                  }).ToList();

                await uow.CompleteAsync();
           


            }

            return entlist;

        }


        /// <summary>
        /// 打印检验申请单  不需要转换版本
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetLisRequestReportByPatientRegisterIdConvertToReport")]
        public async Task<Rpt0002Dto> GetLisRequestReportByPatientRegisterIdConvertToReportAsync(PatientRegisterIdInputDto input)
        {
            var oldDto = await GetLisRequestReportByPatientRegisterIdAsync(input);
            var entDto = await ConvertToReport.ToLisRequestReportDataAsync(oldDto);
            return entDto;
        }

        /// <summary>
        /// 单个打印检验条码
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetLisRequestReportByLisRequestId")]
        public async Task<LisRequestReportDto> GetLisRequestReportByLisRequestIdAsync(LisRequestIdInputDto input)
        {
            var lisRequestNoPrintMode = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "lis_request_no_print_mode");
            if (string.IsNullOrWhiteSpace(lisRequestNoPrintMode))
                lisRequestNoPrintMode = "0";

            var list = (from patient in await _patientRepository.GetQueryableAsync()
                        join patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                        on patient.Id equals patientRegister.PatientId
                        join registerCheck in await _registerCheckRepository.GetQueryableAsync()
                        on patientRegister.Id equals registerCheck.PatientRegisterId
                        join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                        on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                        join asbitem in await _asbitemRepository.GetQueryableAsync()
                        on registerCheckAsbitem.AsbitemId equals asbitem.Id
                        join lisRequest in await _lisRequestReportRepository.GetQueryableAsync()
                        on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                        join sampleContainer in await _sampleContainerRepository.GetQueryableAsync()
                        on lisRequest.SampleContainerId equals sampleContainer.Id
                        join sampleType in await _sampleTypeRepository.GetQueryableAsync()
                        on lisRequest.SampleTypeId equals sampleType.Id
                        join sampleGroupDetail in await _sampleGroupDetailRepository.GetQueryableAsync() on asbitem.Id equals sampleGroupDetail.AsbitemId into sampleGroupDetailTemp
                        from sampleTypeHaveEmptyHaveEmpty in sampleGroupDetailTemp.DefaultIfEmpty()
                        join sampleGroup in await _sampleGroupRepository.GetQueryableAsync() on sampleTypeHaveEmptyHaveEmpty.SampleGroupId equals sampleGroup.Id into sampleGroupTemp
                        from sampleGroupHaveEmpty in sampleGroupTemp.DefaultIfEmpty()
                        where lisRequest.Id == input.LisRequestId
                        select new
                        {
                            patient,
                            patientRegister,
                            asbitem,
                            lisRequest,
                            sampleContainer,
                            sampleType,
                            sampleGroupName = sampleGroupHaveEmpty != null ? sampleGroupHaveEmpty.DisplayName : "",
                            samplePrintCount = sampleGroupHaveEmpty != null ? sampleGroupHaveEmpty.SamplePrintCount : 1

                        }).Distinct().ToList();
            if (!list.Any())
            {
                return null;
            }

            var lisRequestDtoList = new List<LisRequestReportDto>();
            var lisRequestInfo = list.First();
            var lisRequestDto = new LisRequestReportDto()
            {

                LisRequestId = input.LisRequestId,
                LisRequestNo = lisRequestNoPrintMode == "0" ? lisRequestInfo.lisRequest.LisRequestNo : lisRequestInfo.patientRegister.PatientRegisterNo,
                PatientNo = lisRequestInfo.patient.PatientNo,
                PatientRegisterNo = lisRequestInfo.patientRegister.PatientRegisterNo,
                PatientName = lisRequestInfo.patientRegister.PatientName,
                SexName = _cacheService.GetSexNameAsync(lisRequestInfo.patientRegister.SexId).Result,
                Age = lisRequestInfo.patientRegister.Age,
                IsPrint = lisRequestInfo.lisRequest.IsPrint,
                IsSignIn = lisRequestInfo.lisRequest.IsSignIn,
                SamplingTime = lisRequestInfo.lisRequest.SamplingTime,
                SignInOrder = lisRequestInfo.lisRequest.SignInOrder,
                SignInPerson = lisRequestInfo.lisRequest.SignInPerson,
                SignInTime = lisRequestInfo.lisRequest.SignInTime,
                SampleTypeName = lisRequestInfo.sampleType.DisplayName,
                SampleContainerName = lisRequestInfo.sampleContainer.DisplayName,
                ContainerColor = lisRequestInfo.sampleContainer.ContainerColor,
                SampleContainerRemark = lisRequestInfo.sampleContainer.ContainerRemark,
                AsbitemNames = string.Join(",", list.OrderBy(o => o.asbitem.DisplayOrder).Select(o => o.asbitem.DisplayName).Distinct()),
                CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(lisRequestInfo.patientRegister.CustomerOrgId).Result,
                DepartmentName = _cacheService.GetAllDepartmentNameAsync(lisRequestInfo.patientRegister.CustomerOrgId).Result,
                SampleGroupName = lisRequestInfo.sampleGroupName,
                MobileTelephone = lisRequestInfo.patient.MobileTelephone,
                SamplePrintCount = lisRequestInfo.samplePrintCount
            };

            return lisRequestDto;
        }

        /// <summary>
        /// 单个打印检验条码  不需要转换版本
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetLisRequestReportByLisRequestIdConvertToReport")]
        public async Task<Rpt0002Dto> GetLisRequestReportByLisRequestIdConvertToReportAsync(LisRequestIdInputDto input)
        {
            var oldDto = await GetLisRequestReportByLisRequestIdAsync(input);
            var entDto = await ConvertToReport.ToLisRequestReportDataAsync(new List<LisRequestReportDto> { oldDto });
            return entDto;
        }


        /// <summary>
        /// 打印体检报告
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetMedicalReport")]
        public async Task<MedicalReportDto> GetMedicalReportAsync(PatientRegisterIdInputDto input)
        {

            var patientRegister = (await _patientRegisterRepository.GetQueryableAsync())
               .Include(x => x.Patient)
               .Where(m => m.Id == input.PatientRegisterId).FirstOrDefault();
            if (patientRegister == null)
            {
                throw new UserFriendlyException("人员登记信息不存在");
            }
            var medicalReportDto = await GetMedicalReportDto(patientRegister);

            //获取综述
            medicalReportDto.SumSummarys = await GetMedicalReportSummaryDtos(patientRegister);
            //获取建议
            medicalReportDto.SumSuggestions = await GetMedicalReportSuggestinoDtos(patientRegister);
            //设置明细结果
            await SetMedicalReportRegisterChecks(patientRegister, medicalReportDto);
            //项目对比结果
            medicalReportDto.ItemContrasts = await GetMedicalReportItemContrastListAsync(patientRegister);

            return medicalReportDto;
        }


        /// <summary>
        /// 打印体检报告  不需要转换版本
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetMedicalReportConvertToReport")]
        public async Task<Rpt0005Dto> GetMedicalReportConvertToReportAsync(PatientRegisterIdInputDto input)
        {
            var oldDto = await GetMedicalReportAsync(input);
            var entDto = await ConvertToReport.ToHealthReportDataAsync(oldDto);
            return entDto;
        }

        /// <summary>
        /// 获取职业病体检报告
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetOccupationalDiseaseMedicalReport")]
        public async Task<OccupationalDiseaseMedicalReportDto> GetOccupationalDiseaseMedicalReportAsync(PatientRegisterIdInputDto input)
        {
            var result = new OccupationalDiseaseMedicalReportDto();

            var patientOccupationalDiseaseEnt = (from patientOccupationalDisease in await _patientOccupationalDiseaseRepository.GetQueryableAsync()
                                                 join ocCheckType in await _ocCheckTypeRepository.GetQueryableAsync() on patientOccupationalDisease.OcCheckTypeId equals ocCheckType.Id
                                                 where patientOccupationalDisease.PatientRegisterId == input.PatientRegisterId
                                                 select new
                                                 {
                                                     ocCheckTypeName = ocCheckType.DisplayName,
                                                     patientOccupationalDisease
                                                 }).FirstOrDefault();

            if (patientOccupationalDiseaseEnt == null)
            {
                throw new UserFriendlyException("当前人员无职业病信息");
            }
            //基础报告信息
            var medicalReportDto = await GetMedicalReportAsync(input);
            result = ObjectMapper.Map<MedicalReportDto, OccupationalDiseaseMedicalReportDto>(medicalReportDto);

            #region 检查类别

            var ocCheckTypeList = (await _ocCheckTypeRepository.GetQueryableAsync()).OrderBy(o => o.DisplayOrder);
            if (ocCheckTypeList.Any())
            {
                result.OcCheckTypeDtos = ocCheckTypeList.Select(s => new OccupationalDiseaseMedicalReport_OcCheckTypeDto
                {
                    DisplayName = s.DisplayName,
                    DisplayOrder = s.DisplayOrder,
                    OcCheckTypeId = s.Id,
                    SimpleCode = s.SimpleCode
                }).ToList();
            }
            #endregion

            #region 职业病基本信息

            result.PatientOccupationalDisease = new OccupationalDiseaseMedicalReport_PatientOccupationalDiseaseDto
            {
                OcCheckTypeName = patientOccupationalDiseaseEnt.ocCheckTypeName,
                AbnormalTimes = patientOccupationalDiseaseEnt.patientOccupationalDisease.AbnormalTimes,
                AbortionTimes = patientOccupationalDiseaseEnt.patientOccupationalDisease.AbortionTimes,
                ChildrenNum = patientOccupationalDiseaseEnt.patientOccupationalDisease.ChildrenNum,
                DrinkFlag = patientOccupationalDiseaseEnt.patientOccupationalDisease.DrinkFlag,
                DrinkNum = patientOccupationalDiseaseEnt.patientOccupationalDisease.DrinkNum,
                DrinkNumMax = patientOccupationalDiseaseEnt.patientOccupationalDisease.DrinkNum != null ? patientOccupationalDiseaseEnt.patientOccupationalDisease.DrinkNum.Value + 50 : null,
                DrinkYears = patientOccupationalDiseaseEnt.patientOccupationalDisease.DrinkYears,
                FirstMenstruation = patientOccupationalDiseaseEnt.patientOccupationalDisease.FirstMenstruation,
                HandleSuggestion = patientOccupationalDiseaseEnt.patientOccupationalDisease.HandleSuggestion,
                JobType = patientOccupationalDiseaseEnt.patientOccupationalDisease.JobType,
                LastMenstrualPeriodDate = DataHelper.ConversionDateShortToString(patientOccupationalDiseaseEnt.patientOccupationalDisease.LastMenstrualPeriodDate),
                MenstruationCycle = patientOccupationalDiseaseEnt.patientOccupationalDisease.MenstruationCycle,
                MenstruationEndAge = patientOccupationalDiseaseEnt.patientOccupationalDisease.MenstruationEndAge,
                MenstruationFlag = patientOccupationalDiseaseEnt.patientOccupationalDisease.MenstruationFlag,
                MenstruationTimeLength = patientOccupationalDiseaseEnt.patientOccupationalDisease.MenstruationTimeLength,
                NoOccupAbSuggestion = patientOccupationalDiseaseEnt.patientOccupationalDisease.NoOccupAbSuggestion,
                NoOccupationalAbnormal = patientOccupationalDiseaseEnt.patientOccupationalDisease.NoOccupationalAbnormal,
                OcCheckTypeId = patientOccupationalDiseaseEnt.patientOccupationalDisease.OcCheckTypeId,
                OccupationalAbnormal = patientOccupationalDiseaseEnt.patientOccupationalDisease.OccupationalAbnormal,
                OccupationalAbSuggestion = patientOccupationalDiseaseEnt.patientOccupationalDisease.OccupationalAbSuggestion,
                Other = patientOccupationalDiseaseEnt.patientOccupationalDisease.Other,
                PoisonWorkTime = patientOccupationalDiseaseEnt.patientOccupationalDisease.PoisonWorkTime,
                PrematureBirthTimes = patientOccupationalDiseaseEnt.patientOccupationalDisease.PrematureBirthTimes,
                FamilyGeneticHistory = patientOccupationalDiseaseEnt.patientOccupationalDisease.FamilyGeneticHistory,
                RiskFactors = patientOccupationalDiseaseEnt.patientOccupationalDisease.RiskFactors,
                SmokeFlag = patientOccupationalDiseaseEnt.patientOccupationalDisease.SmokeFlag,
                SmokeNum = patientOccupationalDiseaseEnt.patientOccupationalDisease.SmokeNum,
                SmokeNumMax = patientOccupationalDiseaseEnt.patientOccupationalDisease.SmokeNum != null ? patientOccupationalDiseaseEnt.patientOccupationalDisease.SmokeNum + 5 : null,
                SmokeYears = patientOccupationalDiseaseEnt.patientOccupationalDisease.SmokeYears,
                StillbirthTimes = patientOccupationalDiseaseEnt.patientOccupationalDisease.StillbirthTimes,
                TotalWorkTime = patientOccupationalDiseaseEnt.patientOccupationalDisease.TotalWorkTime,
                OccupationalDiseaseNumber = patientOccupationalDiseaseEnt.patientOccupationalDisease.OccupationalDiseaseNumber
            };
            #endregion

            #region 职业史

            var patientOccupationalHistoryList = (await _patientOccupationalHistoryRepository.GetQueryableAsync()).Where(m => m.PatientRegisterId == input.PatientRegisterId)
                .OrderBy(o => o.CreationTime).ToList();
            result.PatientOccupationalHistoryDtos = patientOccupationalHistoryList.Select(s => new OccupationalDiseaseMedicalReport_PatientOccupationalHistoryDto
            {
                BeginDate = DataHelper.ConversionDateShortToString(s.BeginDate),
                EndDate = DataHelper.ConversionDateShortToString(s.EndDate),
                Org = s.Org,
                Poison = s.Poison,
                ProtectiveMeasures = s.ProtectiveMeasures,
                WorkShop = s.WorkShop,
                WorkType = s.WorkType,
                DisplayOrder = patientOccupationalHistoryList.IndexOf(s) + 1
            }).ToList();
            #endregion


            #region 毒害因素
            var patientPoisonDtoList = (from patientPoison in await _patientPoisonRepository.GetQueryableAsync()
                                        join poison in await _poisonRepository.GetQueryableAsync() on patientPoison.PoisonId equals poison.Id into poisonTemp
                                        from poisonHaveEmpty in poisonTemp.DefaultIfEmpty()
                                        join occupationalAbnormal in await _occupationalAbnormalRepository.GetQueryableAsync() on patientPoison.OccupationalAbnormalId equals occupationalAbnormal.Id into occupationalAbnormalTemp
                                        from occupationalAbnormalHaveEmpty in occupationalAbnormalTemp.DefaultIfEmpty()
                                        where patientPoison.PatientRegisterId == input.PatientRegisterId
                                        orderby patientPoison.CreationTime ascending
                                        select new
                                        {
                                            OccupationalAbnormalName = occupationalAbnormalHaveEmpty != null ? occupationalAbnormalHaveEmpty.DisplayName : "",
                                            PoisonName = poisonHaveEmpty != null ? poisonHaveEmpty.DisplayName : ""
                                        }).ToList();
            result.PatientPoisonDtos = patientPoisonDtoList.Select(s => new OccupationalDiseaseMedicalReport_PatientPoisonDto
            {
                OccupationalAbnormalName = s.OccupationalAbnormalName,
                PoisonName = s.PoisonName,
                DisplayOrder = patientPoisonDtoList.IndexOf(s) + 1
            }).ToList();

            #endregion

            #region 职业病症状
            var patientSymptomList = (from patientSymptom in await _patientSymptomRepository.GetQueryableAsync()
                                      join symptom in await _symptomRepository.GetQueryableAsync() on patientSymptom.SymptomId equals symptom.Id into symptomTemp
                                      from symptomHaveEmpty in symptomTemp.DefaultIfEmpty()
                                      where patientSymptom.PatientRegisterId == input.PatientRegisterId
                                      orderby patientSymptom.CreationTime ascending
                                      select new
                                      {
                                          patientSymptom,
                                          SymptomName = symptomHaveEmpty != null ? symptomHaveEmpty.DisplayName : ""
                                      }).ToList();

            result.PatientSymptomDtos = patientSymptomList.Select(s => new OccupationalDiseaseMedicalReport_PatientSymptomDto
            {
                Degree = s.patientSymptom.Degree,
                SymptomName = s.SymptomName,
                TimeLength = s.patientSymptom.TimeLength,
                DisplayOrder = patientSymptomList.IndexOf(s) + 1
            }).ToList();
            #endregion

            #region 职业病史

            var patientOccupationalMedicalHistoryList = (await _patientOccupationalMedicalHistoryRepository.GetQueryableAsync())
                .Where(m => m.PatientRegisterId == input.PatientRegisterId).OrderBy(o => o.CreationTime).ToList();
            result.PatientOccupationalMedicalHistoryDtos = patientOccupationalMedicalHistoryList.Select(s => new OccupationalDiseaseMedicalReport_PatientOccupationalMedicalHistoryDto
            {
                DiagnosisDate = DataHelper.ConversionDateShortToString(s.DiagnosisDate),
                DiagnosisHospital = s.DiagnosisHospital,
                IsRecovery = s.IsRecovery == 'Y' ? "治愈" : "未愈",
                OccupationalDisease = s.OccupationalDisease,
                TreatmentMethods = s.TreatmentMethods,
                DisplayOrder = patientOccupationalMedicalHistoryList.IndexOf(s) + 1
            }).ToList();


            #endregion

            #region 既往病史

            var patientPastMedicalHistoryList = (await _patientPastMedicalHistoryRepository.GetQueryableAsync())
                .Where(m => m.PatientRegisterId == input.PatientRegisterId).OrderBy(o => o.CreationTime).ToList();
            result.PatientPastMedicalHistoryDtos = patientPastMedicalHistoryList.Select(s => new OccupationalDiseaseMedicalReport_PatientOccupationalMedicalHistoryDto
            {
                DiagnosisDate = DataHelper.ConversionDateShortToString(s.DiagnosisDate),
                DiagnosisHospital = s.DiagnosisHospital,
                IsRecovery = s.IsRecovery == 'Y' ? "治愈" : "未愈",
                OccupationalDisease = s.OccupationalDisease,
                TreatmentMethods = s.TreatmentMethods,
                DisplayOrder = patientPastMedicalHistoryList.IndexOf(s) + 1
            }).ToList();

            #endregion

            return result;



        }

        /// <summary>
        /// 获取职业病体检报告  不需要转换版本
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetOccupationalDiseaseMedicalReportConvertToReport")]
        public async Task<Rpt0006Dto> GetOccupationalDiseaseMedicalReportConvertToReportAsync(PatientRegisterIdInputDto input)
        {
            var oldDto = await GetOccupationalDiseaseMedicalReportAsync(input);
            var entDto = await ConvertToReport.ToOccupationalDiseaseReportDataAsync(oldDto);
            return entDto;
        }


        /// <summary>
        /// 打印Pacs条码数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/getpacsnoreport")]
        public async Task<List<PacsNoReportDto>> GetPacsNoReportAsync(PatientRegisterIdInputDto input)
        {

            var query = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                         join patient in await _patientRepository.GetQueryableAsync() on patientRegister.PatientId equals patient.Id
                         join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                         join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                         join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id into asbitemTemp
                         from asbitemHaveEmpty in asbitemTemp.DefaultIfEmpty()
                         join itemType in await _itemTypeRepository.GetQueryableAsync() on asbitemHaveEmpty.ItemTypeId equals itemType.Id into itemTypeTemp
                         from itemTypeHaveEmpty in itemTypeTemp.DefaultIfEmpty()
                         where (patientRegister.Id == input.PatientRegisterId
                         && !string.IsNullOrEmpty(registerCheck.CheckRequestNo)
                         && asbitemHaveEmpty.BarcodeMode != BarcodeModeFlag.NoPrint
                         )
                         select new
                         {
                             Age = patientRegister.Age,
                             AsbitemName = asbitemHaveEmpty.DisplayName,
                             CheckRequestNo = registerCheck.CheckRequestNo,
                             RegisterCheckId = registerCheck.Id,
                             PatientName = patientRegister.PatientName,
                             PatientRegisterNo = patientRegister.PatientRegisterNo,
                             SexName = _cacheService.GetSexNameAsync(patientRegister.SexId).Result,
                             IsCheckRequest = itemTypeHaveEmpty != null ? itemTypeHaveEmpty.IsCheckRequest : 'N',
                             BarcodeMode = asbitemHaveEmpty != null ? asbitemHaveEmpty.BarcodeMode : '0',
                             CustomerOrgId = patientRegister.CustomerOrgId,
                             MobileTelephone = patient.MobileTelephone,
                             DeviceCheckRequestPrintTimes = registerCheck.DeviceCheckRequestPrintTimes
                         }).ToList();



            var queryGroup = query.GroupBy(g => g.CheckRequestNo);

            List<PacsNoReportDto> pacsNoReportDtos = new List<PacsNoReportDto>();

            foreach (var s in queryGroup)
            {
                if (s.Where(m => m.BarcodeMode == '0' && m.IsCheckRequest == 'Y').Count() > 0)
                {
                    pacsNoReportDtos.Add(new PacsNoReportDto
                    {
                        Age = s.FirstOrDefault().Age,
                        AsbitemName = string.Join(',', s.Select(s => s.AsbitemName)),
                        CheckRequestNo = s.FirstOrDefault().CheckRequestNo,
                        RegisterCheckId = s.FirstOrDefault().RegisterCheckId,
                        PatientName = s.FirstOrDefault().PatientName,
                        PatientRegisterNo = s.FirstOrDefault().PatientRegisterNo,
                        SexName = s.FirstOrDefault().SexName,
                        CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(s.FirstOrDefault().CustomerOrgId).Result,
                        DepartmentName = _cacheService.GetAllDepartmentNameAsync(s.FirstOrDefault().CustomerOrgId).Result,
                        MobileTelephone = s.FirstOrDefault().MobileTelephone,
                        DeviceCheckRequestPrintTimes = s.FirstOrDefault().DeviceCheckRequestPrintTimes
                    });
                }
                else if (s.Where(m => m.BarcodeMode == '1').Count() > 0)
                {
                    pacsNoReportDtos.Add(new PacsNoReportDto
                    {
                        Age = s.FirstOrDefault().Age,
                        AsbitemName = string.Join(',', s.Select(s => s.AsbitemName)),
                        CheckRequestNo = s.FirstOrDefault().PatientRegisterNo,
                        RegisterCheckId = s.FirstOrDefault().RegisterCheckId,
                        PatientName = s.FirstOrDefault().PatientName,
                        PatientRegisterNo = s.FirstOrDefault().PatientRegisterNo,
                        SexName = s.FirstOrDefault().SexName,
                        CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(s.FirstOrDefault().CustomerOrgId).Result,
                        DepartmentName = _cacheService.GetAllDepartmentNameAsync(s.FirstOrDefault().CustomerOrgId).Result,
                        MobileTelephone = s.FirstOrDefault().MobileTelephone,
                        DeviceCheckRequestPrintTimes = s.FirstOrDefault().DeviceCheckRequestPrintTimes
                    });
                }
            }



            return pacsNoReportDtos;

        }

        /// <summary>
        /// 打印Pacs条码数据  不需要转换版本
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetPacsNoReportConvertToReport")]
        public async Task<Rpt0004Dto> GetPacsNoReportConvertToReportAsync(PatientRegisterIdInputDto input)
        {

            var oldDto = await GetPacsNoReportAsync(input);
            var entDto = await ConvertToReport.ToExamRequestReportDataAsync(oldDto);
            return entDto;
        }


        /// <summary>
        ///  打印Pacs条码数据 单个条码打印
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetPacsNoReportByCheckRequestNo")]
        public async Task<PacsNoReportDto> GetPacsNoReportByCheckRequestNoAsync(RegisterCheckIdInputDto input)
        {

            PacsNoReportDto pacsNoReportDto = new PacsNoReportDto();

            if (input.RegisterCheckId != Guid.Empty)
            {
                var query = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                             join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                             join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                             join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id into asbitemTemp
                             from asbitemHaveEmpty in asbitemTemp.DefaultIfEmpty()
                             join itemType in await _itemTypeRepository.GetQueryableAsync() on asbitemHaveEmpty.ItemTypeId equals itemType.Id into itemTypeTemp
                             from itemTypeHaveEmpty in itemTypeTemp.DefaultIfEmpty()
                             where registerCheck.Id == input.RegisterCheckId
                             && !string.IsNullOrEmpty(registerCheck.CheckRequestNo)
                             && asbitemHaveEmpty.BarcodeMode != '2'
                             select new
                             {
                                 Age = patientRegister.Age,
                                 AsbitemName = asbitemHaveEmpty.DisplayName,
                                 CheckRequestNo = registerCheck.CheckRequestNo,
                                 PatientName = patientRegister.PatientName,
                                 PatientRegisterNo = patientRegister.PatientRegisterNo,
                                 SexName = _cacheService.GetSexNameAsync(patientRegister.SexId).Result,
                                 IsCheckRequest = itemTypeHaveEmpty != null ? itemTypeHaveEmpty.IsCheckRequest : 'N',
                                 BarcodeMode = asbitemHaveEmpty != null ? asbitemHaveEmpty.BarcodeMode : '0',
                                 CustomerOrgId = patientRegister.CustomerOrgId,
                             }).ToList();


                if (query.Count > 0)
                {
                    var queryGroup = query.GroupBy(g => g.CheckRequestNo).FirstOrDefault();


                    if (queryGroup.Where(m => m.BarcodeMode == '0' && m.IsCheckRequest == 'Y').Count() > 0)
                    {
                        pacsNoReportDto = new PacsNoReportDto
                        {
                            Age = queryGroup.FirstOrDefault().Age,
                            AsbitemName = string.Join(',', queryGroup.Select(s => s.AsbitemName)),
                            CheckRequestNo = queryGroup.FirstOrDefault().CheckRequestNo,
                            PatientName = queryGroup.FirstOrDefault().PatientName,
                            PatientRegisterNo = queryGroup.FirstOrDefault().PatientRegisterNo,
                            SexName = queryGroup.FirstOrDefault().SexName,
                            CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(queryGroup.FirstOrDefault().CustomerOrgId).Result,
                            DepartmentName = _cacheService.GetAllDepartmentNameAsync(queryGroup.FirstOrDefault().CustomerOrgId).Result
                        };
                    }
                    else if (queryGroup.Where(m => m.BarcodeMode == '1').Count() > 0)
                    {
                        pacsNoReportDto = new PacsNoReportDto
                        {
                            Age = queryGroup.FirstOrDefault().Age,
                            AsbitemName = string.Join(',', queryGroup.Select(s => s.AsbitemName)),
                            CheckRequestNo = queryGroup.FirstOrDefault().PatientRegisterNo,
                            PatientName = queryGroup.FirstOrDefault().PatientName,
                            PatientRegisterNo = queryGroup.FirstOrDefault().PatientRegisterNo,
                            SexName = queryGroup.FirstOrDefault().SexName,
                            CustomerOrgName = _cacheService.GetTopCustomerOrgShortNameAsync(queryGroup.FirstOrDefault().CustomerOrgId).Result,
                            DepartmentName = _cacheService.GetAllDepartmentNameAsync(queryGroup.FirstOrDefault().CustomerOrgId).Result
                        };
                    }

                }

            }

            return pacsNoReportDto;

        }


        /// <summary>
        ///  打印Pacs条码数据 单个条码打印
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetPacsNoReportByCheckRequestNoConvertToReport")]
        public async Task<Rpt0004Dto> GetPacsNoReportByCheckRequestNoConvertToReportAsync(RegisterCheckIdInputDto input)
        {
            var oldDto = await GetPacsNoReportByCheckRequestNoAsync(input);
            var entDto = await ConvertToReport.ToExamRequestReportDataAsync(new List<PacsNoReportDto> { oldDto });
            return entDto;
        }


        ///// <summary>
        ///// 打印Pacs条码数据
        ///// </summary>
        ///// <param name="PatientRegisterId"></param>
        ///// <returns></returns>
        //[HttpPost("api/app/PrintReport/getpacsnoreport")]
        //public async Task<List<PacsNoReportDto>> GetPacsNoReportAsync(Guid PatientRegisterId)
        //{

        //    var query = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
        //                 join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
        //                 join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
        //                 join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id into asbitemTemp
        //                 from asbitemHaveEmpty in asbitemTemp.DefaultIfEmpty()
        //                 join itemType in await _itemTypeRepository.GetQueryableAsync() on asbitemHaveEmpty.ItemTypeId equals itemType.Id into itemTypeTemp
        //                 from itemTypeHaveEmpty in itemTypeTemp.DefaultIfEmpty()
        //                 where (patientRegister.Id == PatientRegisterId && itemTypeHaveEmpty.IsCheckRequest == 'Y')
        //                 select new PacsNoReportDto
        //                 {
        //                     Age = patientRegister.Age,
        //                     AsbitemName = asbitemHaveEmpty.DisplayName,
        //                     CheckRequestNo = registerCheck.CheckRequestNo,
        //                     PatientName = patientRegister.PatientName,
        //                     PatientRegisterNo = patientRegister.PatientRegisterNo,
        //                     SexName = _cacheService.GetSexNameAsync(patientRegister.SexId).Result,
        //                     CustomerOrgName = _cacheService.GetTopCustomerOrgNameAsync(patientRegister.CustomerOrgId).Result,
        //                     DepartmentName = _cacheService.GetCustomerOrgNameAsync(patientRegister.CustomerOrgId).Result
        //                 }).ToList();



        //    var entList = query.GroupBy(g => g.CheckRequestNo).Select(s => new PacsNoReportDto
        //    {
        //        Age = s.FirstOrDefault().Age,
        //        AsbitemName = string.Join(',', s.Select(s => s.AsbitemName)),
        //        CheckRequestNo = s.FirstOrDefault().CheckRequestNo,
        //        PatientName = s.FirstOrDefault().PatientName,
        //        PatientRegisterNo = s.FirstOrDefault().PatientRegisterNo,
        //        SexName = s.FirstOrDefault().SexName,
        //        CustomerOrgName = s.FirstOrDefault().CustomerOrgName,
        //        DepartmentName = s.FirstOrDefault().DepartmentName
        //    }).ToList();

        //    return entList;

        //}

        /// <summary>
        /// 打印收费单
        /// </summary>
        /// <param name="ChargeId">收费主表ID</param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/getchargereport")]
        public async Task<ChargeReportDto> GetChargeReportAsync(Guid ChargeId)
        {
            return await _chargeReportRepository.GetChargeReportAsync(ChargeId);
        }


        /// <summary>
        /// 打印收费单  不需要转换版本
        /// </summary>
        /// <param name="ChargeId">收费主表ID</param>
        /// <returns></returns>
        [HttpPost("api/app/PrintReport/GetChargeReportConvertToReport")]
        public async Task<Rpt0007Dto> GetChargeReportConvertToReportAsync(Guid ChargeId)
        {
            var oldDto = await GetChargeReportAsync(ChargeId);
            var entDto = await ConvertToReport.ToPayBillReportDataAsync(oldDto);
            return entDto;
        }


        /// <summary>
        /// 获取体检报告人员信息
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <returns></returns>
        private async Task<MedicalReportDto> GetMedicalReportDto(PatientRegister patientRegister)
        {
            #region 系统参数配置
            var medicalCenterAddress = await _sysParmValueManager.GetSysParmValueAsync(patientRegister.MedicalCenterId, "medical_center_address");
            var medicalCenterFax = await _sysParmValueManager.GetSysParmValueAsync(patientRegister.MedicalCenterId, "medical_center_fax");
            var medicalCenterTelphone = await _sysParmValueManager.GetSysParmValueAsync(patientRegister.MedicalCenterId, "medical_center_telphone");
            #endregion
            #region 人员信息
            var medicalReportDto = new MedicalReportDto
            {
                //个人信息
                PatientRegisterId = patientRegister.Id,
                IsPersonal = 'N',
                CustomerOrgName = _cacheService.GetTopCustomerOrgAsync(patientRegister.CustomerOrgId).Result.DisplayName,
                DepartmentName = _cacheService.GetCustomerOrgAsync(patientRegister.CustomerOrgId).Result.DisplayName,
                PatientRegisterNo = patientRegister.PatientRegisterNo,
                PatientNo = patientRegister.Patient.PatientNo,
                PatientName = patientRegister.PatientName,
                IdNo = patientRegister.Patient.IdNo,
                MedicalTimes = patientRegister.MedicalTimes,
                SexName = _cacheService.GetSexNameAsync(patientRegister.SexId).GetAwaiter().GetResult(),
                BirthDate = patientRegister.BirthDate,
                Age = patientRegister.Age,
                MaritalStatusName = _cacheService.GetMaritalStatusNameAsync(patientRegister.MaritalStatusId).GetAwaiter().GetResult(),
                NationName = _cacheService.GetNationNameAsync(patientRegister.Patient.NationId).GetAwaiter().GetResult(),
                MobileTelephone = patientRegister.Patient.MobileTelephone,
                IsVip = patientRegister.IsVip,
                MedicalTypeName = _cacheService.GetMedicalTypeNameAsync(patientRegister.MedicalTypeId).GetAwaiter().GetResult(),
                PersonnelTypeName = _cacheService.GetPersonnelTypeNameAsync(patientRegister.PersonnelTypeId).GetAwaiter().GetResult(),
                MedicalStartDate = patientRegister.MedicalStartDate,
                SummaryDoctorName = _cacheService.GetSurnameAsync(patientRegister.SummaryDoctorId).GetAwaiter().GetResult(),
                SummaryDoctorSignUrl = _cacheService.GetUserSignAsync(patientRegister.SummaryDoctorId).GetAwaiter().GetResult(),
                SummaryDate = patientRegister.SummaryDate,
                AuditDoctorName = _cacheService.GetSurnameAsync(patientRegister.AuditDoctorId).GetAwaiter().GetResult(),
                AuditDoctorSignUrl = _cacheService.GetUserSignAsync(patientRegister.AuditDoctorId).GetAwaiter().GetResult(),
                AuditDate = patientRegister.AuditDate,
                //体检中心信息
                MedicalCenterTelphone = medicalCenterTelphone,
                MedicalCenterAddress = medicalCenterAddress,
                MedicalCenterId = patientRegister.MedicalCenterId,
                MedicalCenterName = (await _organizationUnitRepository.GetAsync(patientRegister.MedicalCenterId)).DisplayName,
            };
            if (patientRegister.CustomerOrgId == GuidFlag.PersonCustomerOrgId)
            {
                medicalReportDto.IsPersonal = 'Y';
            }

            if (patientRegister.MedicalPackageId != null)
            {
                var medicalPackageEnt = await _medicalPackageRepository.FirstOrDefaultAsync(f => f.Id == patientRegister.MedicalPackageId);
                if (medicalPackageEnt != null)
                {
                    medicalReportDto.MedicalPackageOrCustomerOrgGroupName = medicalPackageEnt.DisplayName;
                }
            }
            else
            {
                var customerOrgGroupEnt = await _customerOrgGroupRepository.FirstOrDefaultAsync(f => f.Id == patientRegister.CustomerOrgGroupId);
                if (customerOrgGroupEnt != null)
                {
                    medicalReportDto.MedicalPackageOrCustomerOrgGroupName = customerOrgGroupEnt.DisplayName;
                }
            }

            #endregion
            return medicalReportDto;
        }
        /// <summary>
        /// 获取体检报告综述
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <returns></returns>
        private async Task<List<MedicalReportSumSummaryDto>> GetMedicalReportSummaryDtos(PatientRegister patientRegister)
        {
            var sumSummarylist = (await _sumSummaryHeaderRepository.GetQueryableAsync())
          .Include(x => x.SumSummaryContents)
          .Where(m => m.PatientRegisterId == patientRegister.Id).OrderBy(o => o.DisplayOrder).ToList();
            var medicalReportSumSummaryDtos = new List<MedicalReportSumSummaryDto>();
            if (sumSummarylist.Any())
            {
                medicalReportSumSummaryDtos = sumSummarylist.Select(s => new MedicalReportSumSummaryDto
                {
                    SummaryTitle = s.SummaryTitle,
                    SummaryFlag = s.SummaryFlag,
                    DisplayOrder = s.DisplayOrder,
                    SummaryContents = s.SumSummaryContents.OrderBy(o => o.DisplayOrder).Select(sa => new MedicalReportSumSummaryContentDto
                    {
                        SummaryContent = sa.SummaryContent,
                        DisplayOrder = sa.DisplayOrder,
                    }).OrderBy(o => o.DisplayOrder).ToList()
                }).OrderBy(o => o.DisplayOrder).ToList();
            }
            return medicalReportSumSummaryDtos;
        }
        /// <summary>
        /// 获取体检报告建议
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <returns></returns>
        private async Task<List<MedicalReportSumSuggestionDto>> GetMedicalReportSuggestinoDtos(PatientRegister patientRegister)
        {
            var sumSuggestionlist = (await _sumSuggestionHeaderRepository.GetQueryableAsync())
          .Include(x => x.SumSuggestionContents)
          .Where(m => m.PatientRegisterId == patientRegister.Id).OrderBy(o => o.DisplayOrder).ToList();
            var medicalReportSumSuggestionDtos = new List<MedicalReportSumSuggestionDto>();
            if (sumSuggestionlist.Any())
            {
                medicalReportSumSuggestionDtos = sumSuggestionlist.Select(s => new MedicalReportSumSuggestionDto
                {
                    SuggestionTitle = s.SuggestionTitle,
                    SuggestionFlag = s.SuggestionFlag,
                    DisplayOrder = s.DisplayOrder,
                    MedicalInterpretations = s.SumSuggestionContents.
                    Where(o => o.SuggestionType == SuggestionTypeFlag.MedicalInterpretation && !string.IsNullOrWhiteSpace(o.SuggestionContent))
                    .OrderBy(o => o.DisplayOrder)
                    .Select(sa => new MedicalReportSumSuggestionContentDto
                    {
                        SuggestionContent = sa.SuggestionContent,
                        DisplayOrder = sa.DisplayOrder,
                    }).OrderBy(o => o.DisplayOrder).ToList(),
                    CommonReasons = s.SumSuggestionContents.
                    Where(o => o.SuggestionType == SuggestionTypeFlag.CommonReasons && !string.IsNullOrWhiteSpace(o.SuggestionContent))
                    .OrderBy(o => o.DisplayOrder)
                    .Select(sa => new MedicalReportSumSuggestionContentDto
                    {
                        SuggestionContent = sa.SuggestionContent,
                        DisplayOrder = sa.DisplayOrder,
                    }).OrderBy(o => o.DisplayOrder).ToList(),
                    HealthGuidances = s.SumSuggestionContents.
                    Where(o => o.SuggestionType == SuggestionTypeFlag.HealthGuidance && !string.IsNullOrWhiteSpace(o.SuggestionContent))
                    .OrderBy(o => o.DisplayOrder)
                    .Select(sa => new MedicalReportSumSuggestionContentDto
                    {
                        SuggestionContent = sa.SuggestionContent,
                        DisplayOrder = sa.DisplayOrder,
                    }).OrderBy(o => o.DisplayOrder).ToList()
                })
                .OrderBy(o => o.DisplayOrder).ToList();
            }
            return medicalReportSumSuggestionDtos;
        }
        /// <summary>
        ///  获取体检报告明细结果
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <param name="medicalReportDto"></param>
        /// <returns></returns>
        private async Task SetMedicalReportRegisterChecks(PatientRegister patientRegister, MedicalReportDto medicalReportDto)
        {
            var resultStatusList = (await _resultStatusRepository.GetListAsync());
            //获取体检报告类别
            medicalReportDto.MedicalReportTypes = await GetMedicalReportTypeList();
            //获取项目类别
            medicalReportDto.ItemTypes = await GetItemTypeList();

            var registerChecklist = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
                                     join registerAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync()
                                     on registerCheck.Id equals registerAsbitem.RegisterCheckId
                                     join registerCheckItem in await _registerCheckItemRepository.GetQueryableAsync()
                                     on registerCheck.Id equals registerCheckItem.RegisterCheckId
                                     join registerCheckPicture in await _registerCheckPictureRepository.GetQueryableAsync()
                                     on registerCheck.Id equals registerCheckPicture.RegisterCheckId into registerCheckPictureExist
                                     from registerCheckPictureHaveEmpty in registerCheckPictureExist.DefaultIfEmpty()
                                     join registerCheckSummary in await _registerCheckSummaryRepository.GetQueryableAsync()
                                     on registerCheck.Id equals registerCheckSummary.RegisterCheckId into registerCheckSummaryExist
                                     from registerCheckSummaryHaveEmpty in registerCheckSummaryExist.DefaultIfEmpty()
                                     join asbitem in await _asbitemRepository.GetQueryableAsync()
                                      on registerAsbitem.AsbitemId equals asbitem.Id
                                     join item in await _itemRepository.GetQueryableAsync()
                                     on registerCheckItem.ItemId equals item.Id
                                     join itemType in await _itemTypeRepository.GetQueryableAsync()
                                     on asbitem.ItemTypeId equals itemType.Id
                                     join medicalReportType in await _medicalReportTypeRepository.GetQueryableAsync()
                                     on itemType.MedicalReportTypeId equals medicalReportType.Id
                                     where (registerCheck.PatientRegisterId == patientRegister.Id
                                           && registerCheck.CompleteFlag == RegisterCheckCompleteFlag.Checked)
                                     select new
                                     {
                                         registerCheck,
                                         registerAsbitem,
                                         registerCheckItem,
                                         registerCheckPictureHaveEmpty,
                                         registerCheckSummaryHaveEmpty,
                                         asbitem,
                                         item,
                                         itemType,
                                         medicalReportType
                                     })
                                      .OrderBy(o => o.registerCheck.Id)
                                      .ToList();

            var registerCheckIds = registerChecklist.Select(o => o.registerCheck.Id).Distinct().ToList();

            #region 获取采样时间

            var samplerList = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
                               join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                               join lisRequest in await _lisRequestRepository.GetQueryableAsync() on registerCheckAsbitem.LisRequestId equals lisRequest.Id
                               where registerCheckIds.Contains(registerCheck.Id)
                               select new
                               {
                                   registerCheckId = registerCheck.Id,
                                   samplerId = lisRequest.SamplerId,
                                   samplingTime = lisRequest.SamplingTime
                               }).ToList();

            #endregion

            foreach (var registerCheckId in registerCheckIds)
            {
                var registerCheckRows = registerChecklist.Where(o => o.registerCheck.Id == registerCheckId).ToList();

                //隐藏隐私项目
                if (registerCheckRows.Where(m => m.asbitem.IsPrivacy == 'Y').Count() > 0)
                {
                    continue;
                }

                var registerCheckRow = registerCheckRows.First();
                var medicalReportRegisterCheckDto = new MedicalReportRegisterCheckDto()
                {
                    ItemTypeId = registerCheckRow.itemType.Id,
                    AsbitemNames = string.Join(",", registerCheckRows.
                                     GroupBy(o => o.asbitem.Id).
                                     Select(d => d.First().asbitem.DisplayName
                                     )
                                     .ToList()
                                     ),
                    CheckDate = (DateTime)registerCheckRow.registerCheck.CheckDate,
                };

                #region 采样信息

                var sampler = samplerList.FirstOrDefault(f => f.registerCheckId == registerCheckId);
                if (sampler != null)
                {
                    medicalReportRegisterCheckDto.SamplerName = _cacheService.GetSurnameAsync(sampler.samplerId).GetAwaiter().GetResult();
                    medicalReportRegisterCheckDto.SamplingTime = DataHelper.ConversionDateToString(sampler.samplingTime);
                }
                #endregion

                //检查医生
                var checkDoctorId = registerCheckRow.registerCheck.CheckDoctorId;
                if (!string.IsNullOrWhiteSpace(checkDoctorId))
                {
                    if (Guid.TryParse(checkDoctorId, out var checkDoctorIdGuid))
                    {
                        medicalReportRegisterCheckDto.CheckDoctorName = _cacheService.GetSurnameAsync(checkDoctorIdGuid).GetAwaiter().GetResult();
                        medicalReportRegisterCheckDto.CheckDoctorSignUrl = _cacheService.GetUserSignAsync(checkDoctorIdGuid).GetAwaiter().GetResult();
                    }
                    else
                    {
                        medicalReportRegisterCheckDto.CheckDoctorName = checkDoctorId;
                        medicalReportRegisterCheckDto.CheckDoctorSignUrl = "";
                    }
                }


                #region 体检审核信息

                medicalReportRegisterCheckDto.IsAudit = registerCheckRow.registerCheck.IsAudit;
                medicalReportRegisterCheckDto.AuditTime = DataHelper.ConversionDateToString(registerCheckRow.registerCheck.AuditTime);

                var auditorUserId = registerCheckRow.registerCheck.AuditorUserId;
                if (auditorUserId != null && auditorUserId != Guid.Empty)
                {
                    medicalReportRegisterCheckDto.AuditorUserName = _cacheService.GetSurnameAsync(auditorUserId).GetAwaiter().GetResult();
                    medicalReportRegisterCheckDto.AuditorUserSignUrl = _cacheService.GetUserSignAsync(auditorUserId).GetAwaiter().GetResult();
                }

                #endregion



                #region 第三方传过来的审核信息
                //lis审核医生+标本号
                medicalReportRegisterCheckDto.LisSampleNo = registerCheckRow.registerCheck.LisSampleNo;
                medicalReportRegisterCheckDto.SubmissionTime = DataHelper.ConversionDateToString(registerCheckRow.registerCheck.SubmissionTime);
                medicalReportRegisterCheckDto.AuditorTime = DataHelper.ConversionDateToString(registerCheckRow.registerCheck.AuditorTime);
                // medicalReportRegisterCheckDto.LisAuditorDoctorName = registerCheckRow.registerCheck.LisAuditorDoctorName;

                //lis审核医生
                var auditorNameId = registerCheckRow.registerCheck.AuditorName;
                if (!string.IsNullOrWhiteSpace(auditorNameId))
                {
                    if (Guid.TryParse(auditorNameId, out var auditorNameIdGuid))
                    {
                        medicalReportRegisterCheckDto.AuditorName = _cacheService.GetSurnameAsync(auditorNameIdGuid).GetAwaiter().GetResult();
                        medicalReportRegisterCheckDto.AuditorNameSignUrl = _cacheService.GetUserSignAsync(auditorNameIdGuid).GetAwaiter().GetResult();
                    }
                    else
                    {
                        medicalReportRegisterCheckDto.AuditorName = auditorNameId;
                        medicalReportRegisterCheckDto.AuditorNameSignUrl = "";
                    }
                }

                #endregion


                //显示顺序
                medicalReportRegisterCheckDto.DisplayOrder = registerCheckRow.asbitem.DisplayOrder;
                //明细结果
                foreach (var registerCheckItemRow in registerCheckRows)
                {
                    if (medicalReportRegisterCheckDto.Items.
                        Where(o => o.ItemId == registerCheckItemRow.registerCheckItem.ItemId).Count() > 0)
                    {
                        continue;
                    }
                    var resultStatus = resultStatusList.Where(o => o.Id == registerCheckItemRow.registerCheckItem.ResultStatusId).FirstOrDefault();

                    var medicalReportCheckItemDto = new MedicalReportCheckItemDto()
                    {
                        ItemId = registerCheckItemRow.registerCheckItem.ItemId,
                        ItemName = registerCheckItemRow.item.DisplayName,
                        Result = registerCheckItemRow.registerCheckItem.Result,
                        ReferenceRangeValue = registerCheckItemRow.registerCheckItem.ReferenceRangeValue,
                        CriticalRangeValue = registerCheckItemRow.registerCheckItem.CriticalRangeValue,
                        Unit = registerCheckItemRow.registerCheckItem.Unit,
                        ReportFontColor = (resultStatus == null) ? 0 : resultStatus.ReportFontColor,
                        ReportBackgroundColor = (resultStatus == null) ? 16579836 : resultStatus.ReportBackgroundColor,
                        ReportPrompt = (resultStatus == null) ? null : resultStatus.ReportPrompt,
                        DisplayOrder = registerCheckItemRow.item.DisplayOrder,
                    };
                    medicalReportRegisterCheckDto.Items.Add(medicalReportCheckItemDto);
                }
                //小结
                //medicalReportRegisterCheckDto.Summarys = registerCheckRows.Select(o => new MedicalReportCheckAsbitemSummaryDto()
                //{
                //    Summary = o.registerCheckSummaryHaveEmpty.Summary,
                //    DisplayOrder = o.registerCheckSummaryHaveEmpty.DisplayOrder
                //}).OrderBy(o => o.DisplayOrder).Distinct().ToList();
                medicalReportRegisterCheckDto.Summarys = registerCheckRows.Where(o => o.registerCheckSummaryHaveEmpty != null)
                    .GroupBy(g => g.registerCheckSummaryHaveEmpty.Id)
                    .Select(o => new MedicalReportCheckAsbitemSummaryDto()
                    {
                        Summary = o.FirstOrDefault().registerCheckSummaryHaveEmpty.Summary,
                        DisplayOrder = o.FirstOrDefault().registerCheckSummaryHaveEmpty.DisplayOrder
                    }).OrderBy(o => o.DisplayOrder).Distinct().ToList();
                //图片
                var registerCheckPictures = registerCheckRows.Where(o => o.registerCheckPictureHaveEmpty != null &&
                           o.registerCheckPictureHaveEmpty.IsPrint == 'Y')
                    .Select(o => new
                    {
                        PictureFilename = o.registerCheckPictureHaveEmpty.PictureFilename,
                        DisplayOrder = o.registerCheckPictureHaveEmpty.DisplayOrder,
                        PictureFileType = o.registerCheckPictureHaveEmpty.PictureFileType,
                        ItemTypeName = o.itemType.DisplayName
                    }).OrderBy(o => o.DisplayOrder).Distinct().ToList();
                foreach (var registerCheckPicture in registerCheckPictures)
                {
                    var medicalReportCheckPictureDto = new MedicalReportCheckPictureDto();
                    medicalReportCheckPictureDto.PictureFileName = registerCheckPicture.PictureFilename;
                    //medicalReportCheckPictureDto.PictureBase64 =
                    //    Shentun.Utilities.FileHelper.ToBase64(registerCheckPicture.PictureFilename);
                    medicalReportCheckPictureDto.DisplayOrder = registerCheckPicture.DisplayOrder;
                    medicalReportCheckPictureDto.PictureFileType = registerCheckPicture.PictureFileType;
                    medicalReportCheckPictureDto.ItemTypeName = registerCheckPicture.ItemTypeName;
                    medicalReportRegisterCheckDto.Pictures.Add(medicalReportCheckPictureDto);
                }
                medicalReportDto.RegisterChecks.Add(medicalReportRegisterCheckDto);
            }
        }
        /// <summary>
        /// 获取项目类别
        /// </summary>
        /// <returns></returns>
        private async Task<List<MedicalReportItemTypeDto>> GetItemTypeList()
        {
            var itemTypes = await _itemTypeRepository.GetListAsync();
            var medicalReportItemTypeDtos = new List<MedicalReportItemTypeDto>();
            foreach (var itemType in itemTypes)
            {
                var medicalReportItemTypeDto = new MedicalReportItemTypeDto()
                {
                    MedicalReportTypeId = itemType.MedicalReportTypeId,
                    ItemTypeId = itemType.Id,
                    ItemTypeName = itemType.DisplayName,
                    ItemTypePathCode = itemType.PathCode,
                    DisplayOrder = itemType.DisplayOrder,
                };
                medicalReportItemTypeDtos.Add(medicalReportItemTypeDto);

            }
            return medicalReportItemTypeDtos;
        }
        /// <summary>
        /// 获取体检报告类别
        /// </summary>
        /// <returns></returns>
        private async Task<List<MedicalReportMedicalReportTypeDto>> GetMedicalReportTypeList()
        {
            var medicalReportTypes = (await _medicalReportTypeRepository.GetListAsync()).OrderBy(o => o.DisplayOrder);
            var MedicalReportMedicalReportTypeDtos = new List<MedicalReportMedicalReportTypeDto>();
            foreach (var medicalReportType in medicalReportTypes)
            {
                MedicalReportMedicalReportTypeDtos.Add(new MedicalReportMedicalReportTypeDto()
                {
                    MedicalReportTypeId = medicalReportType.Id,
                    MedicalReportTypeName = medicalReportType.DisplayName,
                    DisplayOrder = medicalReportType.DisplayOrder,
                });
            }
            return MedicalReportMedicalReportTypeDtos;
        }

        private static List<PatientRegisterGuideReport_Detail> PatientRegisterGuideAsbitem(Guid PatientRegisterId, string PatientRegisterNo, Guid medicalCenterId, char SexId)
        {
            var entlist = _registerCheckAsbitemStaticRepository.GetQueryableAsync().Result
            .Include(x => x.Asbitem.ItemType)
            .Include(x => x.Asbitem.ItemType.GuidType)
            .Include(x => x.RegisterCheck)
            .Where(m => m.PatientRegisterId == PatientRegisterId && m.Asbitem.IsCheck == 'Y')
            .Select(s => new PatientRegisterGuideReport_Asbitem_Temp
            {
                AsbitemName = s.Asbitem.DisplayName,
                AsbitemGuide = _asbitemGuideManager.GetAsbitemGuideConvertSexId(medicalCenterId, s.AsbitemId, SexId),
                AsbitemDisplayOrder = s.Asbitem.DisplayOrder,
                ItemTypeDisplayOrder = s.Asbitem.ItemType.DisplayOrder,
                GuideDisplayOrder = s.Asbitem.ItemType.GuidType.DisplayOrder,
                GuideName = s.Asbitem.ItemType.GuidType.DisplayName,
                CheckRequestNo = GetCheckRequestNobyAsbitem(s.Asbitem, PatientRegisterNo, s.RegisterCheck.CheckRequestNo, s.Asbitem.ItemType.IsCheckRequest)
            })
            .OrderBy(o => o.GuideDisplayOrder)
            .GroupBy(g => new { g.GuideName, g.GuideDisplayOrder })
            .Select(s => new PatientRegisterGuideReport_Detail
            {
                GuideName = s.Key.GuideName,
                AsbitemCount = s.Count(),
                DisplayOrder = s.Key.GuideDisplayOrder,
                Detail_Name = s.ToList().Select(ss => new PatientRegisterGuideReport_Detail_Asbitem
                {
                    AsbitemName = ss.AsbitemName,
                    AsbitemGuide = ss.AsbitemGuide,
                    DisplayOrder = (ss.ItemTypeDisplayOrder * 3000) + ss.AsbitemDisplayOrder,
                    CheckRequestNo = ss.CheckRequestNo
                }).OrderBy(o => o.DisplayOrder).ToList()
            }).OrderBy(o => o.DisplayOrder).ToList();




            return entlist;

        }

        /// <summary>
        /// 获取检查单号
        /// </summary>
        /// <returns></returns>
        private static string GetCheckRequestNobyAsbitem(Asbitem asbitem, string PatientRegisterNo, string CheckRequestNo, char IsCheckRequest)
        {
            string result = "";
            if (asbitem.BarcodeMode == BarcodeModeFlag.UsingItemType && IsCheckRequest == 'Y')
            {
                result = CheckRequestNo;
            }
            else if (asbitem.BarcodeMode == BarcodeModeFlag.PrintPatientRegisterNumber)
            {
                result = PatientRegisterNo;
            }
            return result;
        }

        /// <summary>
        /// 获取项目结果对比
        /// </summary>
        /// <param name="newPatientRegister"></param>
        /// <returns></returns>
        private async Task<List<MedicalReportItemContrastDto>> GetMedicalReportItemContrastListAsync(PatientRegister newPatientRegister)
        {
            var query = (from patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                         join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                         join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                         join asbitem in await _asbitemRepository.GetQueryableAsync() on registerCheckAsbitem.AsbitemId equals asbitem.Id
                         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 patientRegister.PatientId == newPatientRegister.PatientId
                         && item.IsReportContrast == 'Y'
                         && patientRegister.MedicalStartDate != null
                         && patientRegister.MedicalStartDate >= newPatientRegister.MedicalStartDate.Value.AddYears(-3)
                         select new
                         {
                             registerCheckItem,
                             itemName = item.DisplayName,
                             medicalStartDate = patientRegister.MedicalStartDate,
                             asbitemName = asbitem.DisplayName
                         }).ToList();

            var entListDto = query.GroupBy(g => g.registerCheckItem)
                .Select(s => new MedicalReportItemContrastDto
                {
                    AsbitemName = string.Join(",", s.Select(s => s.asbitemName).Distinct()),
                    ItemName = s.FirstOrDefault().itemName,
                    ItemReferenceRange = s.Key.ReferenceRangeValue,
                    ItemResult = s.Key.Result,
                    MedicalStartDate = DataHelper.ConversionDateShortToString(s.FirstOrDefault().medicalStartDate)
                }).ToList();

            foreach (var item in entListDto)
            {
                decimal resultDecimal;
                if (!decimal.TryParse(item.ItemResult, out resultDecimal))
                {
                    item.ItemResult = "0";
                }
            }

            return entListDto;
        }
    }
}