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;

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;

        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)
        {
            _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;
        }
        /// <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
                });


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




            //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>
        /// <returns></returns>
        [HttpPost("api/app/TransToWebPeis/UploadPeisReport")]
        public async Task UploadPeisReportAsync(UploadPeisReportIuputDto input)
        {
            //同步数据
            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, WebApiOutDto>(url, "", input);

            }

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


        /// <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="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 string GetUrl(string 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;

            return url;
        }
        public 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<TOut>(result);
                        if (resultDto is WebApiOutDtoBase)
                        {
                            var webApiOutDtoBase = resultDto as WebApiOutDtoBase;
                            if (webApiOutDtoBase.Code == "-1")
                            {
                                throw new Exception($"调用服务失败{webApiOutDtoBase.Message}");
                            }
                        }
                        return resultDto;
                    }

                }
            }
        }



        #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) 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)",
                              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)
                          });

                    //插入明细

                    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) 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)",
                              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)
                          });

                    //插入明细

                    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) " +
                          "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);",
                              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)
                          });
                }

                _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, display_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) " +
                          "VALUES (@customer_org_group_id,@display_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);",
                              new List<SugarParameter>() {
                                  new SugarParameter("customer_org_group_id",customerOrgGroup.Id),
                                  new SugarParameter("display_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)
                          });
                }

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

                    #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,@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",patientRegisterEnt.MedicalTimes),
                            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",DateTime.Now),
                            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) 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);",
                                   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.CriticalValue),
                                       new SugarParameter("critical_value_flag",registerCheckWithDetail.CriticalValueFlag),
                                       new SugarParameter("critical_value_process_content",registerCheckWithDetail.CriticalValueProcessContent),
                                       new SugarParameter("critical_value_process_flag",registerCheckWithDetail.CriticalValueProcessFlag),
                                       new SugarParameter("critical_value_process_doctor",registerCheckWithDetail.CriticalValueProcessDoctor),
                                       new SugarParameter("critical_value_process_date",registerCheckWithDetail.CriticalValueProcessDate),
                                       new SugarParameter("critical_value_create_date",registerCheckWithDetail.CriticalValueCreateDate),
                                       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),
                                 });
                        #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
                }
                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_register where patient_register_id='{PatientRegisterId}'");


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

        #endregion
    }
}