peis/src/Shentun.Peis.Application/TransToWebPeis/TransToWebPeisAppService.cs

using Azure.Core;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json;
using Org.BouncyCastle.Utilities;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.DataMigrations;
using Shentun.Peis.Enums;
using Shentun.Peis.ItemTypes;
using Shentun.Peis.Models;
using Shentun.Peis.MyUser;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.PlugIns;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.TransToWebPeiss;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Net.Http;
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.Uow;
using Shentun.Peis.PrintReports;
using System.Threading;
using NPOI.HSSF.Record.Chart;
using System.IdentityModel.Tokens.Jwt;
using Shentun.Peis.PlugIns.Sms;
using Shentun.Peis.ThirdBookingPushs;
using Shentun.Peis.PlugIns.Extensions.PatientRegisters.Qztl;
using System.Data;

namespace Shentun.Peis.TransToWebPeis
{
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class TransToWebPeisAppService : ApplicationService
    {
        private readonly IRepository<DeviceType, Guid> _deviceTypeRepository;
        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<MedicalPackage, Guid> _medicalPackageRepository;
        private readonly IRepository<Diagnosis, Guid> _diagnosisRepository;
        private readonly IRepository<DiagnosisLevel> _diagnosisLevelRepository;
        private readonly ILogger<TransToWebPeisAppService> _logger;
        private readonly IRepository<ThirdInterface, Guid> _thirdInterfaceRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<CustomerOrgRegister, Guid> _customerOrgRegisterRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<CustomerOrgGroupDetail> _customerOrgGroupDetailRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<PatientRegisterExter> _patientRegisterExterRepository;
        private readonly UnitOfWorkManager _unitOfWorkManager;
        private readonly PrintReportAppService _printReportAppService;
        private readonly IConfiguration _configuration;
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly ThirdBookingPushAppService _thirdBookingPushAppService;

        private readonly SqlSugarClient Db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "server=135.191.65.102;uid=sa;pwd=123;database=mypeis0513;Encrypt=false;",
            DbType = SqlSugar.DbType.SqlServer,
            IsAutoCloseConnection = true
        });


        private readonly SqlSugarClient WebDb0520 = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "Host=10.1.12.138;Port=5432;Database=WebPeis0520;User ID=postgres;Password=st123;",
            DbType = SqlSugar.DbType.PostgreSQL,
            IsAutoCloseConnection = true
        });

        public TransToWebPeisAppService(
            IRepository<ItemType, Guid> itemTypeRepository,
            ILogger<TransToWebPeisAppService> logger,
            IRepository<ThirdInterface, Guid> thirdInterfaceRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<MedicalPackage, Guid> medicalPackageRepository,
            IRepository<Diagnosis, Guid> diagnosisRepository,
            IRepository<DiagnosisLevel> diagnosisLevelRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            IRepository<CustomerOrgRegister, Guid> customerOrgRegisterRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<CustomerOrgGroupDetail> customerOrgGroupDetailRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<PatientRegisterExter> patientRegisterExterRepository,
            UnitOfWorkManager unitOfWorkManager,
            PrintReportAppService printReportAppService,
            IConfiguration configuration,
            IRepository<Patient, Guid> patientRepository,
            ThirdBookingPushAppService thirdBookingPushAppService)
        {
            _itemTypeRepository = itemTypeRepository;
            _logger = logger;
            _thirdInterfaceRepository = thirdInterfaceRepository;
            _itemRepository = itemRepository;
            _asbitemRepository = asbitemRepository;
            _medicalPackageRepository = medicalPackageRepository;
            _diagnosisRepository = diagnosisRepository;
            _diagnosisLevelRepository = diagnosisLevelRepository;
            _customerOrgRepository = customerOrgRepository;
            _customerOrgRegisterRepository = customerOrgRegisterRepository;
            _customerOrgGroupRepository = customerOrgGroupRepository;
            _customerOrgGroupDetailRepository = customerOrgGroupDetailRepository;
            _patientRegisterRepository = patientRegisterRepository;
            _registerCheckRepository = registerCheckRepository;
            _patientRegisterExterRepository = patientRegisterExterRepository;
            _unitOfWorkManager = unitOfWorkManager;
            _printReportAppService = printReportAppService;
            _configuration = configuration;
            _patientRepository = patientRepository;
            _thirdBookingPushAppService = thirdBookingPushAppService;
        }



        /// <summary>
        /// 上传体检报告 并同步业务数据
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/UploadPeisReport")]
        public async Task UploadPeisReportAsync(UploadPeisReportIuputDto input)
        {

            var isPatientRegister = await _patientRegisterRepository.FirstOrDefaultAsync(f => f.Id == input.PatientRegisterId);
            if (isPatientRegister == null)
                throw new UserFriendlyException("人员不存在");
            if (isPatientRegister.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
                throw new UserFriendlyException("人员未总检，无法上传");

            if (string.IsNullOrWhiteSpace(isPatientRegister.ThirdBookingId))
            {
                //同步数据
                await TransPatientRegisterByPatientRegisterIdAsync(new PatientRegisterIdInputDto { PatientRegisterId = input.PatientRegisterId });

                //上传报告
                var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType ==
               ThirdInterfaceTypeFlag.TranToWebPeis);

                foreach (var thirdInterface in thirdInterfaces)
                {
                    var parmValue = thirdInterface.ParmValue;
                    var configurationBuilder = new ConfigurationBuilder()
                         .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                    var interfaceConfig = configurationBuilder.Build();
                    var url = interfaceConfig.GetSection("Interface").GetSection("Url").Value;
                    var user = interfaceConfig.GetSection("Interface").GetSection("User").Value;
                    var password = interfaceConfig.GetSection("Interface").GetSection("Password").Value;

                    var result = await CallAppServiceAsync<UploadPeisReportIuputDto, object>(url, "", input);

                }

                //更新上传状态
                var patientRegisterEnt = await _patientRegisterRepository.GetAsync(input.PatientRegisterId);
                patientRegisterEnt.IsUpload = 'Y';
                await _patientRegisterRepository.UpdateAsync(patientRegisterEnt);

                //推送短信
                await PushSmsAsync(patientRegisterEnt);
            }
            else
            {
                //上传到人寿
                await _thirdBookingPushAppService.PushReportFileAsync(new PushReportFileInputDto
                {
                    PatientRegisterId = input.PatientRegisterId,
                    ReportBase64 = input.ReportBase64
                });

                isPatientRegister.IsUpload = 'Y';
                await _patientRegisterRepository.UpdateAsync(isPatientRegister);
            }
        }

        /// <summary>
        /// 根据人员登记ID上传人员体检信息   上传备单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/TransPatientRegisterByPatientRegisterId")]
        public async Task TransPatientRegisterByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {

            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType ==
           ThirdInterfaceTypeFlag.TranToWebPeis);
            foreach (var thirdInterface in thirdInterfaces)
            {
                var connectString = GetConnectionStrings(thirdInterface.ParmValue);

                SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = connectString,
                    DbType = SqlSugar.DbType.PostgreSQL,
                    IsAutoCloseConnection = true
                });


                var IsPatient = (await WebDb.Ado.GetDataTableAsync($"select patient_register_id from patient_register where patient_register_id='{input.PatientRegisterId}'")).Rows.Count;
                if (IsPatient > 0)
                {
                    await DeletePatientRegisterWithDetailAsync(WebDb, input.PatientRegisterId);
                }

                await TransPatientRegisterWithDetailAsync(WebDb, input.PatientRegisterId);

            }
        }
        /// <summary>
        /// 撤销上传人员体检信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/CancelTransPatientRegisterByPatientRegisterId")]
        public async Task CancelTransPatientRegisterByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType ==
         ThirdInterfaceTypeFlag.TranToWebPeis);
            foreach (var thirdInterface in thirdInterfaces)
            {
                var connectString = GetConnectionStrings(thirdInterface.ParmValue);

                SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = connectString,
                    DbType = SqlSugar.DbType.PostgreSQL,
                    IsAutoCloseConnection = true
                });

                await DeletePatientRegisterWithDetailAsync(WebDb, input.PatientRegisterId);

            }
        }

        /// <summary>
        /// 导入数据 任务计划用    上传报告
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost("api/app/TransToWebPeis/SyncPatientRegisterReportByPatientRegisterId")]
        public async Task SyncPatientRegisterReportByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {

            var thirdInterface = await _thirdInterfaceRepository.FirstOrDefaultAsync(f => f.ThirdInterfaceType == ThirdInterfaceTypeFlag.TranToWebPeis);
            if (thirdInterface.IsActive != 'Y')
            {
                throw new UserFriendlyException("该接口已禁用");
            }

            var parmValue = thirdInterface.ParmValue;
            var configurationBuilder = new ConfigurationBuilder()
               .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var config = configurationBuilder.Build();
            var reportApiBaseAddress = config.GetSection("Interface").GetSection("ReportApiBaseAddress").Value;
            var reportApiUrl = config.GetSection("Interface").GetSection("ReportApiUrl").Value;

            string reportBase64 = "";
            #region 获取报告地址

            //var printReportData = await _printReportAppService.GetMedicalReportAsync(new PatientRegisterIdInputDto
            //{
            //    PatientRegisterId = input.PatientRegisterId
            //});

            var printReportData = await _printReportAppService.GetMedicalReportConvertToReportAsync(new PatientRegisterIdInputDto
            {
                PatientRegisterId = input.PatientRegisterId
            });


            using (var httpClientHandler = new HttpClientHandler())
            {
                using (var httpClient = new HttpClient(httpClientHandler))
                {
                    httpClient.BaseAddress = new Uri(reportApiBaseAddress);

                    httpClient.DefaultRequestHeaders.Accept.Add(
                      new MediaTypeWithQualityHeaderValue("application/json"));//设置accept标头，告诉JSON是可接受的响应类型


                    var sendData = JsonConvert.SerializeObject(printReportData);
                    using (HttpContent httpContent = new StringContent(sendData))
                    {
                        httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                        HttpResponseMessage response = null;

                        response = await httpClient.PostAsync(reportApiUrl, httpContent);


                        string result;
                        if (!response.IsSuccessStatusCode)
                        {
                            result = response.Content.ReadAsStringAsync().Result;
                            throw new Exception("http通信错误:" + response.StatusCode + ",结果:" + result);
                        }
                        result = await response.Content.ReadAsStringAsync();

                        var resultDto = JsonConvert.DeserializeObject<WebApiClientOutDto>(result);
                        if (resultDto != null)
                        {
                            if (resultDto.code != 1)
                            {
                                throw new Exception($"调用WebApi失败，返回-1,消息:" + result);
                            }

                            reportBase64 = resultDto.data;
                        }
                    }

                }
            }

            Thread.Sleep(1000);

            #endregion

            //获取到报告地址  
            if (!string.IsNullOrWhiteSpace(reportBase64))
            {
                await UploadPeisReportAsync(new UploadPeisReportIuputDto
                {
                    PatientRegisterId = input.PatientRegisterId,
                    ReportBase64 = reportBase64
                });
            }
        }

        #region MyRegion


        /// <summary>
        /// 上传基础资料
        /// </summary>
        /// <returns></returns>

        [HttpPost("api/app/TransToWebPeis/TransBaseData")]
        public async Task TransBaseDataAsync()
        {
            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType ==
            ThirdInterfaceTypeFlag.TranToWebPeis);
            foreach (var thirdInterface in thirdInterfaces)
            {
                var connectString = GetConnectionStrings(thirdInterface.ParmValue);

                SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = connectString,
                    DbType = SqlSugar.DbType.PostgreSQL,
                    IsAutoCloseConnection = true
                });

                try
                {
                    await WebDb.Ado.BeginTranAsync();

                    #region 清理基础数据
                    //删除

                    await WebDb.Ado.ExecuteCommandAsync("delete from medical_package_detail;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from medical_package;");

                    await WebDb.Ado.ExecuteCommandAsync("delete from customer_org_group_detail;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from customer_org_group;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from customer_org_register;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from customer_org;");

                    await WebDb.Ado.ExecuteCommandAsync("delete from diagnosis;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from diagnosis_level;");

                    await WebDb.Ado.ExecuteCommandAsync("delete from asbitem_detail;");
                    await WebDb.Ado.ExecuteCommandAsync("delete from asbitem;");

                    await WebDb.Ado.ExecuteCommandAsync("delete from item;");

                    await WebDb.Ado.ExecuteCommandAsync("delete from item_type;");
                    #endregion


                    await TransItemType(WebDb);
                    await TransItem(WebDb);
                    await TransAsbitem(WebDb);
                    await TransMedicalPackage(WebDb);
                    await TransDiagnosis(WebDb);



                    await TransCustomerOrgAsync(WebDb);
                    await TransCustomerOrgRegisterAsync(WebDb);
                    await TransCustomerOrgGroupAsync(WebDb);
                    await TransCustomerOrgGroupDetailAsync(WebDb);

                    await WebDb.Ado.CommitTranAsync();
                }
                catch (Exception ex)
                {
                    await WebDb.Ado.RollbackTranAsync();
                    _logger.LogError($"上传基础数据异常：{ex.Message}");
                }

            }




            //var connectString = "Host=10.1.12.140;Port=5432;Database=WebPeis;User ID=postgres;Password=st123;";

            //SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
            //{
            //    ConnectionString = connectString,
            //    DbType = SqlSugar.DbType.PostgreSQL,
            //    IsAutoCloseConnection = true
            //});


        }

        /// <summary>
        /// 获取数据库连接地址
        /// </summary>
        /// <param name="parmValue"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        private string GetConnectionStrings(string parmValue)
        {
            var configurationBuilder = new ConfigurationBuilder()
          .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
            var interfaceConfig = configurationBuilder.Build();
            var interfaceConnctionStr = interfaceConfig.GetSection("Interface").GetSection("ConnectionStrings").Value;
            if (!interfaceConnctionStr.ToUpper().Contains("WEBPEIS"))
                throw new UserFriendlyException("请检查配置的数据库地址");
            return interfaceConnctionStr;
        }

        private async Task<TOut> CallAppServiceAsync<TInput, TOut>(string appBaseAddress, string url, TInput data)
        {
            string baseAddress = appBaseAddress;

            using (var httpClientHandler = new HttpClientHandler())
            {
                using (var httpClient = new HttpClient(httpClientHandler))
                {
                    httpClient.BaseAddress = new Uri(baseAddress);

                    httpClient.DefaultRequestHeaders.Accept.Add(
                      new MediaTypeWithQualityHeaderValue("application/json"));//设置accept标头，告诉JSON是可接受的响应类型
                    //httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _accesToken);
                    string sendData = "";
                    if (data != null)
                    {
                        IsoDateTimeConverter timeFormat = new IsoDateTimeConverter();
                        timeFormat.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
                        sendData = JsonConvert.SerializeObject(data, Newtonsoft.Json.Formatting.Indented, timeFormat);
                    }

                    using (HttpContent httpContent = new StringContent(sendData))
                    {
                        httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                        HttpResponseMessage response = await httpClient.PostAsync(url, httpContent);
                        string result;
                        if (!response.IsSuccessStatusCode)
                        {
                            result = response.Content.ReadAsStringAsync().Result;
                            throw new Exception("http通信错误:" + response.StatusCode + ",结果:" + result);
                        }
                        result = await response.Content.ReadAsStringAsync();

                        var resultDto = JsonConvert.DeserializeObject<WebApiOutDto<TOut>>(result);
                        if (resultDto.Code == -1)
                        {
                            throw new Exception($"调用服务失败{resultDto.Message}");
                        }
                        return resultDto.Data;

                    }

                }
            }
        }
        #endregion

        #region 基础数据

        /// <summary>
        /// 项目类别
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransItemType(SqlSugarClient WebDb)
        {
            var itemTypes = await _itemTypeRepository.GetListAsync();
            if (itemTypes.Count > 0)
            {


                foreach (var itemType in itemTypes)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.item_type(item_type_id,item_type_name,simple_code,parent_id,path_code,check_type_flag,display_order,is_wrap, concurrency_stamp,creation_time,creator_id,last_modification_time,last_modifier_id) " +
                          "VALUES (@item_type_id,@item_type_name,@simple_code,@parent_id::uuid,@path_code,@check_type_flag,@display_order,@is_wrap,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                              new List<SugarParameter>() {
                            new SugarParameter("@item_type_id",itemType.Id),
                            new SugarParameter("@item_type_name",itemType.DisplayName),
                            new SugarParameter("@simple_code",itemType.SimpleCode),
                            new SugarParameter("@parent_id",itemType.ParentId),
                            new SugarParameter("@path_code",itemType.PathCode),
                            new SugarParameter("@check_type_flag",itemType.CheckTypeFlag),
                            new SugarParameter("@display_order",itemType.DisplayOrder),
                            new SugarParameter("@is_wrap",itemType.IsWrap),
                            new SugarParameter("@concurrency_stamp",itemType.ConcurrencyStamp),
                            new SugarParameter("@creation_time",itemType.CreationTime),
                            new SugarParameter("@creator_id",itemType.CreatorId),
                            new SugarParameter("@last_modification_time",itemType.LastModificationTime),
                            new SugarParameter("@last_modifier_id",itemType.LastModifierId)
                          });
                }

                _logger.LogInformation($"项目类别数据处理完毕，数量{itemTypes.Count}");

            }
        }

        /// <summary>
        /// 项目数据
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransItem(SqlSugarClient WebDb)
        {
            var items = await _itemRepository.GetListAsync();
            if (items.Count > 0)
            {
                foreach (var item in items)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.item(item_id, item_name, english_short_name, item_type_id, price, unit_id, default_result, reference_range_type_flag, is_calculation_item, " +
                        "is_active,simple_code, display_order,line_mode_flag, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id, device_type_id) values " +
                        "(@item_id,@item_name,@english_short_name,@item_type_id,@price,@unit_id::uuid,@default_result,@reference_range_type_flag,@is_calculation_item,@is_active,@simple_code,@display_order," +
                        "@line_mode_flag,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@device_type_id::uuid);",
                              new List<SugarParameter>() {
                            new SugarParameter("@item_id",item.Id),
                            new SugarParameter("@item_name",item.DisplayName),
                            new SugarParameter("@english_short_name",item.EnglishShortName),
                            new SugarParameter("@item_type_id",item.ItemTypeId),
                            new SugarParameter("@price",item.Price),
                            new SugarParameter("@unit_id",item.UnitId),
                            new SugarParameter("@default_result",item.DefaultResult),
                            new SugarParameter("@reference_range_type_flag",item.ReferenceRangeTypeFlag),
                            new SugarParameter("@is_calculation_item",item.IsCalculationItem),
                            new SugarParameter("@is_active",item.IsActive),
                            new SugarParameter("@simple_code",item.SimpleCode),
                            new SugarParameter("@display_order",item.DisplayOrder),
                            new SugarParameter("@line_mode_flag",item.LineModeFlag),
                            new SugarParameter("@concurrency_stamp",item.ConcurrencyStamp),
                            new SugarParameter("@device_type_id",item.DeviceTypeId),
                            new SugarParameter("@creation_time",item.CreationTime),
                            new SugarParameter("@creator_id",item.CreatorId),
                            new SugarParameter("@last_modification_time",item.LastModificationTime),
                            new SugarParameter("@last_modifier_id",item.LastModifierId)
                          });
                }

                _logger.LogInformation($"项目数据处理完毕，数量{items.Count}");

            }
        }

        /// <summary>
        /// 组合项目、明细
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransAsbitem(SqlSugarClient WebDb)
        {
            var asbitemWithDetails = (await _asbitemRepository.GetQueryableAsync()).Include(x => x.AsbitemDetails).ToList();
            if (asbitemWithDetails.Count > 0)
            {
                foreach (var asbitem in asbitemWithDetails)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.asbitem(asbitem_id, asbitem_name, short_name, for_sex_id, item_type_id," +
                        "price, device_type_id, is_before_eat, clinical_meaning, default_result," +
                        "is_picture_rotate, is_check, is_active, simple_code, display_order, concurrency_stamp," +
                        "creation_time, creator_id, last_modification_time, last_modifier_id, is_web_appoint,warn,disease_screening_type_id,for_pregnant_flag,marital_status_id) values " +
                        "(@asbitem_id,@asbitem_name,@short_name,@for_sex_id,@item_type_id,@price,@device_type_id::uuid,@is_before_eat,@clinical_meaning," +
                        "@default_result,@is_picture_rotate,@is_check,@is_active,@simple_code,@display_order,@concurrency_stamp,@creation_time," +
                        "@creator_id,@last_modification_time,@last_modifier_id,@is_web_appoint,@warn,@disease_screening_type_id::uuid,@for_pregnant_flag,@marital_status_id)",
                              new List<SugarParameter>() {
                                  new SugarParameter("asbitem_id",asbitem.Id),
                                  new SugarParameter("asbitem_name",asbitem.DisplayName),
                                  new SugarParameter("short_name",asbitem.ShortName),
                                  new SugarParameter("for_sex_id",asbitem.ForSexId),
                                  new SugarParameter("item_type_id",asbitem.ItemTypeId),
                                  new SugarParameter("price",asbitem.Price),
                                  new SugarParameter("device_type_id",asbitem.DeviceTypeId),
                                  new SugarParameter("is_before_eat",asbitem.IsBeforeEat),
                                  new SugarParameter("clinical_meaning",asbitem.ClinicalMeaning),
                                  new SugarParameter("default_result",asbitem.DefaultResult),
                                  new SugarParameter("is_picture_rotate",asbitem.IsPictureRotate),
                                  new SugarParameter("is_check",asbitem.IsCheck),
                                  new SugarParameter("is_active",asbitem.IsActive),
                                  new SugarParameter("simple_code",asbitem.SimpleCode),
                                  new SugarParameter("display_order",asbitem.DisplayOrder),
                                  new SugarParameter("concurrency_stamp",asbitem.ConcurrencyStamp),
                                  new SugarParameter("creation_time",asbitem.CreationTime),
                                  new SugarParameter("creator_id",asbitem.CreatorId),
                                  new SugarParameter("last_modification_time",asbitem.LastModificationTime),
                                  new SugarParameter("last_modifier_id",asbitem.LastModifierId),
                                  new SugarParameter("is_web_appoint",asbitem.IsWebAppoint),
                                  new SugarParameter("warn",asbitem.Warn),
                                  new SugarParameter("disease_screening_type_id",asbitem.DiseaseScreeningTypeId),
                                  new SugarParameter("for_pregnant_flag",asbitem.ForPregnantFlag),
                                  new SugarParameter("marital_status_id",asbitem.MaritalStatusId)
                          });

                    //插入明细

                    foreach (var asbitemDetail in asbitem.AsbitemDetails)
                    {
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.asbitem_detail(asbitem_id, item_id, concurrency_stamp) values " +
                  "(@asbitem_id,@item_id,@concurrency_stamp)",
                        new List<SugarParameter>() {
                                  new SugarParameter("asbitem_id",asbitemDetail.AsbitemId),
                                  new SugarParameter("item_id",asbitemDetail.ItemId),
                                  new SugarParameter("concurrency_stamp",asbitemDetail.ConcurrencyStamp)
                    });
                    }
                }

                _logger.LogInformation($"组合项目、明细项目数据处理完毕，数量{asbitemWithDetails.Count}");

            }
        }

        /// <summary>
        /// 套餐
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransMedicalPackage(SqlSugarClient WebDb)
        {
            var medicalPackageWithDetails = (await _medicalPackageRepository.GetQueryableAsync()).Include(x => x.MedicalPackageDetails).ToList();
            if (medicalPackageWithDetails.Count > 0)
            {
                foreach (var medicalPackage in medicalPackageWithDetails)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.medical_package(medical_package_id, medical_package_name, price, for_sex_id, is_active, remark, display_order, simple_code," +
                        "concurrency_stamp,creation_time, creator_id, last_modification_time, last_modifier_id, is_web_appoint, marital_status_id,is_basic_recommend,age_lower_limit,age_upper_limit) values " +
                        "(@medical_package_id,@medical_package_name,@price,@for_sex_id,@is_active,@remark,@display_order,@simple_code, " +
                        "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@is_web_appoint,@marital_status_id,@is_basic_recommend,@age_lower_limit,@age_upper_limit)",
                              new List<SugarParameter>() {
                                 new SugarParameter("medical_package_id",medicalPackage.Id),
                                  new SugarParameter("medical_package_name",medicalPackage.DisplayName),
                                  new SugarParameter("price",medicalPackage.Price),
                                  new SugarParameter("for_sex_id",medicalPackage.ForSexId),
                                  new SugarParameter("is_active",medicalPackage.IsActive),
                                  new SugarParameter("remark",medicalPackage.Remark),
                                  new SugarParameter("display_order",medicalPackage.DisplayOrder),
                                  new SugarParameter("simple_code",medicalPackage.SimpleCode),
                                  new SugarParameter("concurrency_stamp",medicalPackage.ConcurrencyStamp),
                                  new SugarParameter("creation_time",medicalPackage.CreationTime),
                                  new SugarParameter("creator_id",medicalPackage.CreatorId),
                                  new SugarParameter("last_modification_time",medicalPackage.LastModificationTime),
                                  new SugarParameter("last_modifier_id",medicalPackage.LastModifierId),
                                  new SugarParameter("is_web_appoint",medicalPackage.IsWebAppoint),
                                  new SugarParameter("marital_status_id",medicalPackage.MaritalStatusId),
                                  new SugarParameter("is_basic_recommend",medicalPackage.IsBasicRecommend),
                                  new SugarParameter("age_lower_limit",medicalPackage.AgeLowerLimit),
                                  new SugarParameter("age_upper_limit",medicalPackage.AgeUpperLimit)
                          });

                    //插入明细

                    foreach (var medicalPackageDetail in medicalPackage.MedicalPackageDetails)
                    {
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.medical_package_detail(medical_package_id, asbitem_id,price,amount,concurrency_stamp) values " +
                  "(@medical_package_id,@asbitem_id,@price,@amount,@concurrency_stamp)",
                        new List<SugarParameter>() {
                                  new SugarParameter("medical_package_id",medicalPackageDetail.MedicalPackageId),
                                  new SugarParameter("asbitem_id",medicalPackageDetail.AsbitemId),
                                  new SugarParameter("price",medicalPackageDetail.Price),
                                  new SugarParameter("amount",medicalPackageDetail.Amount),
                                  new SugarParameter("concurrency_stamp",medicalPackageDetail.ConcurrencyStamp)
                    });
                    }
                }

                _logger.LogInformation($"套餐数据、套餐明细处理完毕，数量{medicalPackageWithDetails.Count}");

            }
        }
        /// <summary>
        /// 诊断
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransDiagnosis(SqlSugarClient WebDb)
        {
            //诊断级别
            var diagnosisLevels = await _diagnosisLevelRepository.GetListAsync();
            if (diagnosisLevels.Count > 0)
            {
                foreach (var diagnosisLevel in diagnosisLevels)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.diagnosis_level(diagnosis_level_id, display_name, display_order, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) " +
                          "VALUES (@diagnosis_level_id,@display_name,@display_order,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                              new List<SugarParameter>() {
                                  new SugarParameter("diagnosis_level_id",diagnosisLevel.Id),
                                  new SugarParameter("display_name",diagnosisLevel.DisplayName),
                                  new SugarParameter("display_order",diagnosisLevel.DisplayOrder),
                                  new SugarParameter("concurrency_stamp",diagnosisLevel.ConcurrencyStamp),
                                  new SugarParameter("creation_time",diagnosisLevel.CreationTime),
                                  new SugarParameter("creator_id",diagnosisLevel.CreatorId),
                                  new SugarParameter("last_modification_time",diagnosisLevel.LastModificationTime),
                                  new SugarParameter("last_modifier_id",diagnosisLevel.LastModifierId)
                          });
                }

                _logger.LogInformation($"诊断级别数据处理完毕，数量{diagnosisLevels.Count}");

            }

            //诊断
            var diagnosiss = await _diagnosisRepository.GetListAsync();
            if (diagnosiss.Count > 0)
            {
                foreach (var diagnosis in diagnosiss)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.diagnosis(diagnosis_id, diagnosis_name, item_type_id, suggestion_name, is_ill, for_sex_id, diagnosis_level_id, " +
                        "simple_code,display_order,concurrency_stamp, creation_time, creator_id,last_modification_time,last_modifier_id) " +
                          "VALUES (@diagnosis_id,@diagnosis_name,@item_type_id,@suggestion_name,@is_ill,@for_sex_id,@diagnosis_level_id," +
                          "@simple_code,@display_order,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                              new List<SugarParameter>() {
                                 new SugarParameter("diagnosis_id",diagnosis.Id),
                                  new SugarParameter("diagnosis_name",diagnosis.DisplayName),
                                  new SugarParameter("item_type_id",diagnosis.ItemTypeId),
                                  new SugarParameter("suggestion_name",diagnosis.SuggestionName),
                                  new SugarParameter("is_ill",diagnosis.IsIll),
                                  new SugarParameter("for_sex_id",diagnosis.ForSexId),
                                  new SugarParameter("diagnosis_level_id",diagnosis.DiagnosisLevelId),
                                  new SugarParameter("simple_code",diagnosis.SimpleCode),
                                  new SugarParameter("display_order",diagnosis.DisplayOrder),
                                  new SugarParameter("concurrency_stamp",diagnosis.ConcurrencyStamp),
                                  new SugarParameter("creation_time",diagnosis.CreationTime),
                                  new SugarParameter("creator_id",diagnosis.CreatorId),
                                  new SugarParameter("last_modification_time",diagnosis.LastModificationTime),
                                  new SugarParameter("last_modifier_id",diagnosis.LastModifierId)
                          });
                }

                _logger.LogInformation($"诊断数据处理完毕，数量{diagnosiss.Count}");

            }
        }
        #endregion

        #region 单位相关

        /// <summary>
        /// 单位数据
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransCustomerOrgAsync(SqlSugarClient WebDb)
        {
            var customerOrgs = await _customerOrgRepository.GetListAsync();
            if (customerOrgs.Count > 0)
            {
                foreach (var customerOrg in customerOrgs)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.customer_org(customer_org_id, customer_org_name, short_name, parent_id, path_code, simple_code, remark, is_active, display_order," +
                        "concurrency_stamp, medical_center_id, creation_time, creator_id, last_modification_time, last_modifier_id, country_org_code) " +
                          "VALUES (@customer_org_id,@customer_org_name,@short_name,@parent_id::uuid,@path_code,@simple_code,@remark,@is_active,@display_order," +
                          "@concurrency_stamp,@medical_center_id,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@country_org_code);",
                              new List<SugarParameter>() {
                                  new SugarParameter("customer_org_id",customerOrg.Id),
                                  new SugarParameter("customer_org_name",customerOrg.DisplayName),
                                  new SugarParameter("short_name",customerOrg.ShortName),
                                  new SugarParameter("parent_id",customerOrg.ParentId),
                                  new SugarParameter("path_code",customerOrg.PathCode),
                                  new SugarParameter("simple_code",customerOrg.SimpleCode),
                                  new SugarParameter("remark",customerOrg.Remark),
                                  new SugarParameter("is_active",customerOrg.IsActive),
                                  new SugarParameter("display_order",customerOrg.DisplayOrder),
                                  new SugarParameter("concurrency_stamp",customerOrg.ConcurrencyStamp),
                                  new SugarParameter("medical_center_id",customerOrg.MedicalCenterId),
                                  new SugarParameter("creation_time",customerOrg.CreationTime),
                                  new SugarParameter("creator_id",customerOrg.CreatorId),
                                  new SugarParameter("last_modification_time",customerOrg.LastModificationTime),
                                  new SugarParameter("last_modifier_id",customerOrg.LastModifierId),
                                  new SugarParameter("country_org_code",customerOrg.CountryOrgCode)
                          });
                }

                _logger.LogInformation($"单位数据处理完毕，数量{customerOrgs.Count}");

            }
        }

        /// <summary>
        /// 单位体检次数
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransCustomerOrgRegisterAsync(SqlSugarClient WebDb)
        {
            var customerOrgRegisters = await _customerOrgRegisterRepository.GetListAsync();
            if (customerOrgRegisters.Count > 0)
            {
                foreach (var customerOrgRegister in customerOrgRegisters)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.customer_org_register(customer_org_register_id, customer_org_id, medical_times, register_no, register_name, begin_time," +
                        "end_time, is_complete, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id,is_question) " +
                          "VALUES (@customer_org_register_id,@customer_org_id,@medical_times,@register_no,@register_name,@begin_time," +
                          "CAST(@end_time as timestamp),@is_complete,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@is_question);",
                              new List<SugarParameter>() {
                                  new SugarParameter("customer_org_register_id",customerOrgRegister.Id),
                                  new SugarParameter("customer_org_id",customerOrgRegister.CustomerOrgId),
                                  new SugarParameter("medical_times",customerOrgRegister.MedicalTimes),
                                  new SugarParameter("register_no",customerOrgRegister.RegisterNo),
                                  new SugarParameter("register_name",customerOrgRegister.RegisterName),
                                  new SugarParameter("begin_time",customerOrgRegister.BeginTime),
                                  new SugarParameter("end_time",customerOrgRegister.EndTime),
                                  new SugarParameter("is_complete",customerOrgRegister.IsComplete),
                                  new SugarParameter("concurrency_stamp",customerOrgRegister.ConcurrencyStamp),
                                  new SugarParameter("creation_time",customerOrgRegister.CreationTime),
                                  new SugarParameter("creator_id",customerOrgRegister.CreatorId),
                                  new SugarParameter("last_modification_time",customerOrgRegister.LastModificationTime),
                                  new SugarParameter("last_modifier_id",customerOrgRegister.LastModifierId),
                                  new SugarParameter("is_question",customerOrgRegister.IsQuestion)
                          });
                }

                _logger.LogInformation($"单位体检次数数据处理完毕，数量{customerOrgRegisters.Count}");

            }
        }


        /// <summary>
        /// 单位分组
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransCustomerOrgGroupAsync(SqlSugarClient WebDb)
        {
            var customerOrgGroups = await _customerOrgGroupRepository.GetListAsync();
            if (customerOrgGroups.Count > 0)
            {
                foreach (var customerOrgGroup in customerOrgGroups)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.customer_org_group(customer_org_group_id, customer_org_group_name, price, for_sex_id, marital_status_id, age_lower_limit, age_upper_limit," +
                        "job_post, job_title, remark, display_order, customer_org_register_id, concurrency_stamp, creation_time, creator_id,last_modification_time, last_modifier_id,can_add_money) " +
                          "VALUES (@customer_org_group_id,@customer_org_group_name,@price,@for_sex_id,@marital_status_id,@age_lower_limit,@age_upper_limit," +
                          "@job_post,@job_title,@remark,@display_order,@customer_org_register_id,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@can_add_money);",
                              new List<SugarParameter>() {
                                  new SugarParameter("customer_org_group_id",customerOrgGroup.Id),
                                  new SugarParameter("customer_org_group_name",customerOrgGroup.DisplayName),
                                  new SugarParameter("price",customerOrgGroup.Price),
                                  new SugarParameter("for_sex_id",customerOrgGroup.ForSexId),
                                  new SugarParameter("marital_status_id",customerOrgGroup.MaritalStatusId),
                                  new SugarParameter("age_lower_limit",customerOrgGroup.AgeLowerLimit),
                                  new SugarParameter("age_upper_limit",customerOrgGroup.AgeUpperLimit),
                                  new SugarParameter("job_post",customerOrgGroup.JobPost),
                                  new SugarParameter("job_title",customerOrgGroup.JobTitle),
                                  new SugarParameter("remark",customerOrgGroup.Remark),
                                  new SugarParameter("display_order",customerOrgGroup.DisplayOrder),
                                  new SugarParameter("customer_org_register_id",customerOrgGroup.CustomerOrgRegisterId),
                                  new SugarParameter("concurrency_stamp",customerOrgGroup.ConcurrencyStamp),
                                  new SugarParameter("creation_time",customerOrgGroup.CreationTime),
                                  new SugarParameter("creator_id",customerOrgGroup.CreatorId),
                                  new SugarParameter("last_modification_time",customerOrgGroup.LastModificationTime),
                                  new SugarParameter("last_modifier_id",customerOrgGroup.LastModifierId),
                                  new SugarParameter("can_add_money",customerOrgGroup.CanAddMoney),
                          });
                }

                _logger.LogInformation($"单位分组数据处理完毕，数量{customerOrgGroups.Count}");

            }
        }

        /// <summary>
        /// 单位分组明细
        /// </summary>
        /// <param name="WebDb"></param>
        /// <returns></returns>
        private async Task TransCustomerOrgGroupDetailAsync(SqlSugarClient WebDb)
        {
            var customerOrgGroupDetails = await _customerOrgGroupDetailRepository.GetListAsync();
            if (customerOrgGroupDetails.Count > 0)
            {
                foreach (var customerOrgGroupDetail in customerOrgGroupDetails)
                {
                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.customer_org_group_detail(customer_org_group_id, asbitem_id, price, amount, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) " +
                          "VALUES (@customer_org_group_id,@asbitem_id,@price,@amount,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                              new List<SugarParameter>() {
                                  new SugarParameter("customer_org_group_id",customerOrgGroupDetail.CustomerOrgGroupId),
                                  new SugarParameter("asbitem_id",customerOrgGroupDetail.AsbitemId),
                                  new SugarParameter("price",customerOrgGroupDetail.Price),
                                  new SugarParameter("amount",customerOrgGroupDetail.Amount),
                                  new SugarParameter("concurrency_stamp",customerOrgGroupDetail.ConcurrencyStamp),
                                  new SugarParameter("creation_time",customerOrgGroupDetail.CreationTime),
                                  new SugarParameter("creator_id",customerOrgGroupDetail.CreatorId),
                                  new SugarParameter("last_modification_time",customerOrgGroupDetail.LastModificationTime),
                                  new SugarParameter("last_modifier_id",customerOrgGroupDetail.LastModifierId)
                          });
                }

                _logger.LogInformation($"单位分组明细数据处理完毕，数量{customerOrgGroupDetails.Count}");

            }
        }

        #endregion

        #region 人员导入
        /// <summary>
        /// 人员导入   
        /// </summary>
        /// <param name="WebDb"></param>
        /// <param name="PatientRegisterId"></param>
        /// <returns></returns>
        private async Task TransPatientRegisterWithDetailAsync(SqlSugarClient WebDb, Guid PatientRegisterId)
        {
            try
            {
                await WebDb.Ado.BeginTranAsync();

                //人员登记信息
                var patientRegisterEnt = (await _patientRegisterRepository.GetQueryableAsync())
                    .Include(x => x.Patient)
                    .Include(x => x.SumDiagnoses)
                    .Include(x => x.SumSuggestionHeaders).ThenInclude(x => x.SumSuggestionContents)
                    .Include(x => x.SumSummaryHeaders).ThenInclude(x => x.SumSummaryContents)
                    .Where(m => m.Id == PatientRegisterId).FirstOrDefault();
                if (patientRegisterEnt != null)
                {
                    //if (patientRegisterEnt.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
                    //    throw new UserFriendlyException("人员未总检，不能同步");






                    var IsPatient = (await WebDb.Ado.GetDataTableAsync($"select patient_id from patient where patient_id='{patientRegisterEnt.PatientId}'")).Rows.Count;
                    if (IsPatient == 0)
                    {
                        #region 插入档案

                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.patient(patient_id, patient_no, medical_center_id, patient_name, sex_id, marital_status_id," +
                            " birth_date, nation_id, birth_place_id, id_no, postal_code, email, telephone, mobile_telephone, address, simple_code, concurrency_stamp, creation_time," +
                            " creator_id, last_modification_time, last_modifier_id) VALUES (@patient_id,@patient_no,@medical_center_id,@patient_name,@sex_id,@marital_status_id," +
                            "CAST(@birth_date as timestamp),@nation_id,@birth_place_id::uuid,@id_no,@postal_code,@email,@telephone,@mobile_telephone,@address,@simple_code,@concurrency_stamp,@creation_time," +
                            "@creator_id,@last_modification_time,@last_modifier_id);",
                            new List<SugarParameter>() {
                                new SugarParameter("patient_id",patientRegisterEnt.Patient.Id),
                                new SugarParameter("patient_no",patientRegisterEnt.Patient.PatientNo),
                                new SugarParameter("medical_center_id",patientRegisterEnt.Patient.MedicalCenterId),
                                new SugarParameter("patient_name",patientRegisterEnt.Patient.DisplayName),
                                new SugarParameter("sex_id",patientRegisterEnt.Patient.SexId),
                                new SugarParameter("marital_status_id",patientRegisterEnt.Patient.MaritalStatusId),
                                new SugarParameter("birth_date",patientRegisterEnt.Patient.BirthDate),
                                new SugarParameter("nation_id",patientRegisterEnt.Patient.NationId),
                                new SugarParameter("birth_place_id",patientRegisterEnt.Patient.BirthPlaceId),
                                new SugarParameter("id_no",patientRegisterEnt.Patient.IdNo),
                                new SugarParameter("postal_code",patientRegisterEnt.Patient.PostalCode),
                                new SugarParameter("email",patientRegisterEnt.Patient.Email),
                                new SugarParameter("telephone",patientRegisterEnt.Patient.Telephone),
                                new SugarParameter("mobile_telephone",patientRegisterEnt.Patient.MobileTelephone),
                                new SugarParameter("address",patientRegisterEnt.Patient.Address),
                                new SugarParameter("simple_code",patientRegisterEnt.Patient.SimpleCode),
                                new SugarParameter("concurrency_stamp",patientRegisterEnt.Patient.ConcurrencyStamp),
                                new SugarParameter("creation_time",patientRegisterEnt.Patient.CreationTime),
                                new SugarParameter("creator_id",patientRegisterEnt.Patient.CreatorId),
                                new SugarParameter("last_modification_time",patientRegisterEnt.Patient.LastModificationTime),
                                new SugarParameter("last_modifier_id",patientRegisterEnt.Patient.LastModifierId)
                          });

                        #endregion
                    }


                    short newMedicalTimes = 1;
                    var maxMedicalTimes = await WebDb.Ado.GetStringAsync($"select max(medical_times) from patient_register where patient_id='{patientRegisterEnt.PatientId}'");
                    if (!string.IsNullOrWhiteSpace(maxMedicalTimes))
                    {
                        newMedicalTimes = (short)(Convert.ToInt16(maxMedicalTimes) + 1);
                    }



                    #region 插入人员登记信息

                    string third_register_id = "";
                    var patientRegisterExterEnt = await _patientRegisterExterRepository.FirstOrDefaultAsync(f => f.PatientRegisterId == PatientRegisterId);
                    if (patientRegisterExterEnt != null && !string.IsNullOrWhiteSpace(patientRegisterExterEnt.Planuserid))
                        third_register_id = patientRegisterExterEnt.Planuserid;

                    await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.patient_register(patient_register_id, patient_register_no, patient_id, medical_times, customer_org_id, customer_org_group_id, medical_package_id," +
                        "patient_name,sex_id, birth_date, age, job_card_no, medical_card_no, marital_status_id, medical_type_id, personnel_type_id, job_post, job_title, photo," +
                        " sex_hormone_term_id, interpose_measure, medical_conclusion_id, complete_flag, is_medical_start, medical_start_date, summary_date, is_audit, audit_date, is_vip, third_info,remark,medical_center_id," +
                        "customer_org_register_id, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id, audit_doctor_id,summary_doctor_id, his_patient_id,third_register_id) VALUES " +
                        "(@patient_register_id,@patient_register_no,@patient_id,@medical_times,@customer_org_id,@customer_org_group_id::uuid,@medical_package_id::uuid," +
                        "@patient_name,@sex_id,CAST(@birth_date as timestamp),@age::smallint,@job_card_no,@medical_card_no,@marital_status_id,@medical_type_id::uuid,@personnel_type_id::uuid,@job_post,@job_title,@photo," +
                        "@sex_hormone_term_id::uuid,@interpose_measure,@medical_conclusion_id::uuid,@complete_flag,@is_medical_start,@medical_start_date,CAST(@summary_date as timestamp),@is_audit,CAST(@audit_date as timestamp),@is_vip,@third_info,@remark,@medical_center_id," +
                        "@customer_org_register_id,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@audit_doctor_id::uuid,@summary_doctor_id::uuid,@his_patient_id,@third_register_id);",
                        new List<SugarParameter>() {
                            new SugarParameter("patient_register_id",patientRegisterEnt.Id),
                            new SugarParameter("patient_register_no",patientRegisterEnt.PatientRegisterNo),
                            new SugarParameter("patient_id",patientRegisterEnt.PatientId),
                            new SugarParameter("medical_times",newMedicalTimes),
                            new SugarParameter("customer_org_id",patientRegisterEnt.CustomerOrgId),
                            new SugarParameter("customer_org_group_id",patientRegisterEnt.CustomerOrgGroupId),
                            new SugarParameter("medical_package_id",patientRegisterEnt.MedicalPackageId),
                            new SugarParameter("patient_name",patientRegisterEnt.PatientName),
                            new SugarParameter("sex_id",patientRegisterEnt.SexId),
                            new SugarParameter("birth_date",patientRegisterEnt.BirthDate),
                            new SugarParameter("age",patientRegisterEnt.Age),
                            new SugarParameter("job_card_no",patientRegisterEnt.JobCardNo),
                            new SugarParameter("medical_card_no",patientRegisterEnt.MedicalCardNo),
                            new SugarParameter("marital_status_id",patientRegisterEnt.MaritalStatusId),
                            new SugarParameter("medical_type_id",patientRegisterEnt.MedicalTypeId),
                            new SugarParameter("personnel_type_id",patientRegisterEnt.PersonnelTypeId),
                            new SugarParameter("job_post",patientRegisterEnt.JobPost),
                            new SugarParameter("job_title",patientRegisterEnt.JobTitle),
                            new SugarParameter("photo",patientRegisterEnt.Photo),
                            new SugarParameter("sex_hormone_term_id",patientRegisterEnt.SexHormoneTermId),
                            new SugarParameter("interpose_measure",patientRegisterEnt.InterposeMeasure),
                            new SugarParameter("medical_conclusion_id",patientRegisterEnt.MedicalConclusionId),
                            new SugarParameter("complete_flag",patientRegisterEnt.CompleteFlag),
                            new SugarParameter("is_medical_start",patientRegisterEnt.IsMedicalStart),
                            new SugarParameter("medical_start_date",patientRegisterEnt.MedicalStartDate),
                            new SugarParameter("summary_date",patientRegisterEnt.SummaryDate),
                            new SugarParameter("is_audit",patientRegisterEnt.IsAudit),
                            new SugarParameter("audit_date",patientRegisterEnt.AuditDate),
                            new SugarParameter("is_vip",patientRegisterEnt.IsVip),
                            new SugarParameter("third_info",patientRegisterEnt.ThirdInfo),
                            new SugarParameter("remark",patientRegisterEnt.Remark),
                            new SugarParameter("medical_center_id",patientRegisterEnt.MedicalCenterId),
                            new SugarParameter("customer_org_register_id",patientRegisterEnt.CustomerOrgRegisterId),
                            new SugarParameter("concurrency_stamp",patientRegisterEnt.ConcurrencyStamp),
                           // new SugarParameter("creation_time",patientRegisterEnt.CreationTime),
                            new SugarParameter("creation_time",patientRegisterEnt.CreationTime),
                            new SugarParameter("creator_id",patientRegisterEnt.CreatorId),
                            new SugarParameter("last_modification_time",patientRegisterEnt.LastModificationTime),
                            new SugarParameter("last_modifier_id",patientRegisterEnt.LastModifierId),
                            new SugarParameter("audit_doctor_id",patientRegisterEnt.AuditDoctorId),
                            new SugarParameter("summary_doctor_id",patientRegisterEnt.SummaryDoctorId),
                            new SugarParameter("his_patient_id",patientRegisterEnt.HisPatientId),
                            new SugarParameter("third_register_id",third_register_id)
                      });

                    #endregion

                    #region 插入registercheck、以及相关

                    var registerCheckWithDetails = (await _registerCheckRepository.GetQueryableAsync())
                        .Include(x => x.RegisterCheckAsbitems)
                        .Include(x => x.RegisterCheckItems)
                        .Include(x => x.RegisterCheckPictures)
                        .Include(x => x.RegisterCheckSuggestions)
                        .Include(x => x.RegisterCheckSummaries)
                        .Where(m => m.PatientRegisterId == patientRegisterEnt.Id).ToList();


                    foreach (var registerCheckWithDetail in registerCheckWithDetails)
                    {
                        #region register_check
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check(register_check_id, patient_register_id, check_request_no, third_info, complete_flag, critical_value, critical_value_flag, critical_value_process_content," +
                                   "critical_value_process_flag, critical_value_process_doctor, critical_value_process_date, critical_value_create_date, check_doctor_id, check_date, is_audit," +
                                   " auditor_user_id, audit_time, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id, exec_organization_unit_id,is_pacs_check,pacs_check_date,pacs_upload_date) VALUES " +
                                   "(@register_check_id,@patient_register_id,@check_request_no,@third_info,@complete_flag,@critical_value,@critical_value_flag,@critical_value_process_content," +
                                   "@critical_value_process_flag,@critical_value_process_doctor,CAST(@critical_value_process_date as timestamp),CAST(@critical_value_create_date as timestamp),@check_doctor_id,CAST(@check_date as timestamp),@is_audit," +
                                   "@auditor_user_id::uuid,CAST(@audit_time as timestamp),@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@exec_organization_unit_id::uuid,@is_pacs_check,CAST(@pacs_check_date as timestamp),CAST(@pacs_upload_date as timestamp));",
                                   new List<SugarParameter>() {
                                       new SugarParameter("register_check_id",registerCheckWithDetail.Id),
                                       new SugarParameter("patient_register_id",registerCheckWithDetail.PatientRegisterId),
                                       new SugarParameter("check_request_no",registerCheckWithDetail.CheckRequestNo),
                                       new SugarParameter("third_info",registerCheckWithDetail.ThirdInfo),
                                       new SugarParameter("complete_flag",registerCheckWithDetail.CompleteFlag),
                                       new SugarParameter("critical_value",registerCheckWithDetail.CriticalRangeValue),
                                       new SugarParameter("critical_value_flag",registerCheckWithDetail.IsCriticalValue),
                                       new SugarParameter("critical_value_process_content",registerCheckWithDetail.CriticalValueContent),
                                       new SugarParameter("critical_value_process_flag",null),
                                       new SugarParameter("critical_value_process_doctor",""),
                                       new SugarParameter("critical_value_process_date",null),
                                       new SugarParameter("critical_value_create_date",null),
                                       new SugarParameter("check_doctor_id",registerCheckWithDetail.CheckDoctorId),
                                       new SugarParameter("check_date",registerCheckWithDetail.CheckDate),
                                       new SugarParameter("is_audit",registerCheckWithDetail.IsAudit),
                                       new SugarParameter("auditor_user_id",registerCheckWithDetail.AuditorUserId),
                                       new SugarParameter("audit_time",registerCheckWithDetail.AuditTime),
                                       new SugarParameter("concurrency_stamp",registerCheckWithDetail.ConcurrencyStamp),
                                       new SugarParameter("creation_time",registerCheckWithDetail.CreationTime),
                                       new SugarParameter("creator_id",registerCheckWithDetail.CreatorId),
                                       new SugarParameter("last_modification_time",registerCheckWithDetail.LastModificationTime),
                                       new SugarParameter("last_modifier_id",registerCheckWithDetail.LastModifierId),
                                       new SugarParameter("exec_organization_unit_id",registerCheckWithDetail.ExecOrganizationUnitId),
                                       new SugarParameter("is_pacs_check",registerCheckWithDetail.IsPacsCheck),
                                       new SugarParameter("pacs_check_date",registerCheckWithDetail.PacsCheckDate),
                                       new SugarParameter("pacs_upload_date",registerCheckWithDetail.PacsUploadDate)
                                 });
                        #endregion

                        #region register_check_asbitem

                        foreach (var registerCheckAsbitem in registerCheckWithDetail.RegisterCheckAsbitems)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check_asbitem" +
                                "(register_check_asbitem_id, register_check_id, asbitem_id, patient_register_id, standard_price, charge_price," +
                                 "pay_type_flag, is_charge, amount, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                 "(@register_check_asbitem_id,@register_check_id,@asbitem_id,@patient_register_id,@standard_price,@charge_price," +
                                 "@pay_type_flag,@is_charge,@amount,@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                 new List<SugarParameter>() {
                                     new SugarParameter("register_check_asbitem_id",registerCheckAsbitem.Id),
                                     new SugarParameter("register_check_id",registerCheckAsbitem.RegisterCheckId),
                                     new SugarParameter("asbitem_id",registerCheckAsbitem.AsbitemId),
                                     new SugarParameter("patient_register_id",registerCheckAsbitem.PatientRegisterId),
                                     new SugarParameter("standard_price",registerCheckAsbitem.StandardPrice),
                                     new SugarParameter("charge_price",registerCheckAsbitem.ChargePrice),
                                     new SugarParameter("pay_type_flag",registerCheckAsbitem.PayTypeFlag),
                                     new SugarParameter("is_charge",registerCheckAsbitem.IsCharge),
                                     new SugarParameter("amount",registerCheckAsbitem.Amount),
                                     new SugarParameter("concurrency_stamp",registerCheckAsbitem.ConcurrencyStamp),
                                     new SugarParameter("creation_time",registerCheckAsbitem.CreationTime),
                                     new SugarParameter("creator_id",registerCheckAsbitem.CreatorId),
                                     new SugarParameter("last_modification_time",registerCheckAsbitem.LastModificationTime),
                                     new SugarParameter("last_modifier_id",registerCheckAsbitem.LastModifierId),
                               });
                        }

                        #endregion

                        #region register_check_item

                        foreach (var registerCheckItem in registerCheckWithDetail.RegisterCheckItems)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check_item(register_check_id, item_id, result, unit, reference_range_value, critical_range_value, critical_value, result_status_id, check_doctor_name, " +
                                 "check_date, concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                 "(@register_check_id,@item_id,@result,@unit,@reference_range_value,@critical_range_value,@critical_value,@result_status_id,@check_doctor_name," +
                                 "CAST(@check_date as timestamp),@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                 new List<SugarParameter>() {
                                     new SugarParameter("register_check_id",registerCheckItem.RegisterCheckId),
                                     new SugarParameter("item_id",registerCheckItem.ItemId),
                                     new SugarParameter("result",registerCheckItem.Result),
                                     new SugarParameter("unit",registerCheckItem.Unit),
                                     new SugarParameter("reference_range_value",registerCheckItem.ReferenceRangeValue),
                                     new SugarParameter("critical_range_value",registerCheckItem.CriticalRangeValue),
                                     new SugarParameter("critical_value",registerCheckItem.CriticalValue),
                                     new SugarParameter("result_status_id",registerCheckItem.ResultStatusId),
                                     new SugarParameter("check_doctor_name",registerCheckItem.CheckDoctorName),
                                     new SugarParameter("check_date",registerCheckItem.CheckDate),
                                     new SugarParameter("concurrency_stamp",registerCheckItem.ConcurrencyStamp),
                                     new SugarParameter("creation_time",registerCheckItem.CreationTime),
                                     new SugarParameter("creator_id",registerCheckItem.CreatorId),
                                     new SugarParameter("last_modification_time",registerCheckItem.LastModificationTime),
                                     new SugarParameter("last_modifier_id",registerCheckItem.LastModifierId)
                               });
                        }

                        #endregion

                        #region register_check_picture

                        foreach (var registerCheckPicture in registerCheckWithDetail.RegisterCheckPictures)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check_picture" +
                                "(register_check_picture_id, register_check_id, picture_filename, is_print, display_order," +
                                 "concurrency_stamp, creation_time,creator_id, last_modification_time, last_modifier_id, picture_file_type) VALUES " +
                                 "(@register_check_picture_id,@register_check_id,@picture_filename,@is_print,@display_order," +
                                 "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id,@picture_file_type);",
                                 new List<SugarParameter>() {
                                     new SugarParameter("register_check_picture_id",registerCheckPicture.Id),
                                     new SugarParameter("register_check_id",registerCheckPicture.RegisterCheckId),
                                     new SugarParameter("picture_filename",registerCheckPicture.PictureFilename),
                                     new SugarParameter("is_print",registerCheckPicture.IsPrint),
                                     new SugarParameter("display_order",registerCheckPicture.DisplayOrder),
                                     new SugarParameter("concurrency_stamp",registerCheckPicture.ConcurrencyStamp),
                                     new SugarParameter("creation_time",registerCheckPicture.CreationTime),
                                     new SugarParameter("creator_id",registerCheckPicture.CreatorId),
                                     new SugarParameter("last_modification_time",registerCheckPicture.LastModificationTime),
                                     new SugarParameter("last_modifier_id",registerCheckPicture.LastModifierId),
                                     new SugarParameter("picture_file_type",registerCheckPicture.PictureFileType)
                               });
                        }

                        #endregion

                        #region register_check_suggestion

                        foreach (var registerCheckSuggestion in registerCheckWithDetail.RegisterCheckSuggestions)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check_suggestion" +
                                "(register_check_suggestion_id, register_check_id, suggestion, display_order," +
                                 "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                 "(@register_check_suggestion_id,@register_check_id,@suggestion,@display_order," +
                                 "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                 new List<SugarParameter>() {
                                     new SugarParameter("register_check_suggestion_id",registerCheckSuggestion.Id),
                                     new SugarParameter("register_check_id",registerCheckSuggestion.RegisterCheckId),
                                     new SugarParameter("suggestion",registerCheckSuggestion.Suggestion),
                                     new SugarParameter("display_order",registerCheckSuggestion.DisplayOrder),
                                     new SugarParameter("concurrency_stamp",registerCheckSuggestion.ConcurrencyStamp),
                                     new SugarParameter("creation_time",registerCheckSuggestion.CreationTime),
                                     new SugarParameter("creator_id",registerCheckSuggestion.CreatorId),
                                     new SugarParameter("last_modification_time",registerCheckSuggestion.LastModificationTime),
                                     new SugarParameter("last_modifier_id",registerCheckSuggestion.LastModifierId)
                               });
                        }

                        #endregion

                        #region register_check_summary

                        foreach (var registerCheckSummarie in registerCheckWithDetail.RegisterCheckSummaries)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.register_check_summary" +
                                "(register_check_summary_id, register_check_id, summary, display_order, summary_flag," +
                                 "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                 "(@register_check_summary_id,@register_check_id,@summary,@display_order,@summary_flag," +
                                 "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                 new List<SugarParameter>() {
                                     new SugarParameter("register_check_summary_id",registerCheckSummarie.Id),
                                     new SugarParameter("register_check_id",registerCheckSummarie.RegisterCheckId),
                                     new SugarParameter("summary",registerCheckSummarie.Summary),
                                     new SugarParameter("display_order",registerCheckSummarie.DisplayOrder),
                                     new SugarParameter("summary_flag",registerCheckSummarie.SummaryFlag),
                                     new SugarParameter("concurrency_stamp",registerCheckSummarie.ConcurrencyStamp),
                                     new SugarParameter("creation_time",registerCheckSummarie.CreationTime),
                                     new SugarParameter("creator_id",registerCheckSummarie.CreatorId),
                                     new SugarParameter("last_modification_time",registerCheckSummarie.LastModificationTime),
                                     new SugarParameter("last_modifier_id",registerCheckSummarie.LastModifierId),
                               });
                        }

                        #endregion
                    }

                    #endregion

                    #region 插入总检综述
                    foreach (var sumSummaryHeader in patientRegisterEnt.SumSummaryHeaders)
                    {
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.sum_summary_header" +
                               "(sum_summary_header_id, patient_register_id, summary_title, summary_flag, display_order," +
                                "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                "(@sum_summary_header_id,@patient_register_id,@summary_title,@summary_flag,@display_order," +
                                "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                new List<SugarParameter>() {
                                    new SugarParameter("sum_summary_header_id",sumSummaryHeader.Id),
                                    new SugarParameter("patient_register_id",sumSummaryHeader.PatientRegisterId),
                                    new SugarParameter("summary_title",sumSummaryHeader.SummaryTitle),
                                    new SugarParameter("summary_flag",sumSummaryHeader.SummaryFlag),
                                    new SugarParameter("display_order",sumSummaryHeader.DisplayOrder),
                                    new SugarParameter("concurrency_stamp",sumSummaryHeader.ConcurrencyStamp),
                                    new SugarParameter("creation_time",sumSummaryHeader.CreationTime),
                                    new SugarParameter("creator_id",sumSummaryHeader.CreatorId),
                                    new SugarParameter("last_modification_time",sumSummaryHeader.LastModificationTime),
                                    new SugarParameter("last_modifier_id",sumSummaryHeader.LastModifierId)
                              });

                        foreach (var sumSummaryContent in sumSummaryHeader.SumSummaryContents)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.sum_summary_content" +
                              "(sum_summary_content_id, sum_summary_header_id, summary_content, display_order, " +
                               "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                               "(@sum_summary_content_id,@sum_summary_header_id,@summary_content,@display_order," +
                               "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                               new List<SugarParameter>() {
                                   new SugarParameter("sum_summary_content_id",sumSummaryContent.Id),
                                   new SugarParameter("sum_summary_header_id",sumSummaryContent.SumSummaryHeaderId),
                                   new SugarParameter("summary_content",sumSummaryContent.SummaryContent),
                                   new SugarParameter("display_order",sumSummaryContent.DisplayOrder),
                                   new SugarParameter("concurrency_stamp",sumSummaryContent.ConcurrencyStamp),
                                   new SugarParameter("creation_time",sumSummaryContent.CreationTime),
                                   new SugarParameter("creator_id",sumSummaryContent.CreatorId),
                                   new SugarParameter("last_modification_time",sumSummaryContent.LastModificationTime),
                                   new SugarParameter("last_modifier_id",sumSummaryContent.LastModifierId)
                             });
                        }
                    }
                    #endregion

                    #region 插入总检建议
                    foreach (var sumSuggestionHeader in patientRegisterEnt.SumSuggestionHeaders)
                    {
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.sum_suggestion_header" +
                               "(sum_suggestion_header_id, patient_register_id, suggestion_title, suggestion_flag, display_order," +
                                "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                                "(@sum_suggestion_header_id,@patient_register_id,@suggestion_title,@suggestion_flag,@display_order," +
                                "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                                new List<SugarParameter>() {
                                    new SugarParameter("sum_suggestion_header_id",sumSuggestionHeader.Id),
                                    new SugarParameter("patient_register_id",sumSuggestionHeader.PatientRegisterId),
                                    new SugarParameter("suggestion_title",sumSuggestionHeader.SuggestionTitle),
                                    new SugarParameter("suggestion_flag",sumSuggestionHeader.SuggestionFlag),
                                    new SugarParameter("display_order",sumSuggestionHeader.DisplayOrder),
                                    new SugarParameter("concurrency_stamp",sumSuggestionHeader.ConcurrencyStamp),
                                    new SugarParameter("creation_time",sumSuggestionHeader.CreationTime),
                                    new SugarParameter("creator_id",sumSuggestionHeader.CreatorId),
                                    new SugarParameter("last_modification_time",sumSuggestionHeader.LastModificationTime),
                                    new SugarParameter("last_modifier_id",sumSuggestionHeader.LastModifierId)
                              });

                        foreach (var sumSuggestionContent in sumSuggestionHeader.SumSuggestionContents)
                        {
                            await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.sum_suggestion_content" +
                              "(sum_suggestion_content_id, sum_suggestion_header_id, suggestion_type, suggestion_content, display_order,  " +
                               "concurrency_stamp, creation_time, creator_id, last_modification_time, last_modifier_id) VALUES " +
                               "(@sum_suggestion_content_id,@sum_suggestion_header_id,@suggestion_type,@suggestion_content,@display_order, " +
                               "@concurrency_stamp,@creation_time,@creator_id,@last_modification_time,@last_modifier_id);",
                               new List<SugarParameter>() {
                                   new SugarParameter("sum_suggestion_content_id",sumSuggestionContent.Id),
                                   new SugarParameter("sum_suggestion_header_id",sumSuggestionContent.SumSuggestionHeaderId),
                                   new SugarParameter("suggestion_type",sumSuggestionContent.SuggestionType),
                                   new SugarParameter("suggestion_content",sumSuggestionContent.SuggestionContent),
                                   new SugarParameter("display_order",sumSuggestionContent.DisplayOrder),
                                   new SugarParameter("concurrency_stamp",sumSuggestionContent.ConcurrencyStamp),
                                   new SugarParameter("creation_time",sumSuggestionContent.CreationTime),
                                   new SugarParameter("creator_id",sumSuggestionContent.CreatorId),
                                   new SugarParameter("last_modification_time",sumSuggestionContent.LastModificationTime),
                                   new SugarParameter("last_modifier_id",sumSuggestionContent.LastModifierId)
                             });
                        }
                    }
                    #endregion

                    #region 插入总检诊断
                    foreach (var sumDiagnoses in patientRegisterEnt.SumDiagnoses)
                    {
                        await WebDb.Ado.ExecuteCommandAsync("INSERT INTO public.sum_diagnosis" +
                               "(patient_register_id, diagnosis_id, sum_suggestion_header_id, display_order, concurrency_stamp) VALUES " +
                                "(@patient_register_id,@diagnosis_id,@sum_suggestion_header_id,@display_order,@concurrency_stamp);",
                                new List<SugarParameter>() {
                                    new SugarParameter("patient_register_id",sumDiagnoses.PatientRegisterId),
                                    new SugarParameter("diagnosis_id",sumDiagnoses.DiagnosisId),
                                    new SugarParameter("sum_suggestion_header_id",sumDiagnoses.SumSuggestionHeaderId),
                                    new SugarParameter("display_order",sumDiagnoses.DisplayOrder),
                                    new SugarParameter("concurrency_stamp",sumDiagnoses.ConcurrencyStamp)
                              });
                    }
                    #endregion

                    if (patientRegisterEnt.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
                        patientRegisterEnt.IsUploadAppoint = 'Y';

                    await _patientRegisterRepository.UpdateAsync(patientRegisterEnt);
                }
                else
                {
                    throw new UserFriendlyException("数据不存在");
                }
                await WebDb.Ado.CommitTranAsync();
            }
            catch (Exception ex)
            {
                await WebDb.Ado.RollbackTranAsync();
                throw new UserFriendlyException(ex.ToString());
            }
        }

        #endregion

        #region 撤销、删除

        /// <summary>
        /// 人员导入
        /// </summary>
        /// <param name="WebDb"></param>
        /// <param name="PatientRegisterId"></param>
        /// <returns></returns>
        private async Task DeletePatientRegisterWithDetailAsync(SqlSugarClient WebDb, Guid PatientRegisterId)
        {
            try
            {
                await WebDb.Ado.BeginTranAsync();

                await WebDb.Ado.ExecuteCommandAsync($"delete from sum_diagnosis where patient_register_id='{PatientRegisterId}'");

                await WebDb.Ado.ExecuteCommandAsync($"delete from sum_summary_content where sum_summary_header_id in  (select sum_summary_header_id from sum_summary_header where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from sum_summary_header where  patient_register_id='{PatientRegisterId}'");


                await WebDb.Ado.ExecuteCommandAsync($"delete from sum_suggestion_content where sum_suggestion_header_id in  (select sum_suggestion_header_id from sum_suggestion_header where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from sum_suggestion_header where  patient_register_id='{PatientRegisterId}'");


                await WebDb.Ado.ExecuteCommandAsync($"delete from register_check_asbitem where register_check_id in  (select register_check_id from register_check where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from register_check_item where register_check_id in  (select register_check_id from register_check where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from register_check_picture where register_check_id in  (select register_check_id from register_check where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from register_check_suggestion where register_check_id in  (select register_check_id from register_check where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from register_check_summary where register_check_id in  (select register_check_id from register_check where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from  register_check where patient_register_id='{PatientRegisterId}'");

                await WebDb.Ado.ExecuteCommandAsync($"delete from  patient where patient_id in (select patient_id from patient_register  where patient_register_id='{PatientRegisterId}')");

                await WebDb.Ado.ExecuteCommandAsync($"delete from  patient_register where patient_register_id='{PatientRegisterId}'");


                await WebDb.Ado.CommitTranAsync();
            }
            catch (Exception ex)
            {
                await WebDb.Ado.RollbackTranAsync();
                throw new UserFriendlyException(ex.ToString());
            }
        }

        #endregion

        #region 临时导数据
        int sumCount = 0;
        int handCount = 0;

        /// <summary>
        /// 导入体检数据到web 全部导入 2024-06-06
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task ExportPatientRegisterWithDetailData()
        {
            var connectString = @"Host=10.1.12.138;Port=5432;Database=WebPeis0520;User ID=postgres;Password=st123;";

            SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = connectString,
                DbType = SqlSugar.DbType.PostgreSQL,
                IsAutoCloseConnection = true
            });


            string nextKeyValue = Db.Ado.GetString("select keyvalue from tb_export_key where tablename='patient_register_web' ");

            var patientRegisterIds = (await _patientRegisterRepository.GetQueryableAsync())
                 .Where(m => string.Compare(m.Id.ToString(), string.IsNullOrEmpty(nextKeyValue) ? "" : nextKeyValue) > 0).OrderBy(o => o.Id).Select(s => s.Id).Take(1000).ToList();


            if (patientRegisterIds.Any())
            {
                foreach (var patientRegisterId in patientRegisterIds)
                {
                    sumCount++;
                    using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                    {
                        var IsPatient = (await WebDb.Ado.GetDataTableAsync($"select patient_register_id from patient_register where patient_register_id='{patientRegisterId}'")).Rows.Count;
                        if (IsPatient == 0)
                        {
                            await TransPatientRegisterWithDetailAsync(WebDb, patientRegisterId);
                            handCount++;
                        }

                        nextKeyValue = patientRegisterId.ToString();
                    }

                    await Db.Ado.ExecuteCommandAsync($"update  tb_export_key set  keyvalue='{patientRegisterId}',addtime=getdate(),handlecount+=1 where tablename='patient_register_web' ");
                }
            }

            _logger.LogInformation($"当前查询数据:{sumCount},新增数据:{handCount}");

            if (patientRegisterIds.Any())
                await ExportPatientRegisterWithDetailData();
        }




        /// <summary>
        /// 反向导入 导入体检数据到web 全部导入 2024-06-07  
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task ExportPatientRegisterWithDetailReverseData()
        {
            //var connectString = @"Host=10.1.12.138;Port=5432;Database=WebPeis0520;User ID=postgres;Password=st123;";
            var connectString = @"Host=62.156.10.86;Port=5432;Database=WebPeis0520;User ID=postgres;Password=st123;";

            SqlSugarClient WebDb = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = connectString,
                DbType = SqlSugar.DbType.PostgreSQL,
                IsAutoCloseConnection = true
            });


            string nextKeyValue = Db.Ado.GetString("select keyvalue from tb_export_key where tablename='patient_register_web_reverse' ");

            var patientRegisterIds = (await _patientRegisterRepository.GetQueryableAsync())
                 .Where(m => string.Compare(string.IsNullOrEmpty(nextKeyValue) ? "" : nextKeyValue, m.Id.ToString()) > 0).OrderByDescending(o => o.Id).Select(s => s.Id).Take(1000).ToList();

            if (patientRegisterIds.Any())
            {
                foreach (var patientRegisterId in patientRegisterIds)
                {
                    sumCount++;
                    using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                    {
                        var IsPatient = (await WebDb.Ado.GetDataTableAsync($"select patient_register_id from patient_register where patient_register_id='{patientRegisterId}'")).Rows.Count;
                        if (IsPatient == 0)
                        {
                            await TransPatientRegisterWithDetailAsync(WebDb, patientRegisterId);
                            handCount++;
                        }

                        nextKeyValue = patientRegisterId.ToString();
                    }

                    await Db.Ado.ExecuteCommandAsync($"update  tb_export_key set  keyvalue='{patientRegisterId}',addtime=getdate(),handlecount+=1 where tablename='patient_register_web_reverse' ");
                }
            }

            _logger.LogInformation($"当前降序查询数据:{sumCount},新增数据:{handCount}");

            if (patientRegisterIds.Any())
                await ExportPatientRegisterWithDetailReverseData();
        }
        #endregion

        #region 临时导报告

        /// <summary>
        /// 临时导入2024年报告
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TempExportReportAsync()
        {

            var patientRegisterIds = (await _patientRegisterRepository.GetQueryableAsync())
                .Where(m => m.CompleteFlag == PatientRegisterCompleteFlag.SumCheck
                && m.SummaryDate > Convert.ToDateTime("2024-01-01 00:00:00"))
                .OrderBy(o => o.SummaryDate)
                .Select(s => s.Id).ToList();

            foreach (var item in patientRegisterIds)
            {
                using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                {
                    var isUploadReport = WebDb0520.Ado.GetDataTable($"select patient_register_id,report_file from patient_register where patient_register_id='{item}' and report_file is null ").Rows.Count;
                    if (isUploadReport == 1)
                    {
                        await SyncPatientRegisterReportByPatientRegisterIdAsync(new PatientRegisterIdInputDto
                        {
                            PatientRegisterId = item
                        });
                    }

                    await uow.CompleteAsync();
                }
            }


        }

        #endregion

        /// <summary>
        /// 测试短信
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/TestSms")]
        public async Task TestSmsAsync(Guid patientRegisterId)
        {
            //推送短信

            var patientRegister = await _patientRegisterRepository.FirstOrDefaultAsync(f => f.Id == patientRegisterId);

            await PushSmsAsync(patientRegister);



        }

        /// <summary>
        /// 推送体检报告通知短信
        /// </summary>
        /// <param name="patientRegister"></param>
        /// <returns></returns>
        private async Task PushSmsAsync(PatientRegister patientRegister)
        {
            var smsThirdInterface = await _thirdInterfaceRepository.FirstOrDefaultAsync(o => o.ThirdInterfaceType ==
           ThirdInterfaceTypeFlag.SmsPush);
            if (smsThirdInterface != null && smsThirdInterface.IsActive == 'Y')
            {

                var parmValue = smsThirdInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                     .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var interfaceConfig = configurationBuilder.Build();
                var pushApiAddress = interfaceConfig.GetSection("Interface").GetSection("PushApiAddress").Value;
                var isEnableSms = interfaceConfig.GetSection("Interface").GetSection("IsActive").Value;
                var noticeTemplateId = interfaceConfig.GetSection("Interface").GetSection("NoticeTemplateId").Value;
                if (!string.IsNullOrWhiteSpace(isEnableSms)
                    && !string.IsNullOrWhiteSpace(noticeTemplateId)
                    && isEnableSms == "Y")
                {
                    SmsPlugIns smsPlugIns = new SmsPlugIns(smsThirdInterface.Id);
                    var smsAppId = Guid.Parse(interfaceConfig.GetSection("Interface").GetSection("SmsAppId").Value);
                    var smsTypeId = Guid.Parse(interfaceConfig.GetSection("Interface").GetSection("SmsTypeId").Value);
                    var patientEnt = await _patientRepository.FirstOrDefaultAsync(f => f.Id == patientRegister.PatientId);
                    if (patientEnt != null)
                    {
                        var inputDto = new CreateSmsTaskDto
                        {
                            SmsAppId = smsAppId,
                            SmsTypeId = smsTypeId,
                            Content = "",
                            CountryCode = "86",
                            MobileTelephone = patientEnt.MobileTelephone,
                            PersonId = patientRegister.PatientId.ToString(),
                            PersonName = patientRegister.PatientName,
                            SenderId = "admin",
                            SenderName = "体检",
                            StopTime = "",
                            TaskCorn = "",
                            TaskCycleType = '0',
                            TemplateId = noticeTemplateId,
                            ThirdId = patientRegister.Id.ToString()

                        };

                        await smsPlugIns.CallSmsAppServiceAsync<CreateSmsTaskDto, Task>(pushApiAddress, inputDto);
                    }
                }
            }
        }


        #region 临时处理青藏公司用户id关系


        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/SyncPatientRegisterQZTLUserId")]
        public async Task SyncPatientRegisterQZTLUserIdAsync(SyncPatientRegisterQZTLUserIdInputDto input)
        {
            if (input.PatientRegisterNos.Any())
            {


                SqlSugarClient peisTemp = new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = "Host=10.1.12.140;Port=5432;Database=ShentunPeis0508;User ID=postgres;Password=st123;",
                    DbType = SqlSugar.DbType.PostgreSQL,
                    IsAutoCloseConnection = true
                });

                //SqlSugarClient peisTempOld = new SqlSugarClient(new ConnectionConfig()
                //{
                //    ConnectionString = "server=10.1.12.139;uid=sa;pwd=VMware6.0u2;database=mypeis;Encrypt=false;",
                //    DbType = SqlSugar.DbType.SqlServer,
                //    IsAutoCloseConnection = true
                //});


                List<QztlPatientRegisterFromInterfacePlan> oldList = new List<QztlPatientRegisterFromInterfacePlan>();

                var qztlDataList = await peisTemp.Ado.GetDataTableAsync($"select data from public.qztl_import_data  ");

                //组合参数
                foreach (DataRow item in qztlDataList.Rows)
                {
                    if (!string.IsNullOrWhiteSpace(item["data"].ToString()))
                    {
                        var oldData = JsonConvert.DeserializeObject<QztlPatientRegisterFromInterface>(item["data"].ToString());

                        if (oldData != null && oldData.errorMsg == "OK")
                        {

                            oldList.AddRange(oldData.plans);
                        }
                    }
                }




                //#region sqlserver  数据
                //var qztlDataOldList = await peisTempOld.Ado.GetDataTableAsync($"select data from qztl_import_data where create_date>'2023-01-01' ");

                ////组合参数
                //foreach (DataRow item in qztlDataOldList.Rows)
                //{


                //    if (!string.IsNullOrWhiteSpace(item["data"].ToString()))
                //    {
                //        string oldstr = item["data"].ToString().Replace("\"[", "[").Replace("]\"", "]").Replace("\\","");
                //        var oldData = JsonConvert.DeserializeObject<QztlPatientRegisterFromInterface>(oldstr);

                //        if (oldData != null && oldData.errorMsg == "OK")
                //        {

                //            oldList.AddRange(oldData.plans.Where(m => m.year == 2024).ToList());
                //        }
                //    }
                //}
                //#endregion


                foreach (var patientRegisterNo in input.PatientRegisterNos)
                {
                    var patientRegisterList = await peisTemp.Ado.GetDataTableAsync($"select a.id,a.patient_name,b.id_no from public.patient_register as a " +
                        $"left join patient as b on a.patient_id=b.id where patient_register_no='{patientRegisterNo}'  ");

                    if (patientRegisterList.Rows.Count > 0)
                    {
                        string patientName = patientRegisterList.Rows[0]["patient_name"].ToString();
                        string idNo = patientRegisterList.Rows[0]["id_no"].ToString();
                        Guid patientRegisterId = Guid.Parse(patientRegisterList.Rows[0]["id"].ToString());

                        var isDT = oldList.Where(f => f.personName.Trim() == patientName.Trim()
                        && f.cardId.Trim().ToUpper() == idNo.Trim().ToUpper()
                        && f.year == 2024).Select(s => s.id).Distinct().ToList();

                        //if (isDT.Count == 0)
                        //{
                        //    var idNos = oldList.Where(f => f.personName.Trim() == patientName.Trim() && f.year == 2024).Select(s => s.cardId).Distinct().ToList();
                        //    _logger.LogInformation($"未找到数据：条码号=>{patientRegisterNo},姓名=>{patientName},体检系统身份证=>{idNo},青藏公司导入身份证=>{string.Join(",", idNos)}");
                        //    continue;
                        //}

                        //if (isDT.Count > 1)
                        //{
                        //    _logger.LogInformation($"存在多条数据：条码号=>{patientRegisterNo},姓名=>{patientName},身份证=>{idNo}");
                        //    continue;
                        //}

                        if (isDT.Count == 1)
                        {

                            await peisTemp.Ado.ExecuteCommandAsync("update patient_register_exter set planuserid=@planuserid where patient_register_id=@patient_register_id ;",
                          new List<SugarParameter>() {
                                    new SugarParameter("planuserid",isDT.First().ToString()),
                                    new SugarParameter("patient_register_id",patientRegisterId)

                        });
                            _logger.LogInformation($"青藏公司数据处理：条码号=>{patientRegisterNo},姓名=>{patientName},身份证=>{idNo},更新青藏铁路用户id=>{isDT.First()}");
                        }


                        // _logger.LogInformation($"青藏公司数据处理：条码号=>{patientRegisterNo},姓名=>{patientName},身份证=>{idNo},更新青藏铁路用户id=>{isDT.First()}");


                    }

                }
            }
        }


        #endregion
    }
}