peis/src/Shentun.Peis.Application/CCTJExportDatas/CCTJExportDataAppService.cs

using EFCore.BulkExtensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using NPOI.POIFS.Properties;
using NPOI.SS.Formula.Functions;
using Shentun.Peis.ColumnReferences;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.DataMigrations;
using Shentun.Peis.EntityFrameworkCore;
using Shentun.Peis.Enums;
using Shentun.Peis.ItemTypes;
using Shentun.Peis.Migrations;
using Shentun.Peis.Models;
using Shentun.Peis.MyUser;
using Shentun.Peis.OrganizationUnits;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Utilities;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Formats.Asn1;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Caching;
using Volo.Abp.Data;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.Identity;
using Volo.Abp.Uow;
using Volo.Abp.Users;
using static System.Formats.Asn1.AsnWriter;

namespace Shentun.Peis.CCTJExportDatas
{
    /// <summary>
    /// 长城体检中心数据导入
    /// </summary>
    [Authorize]
    public class CCTJExportDataAppService : ApplicationService
    {
        //默认指引类别ID
        private readonly char defaultGuidTypeId = '0';
        //默认体检报告类别ID
        private readonly char defaultMedicalReportTypeId = '0';
        //默认体检结论类别
        private readonly string defaultMedicalConclusionType = "01";
        //默认体检中心
        private readonly Guid defaultMedicalCenterId = Guid.Parse("8beda924-3925-4525-be49-d28bbb3618c4");
        //默认容器ID
        private readonly Guid defaultSampleContainerId = Guid.Parse("3a126a07-eb42-a369-99e4-114a2629d714");
        //默认单位性质ID
        private readonly Guid defaultOrgTypeId = Guid.Parse("3a126a08-9607-fe40-e5da-6daa01712468");

        //老系统数据库配置
        private readonly SqlSugarClient oldDb = new SqlSugarClient(new ConnectionConfig()
        {
            // ConnectionString = "server=192.168.0.3;uid=sa;pwd=132****6302;database=oldPeis;Encrypt=false;",
            ConnectionString = "server=192.168.0.3;uid=sa;pwd=132****6302;database=reddolphin;Encrypt=false;",
            DbType = SqlSugar.DbType.SqlServer,
            IsAutoCloseConnection = true
        });


        //lis数据库配置
        private readonly SqlSugarClient oldLisDb = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "server=192.168.0.3;uid=sa;pwd=132****6302;database=mylis;Encrypt=false;",
            DbType = SqlSugar.DbType.SqlServer,
            IsAutoCloseConnection = true
        });

        //新系统配置
        private readonly SqlSugarClient newDb = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "Host=192.168.0.188;Port=5432;Database=ShentunPeis;User ID=postgres;Password=St123456;",
            DbType = SqlSugar.DbType.PostgreSQL,
            IsAutoCloseConnection = true
        });
        private readonly IDbContextProvider<PeisDbContext> _dbContextProvider;
        private readonly UnitOfWorkManager _unitOfWorkManager;
        private readonly IRepository<DeviceType, Guid> _deviceTypeRepository;
        private readonly IRepository<ItemType, Guid> _itemTypeRepository;
        private readonly ItemTypeManager _itemTypeManager;
        private readonly IRepository<Unit, Guid> _unitRepository;
        private readonly IRepository<MedicalType, Guid> _medicalTypeRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;
        private readonly IRepository<InvoiceItemType, Guid> _invoiceItemTypeRepository;
        private readonly IRepository<FieldComparison, Guid> _fieldComparisonRepository;
        private readonly IRepository<SampleType, Guid> _sampleTypeRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<ReferenceRange, Guid> _referenceRangeRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IRepository<AsbitemDetail> _asbitemDetailRepository;
        private readonly IRepository<MedicalPackage, Guid> _medicalPackageRepository;
        private readonly IRepository<MedicalPackageDetail> _medicalPackageDetailRepository;
        private readonly IRepository<Diagnosis, Guid> _diagnosisRepository;
        private readonly IRepository<Suggestion, Guid> _suggestionRepository;
        private readonly IRepository<ItemResultTemplate, Guid> _itemResultTemplateRepository;
        private readonly IRepository<ItemResultMatch, Guid> _ItemResultMatchRepository;
        private readonly IRepository<MenuInfo, Guid> _menuInfoRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly CustomerOrgManager _customerOrgManager;
        private readonly IRepository<CustomerOrgRegister, Guid> _customerOrgRegisterRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<CustomerOrgGroupDetail> _customerOrgGroupDetailRepository;
        private readonly IRepository<Nation> _nationRepository;
        private readonly ILogger<BaseDataHandleAppService> _logger;
        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
        private readonly IRepository<MedicalConclusion, Guid> _medicalConclusionRepository;
        private readonly IRepository<SampleGroup, Guid> _sampleGroupRepository;
        private readonly IRepository<SampleGroupDetail> _sampleGroupDetailRepository;
        private readonly IRepository<SysParmType> _sysParmTypeRepository;
        private readonly IRepository<SysParm> _sysParmRepository;
        private readonly IRepository<SysParmValue> _sysParmValueRepository;
        private readonly IRepository<CollectItemType, Guid> _collectItemTypeRepository;
        private readonly IRepository<AsbitemGuide> _asbitemGuideRepository;
        //业务
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<RegisterCheckSummary, Guid> _registerCheckSummaryRepository;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly IRepository<SumSuggestionHeader, Guid> _sumSuggestionHeaderRepository;
        private readonly IRepository<SumSuggestionContent, Guid> _sumSuggestionContentRepository;
        private readonly IRepository<SumSummaryHeader, Guid> _sumSummaryHeaderRepository;
        private readonly IRepository<SumSummaryContent, Guid> _sumSummaryContentRepository;
        private readonly IRepository<SumDiagnosis> _sumDiagnosisRepository;
        private readonly IConfiguration _configuration;
        private readonly MyUserAppService _myUserAppService;
        private readonly ColumnReferenceAppService _columnReferenceAppService;
        private readonly IRepository<CardType, Guid> _cardTypeRepository;
        private readonly IRepository<CardRegister, Guid> _cardRegisterRepository;
        private readonly IServiceScopeFactory _serviceScopeFactory;
        private readonly ICurrentUser _currentUser;
        private static List<FieldComparison> fieldComparisonTempList = new List<FieldComparison>();
        private static List<FieldComparison> asbitemFieldComparisonTempList = new List<FieldComparison>();
        private static List<FieldComparison> itemFieldComparisonTempList = new List<FieldComparison>();
        private static List<CustomerOrgRegister> _customerOrgRegisterList = new List<CustomerOrgRegister>();
        private static List<IdentityUser> _userList = new List<IdentityUser>();


        private readonly IRepository<GuideType, char> _guideTypeRepository;
        private readonly IRepository<MedicalReportType, char> _medicalReportTypeRepository;
        private readonly IRepository<MedicalConclusionType> _medicalConclusionTypeRepository;
        private readonly IRepository<SampleContainer, Guid> _sampleContainerRepository;
        private readonly IRepository<CustomerOrgType, Guid> _customerOrgTypeRepository;
        private readonly IRepository<OrganizationUnit, Guid> _organizationUnitRepository;
        private readonly PeisOrganizationUnitManager _organizationUnitManager;
        private readonly IRepository<Sex> _sexRepository;
        private readonly IRepository<ForSex> _forSexRepository;
        private readonly IRepository<MaritalStatus> _maritalStatusRepository;
        private readonly IRepository<ResultStatus> _resultStatusRepository;
        private readonly IRepository<PayMode> _payModeRepository;
        private readonly IRepository<DiagnosisLevel, short> _diagnosisLevelRepository;
        private readonly IdentityUserManager _identityUserManager;
        private readonly IRepository<IdentityUserOrganizationUnit> _identityUserOrganizationUnitRepository;
        private readonly IRepository<CommonTable, Guid> _commonTableRepository;
        private readonly IRepository<Room, Guid> _roomRepository;
        private readonly IRepository<RoomDetail> _roomDetailRepository;
        private readonly IRepository<UserItemType> _userItemTypeRepository;
        public CCTJExportDataAppService(
            UnitOfWorkManager unitOfWorkManager,
            IRepository<DeviceType, Guid> deviceTypeRepository,
            IRepository<ItemType, Guid> itemTypeRepository,
            ItemTypeManager itemTypeManager,
            IRepository<Unit, Guid> unitRepository,
            IRepository<MedicalType, Guid> medicalTypeRepository,
            IRepository<PersonnelType, Guid> personnelTypeRepository,
            IRepository<InvoiceItemType, Guid> invoiceItemTypeRepository,
            IRepository<FieldComparison, Guid> fieldComparisonRepository,
            IRepository<SampleType, Guid> sampleTypeRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<ReferenceRange, Guid> referenceRangeRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<AsbitemDetail> asbitemDetailRepository,
            IRepository<MedicalPackage, Guid> medicalPackageRepository,
            IRepository<MedicalPackageDetail> medicalPackageDetailRepository,
            IRepository<Diagnosis, Guid> diagnosisRepository,
            IRepository<Suggestion, Guid> suggestionRepository,
            IRepository<ItemResultTemplate, Guid> itemResultTemplateRepository,
            IRepository<ItemResultMatch, Guid> itemResultMatchRepository,
            IRepository<MenuInfo, Guid> menuInfoRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            CustomerOrgManager customerOrgManager,
            IRepository<CustomerOrgRegister, Guid> customerOrgRegisterRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<CustomerOrgGroupDetail> customerOrgGroupDetailRepository,
            IRepository<Nation> nationRepository,
            ILogger<BaseDataHandleAppService> logger,
            IRepository<IdentityUser, Guid> identityUserRepository,
            IRepository<MedicalConclusion, Guid> medicalConclusionRepository,
            IRepository<SampleGroup, Guid> sampleGroupRepository,
            IRepository<SampleGroupDetail> sampleGroupDetailRepository,
            IRepository<SysParmType> sysParmTypeRepository,
            IRepository<SysParm> sysParmRepository,
            IRepository<SysParmValue> sysParmValueRepository,
            IRepository<CollectItemType, Guid> collectItemTypeRepository,
            IRepository<AsbitemGuide> asbitemGuideRepository,
            IRepository<Patient, Guid> patientRepository,
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerCheckAsbitemRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            IRepository<RegisterCheckSummary, Guid> registerCheckSummaryRepository,
            RegisterCheckItemManager registerCheckItemManager,
            IRepository<SumSuggestionHeader, Guid> sumSuggestionHeaderRepository,
            IRepository<SumSuggestionContent, Guid> sumSuggestionContentRepository,
            IRepository<SumSummaryHeader, Guid> sumSummaryHeaderRepository,
            IRepository<SumSummaryContent, Guid> sumSummaryContentRepository,
            IRepository<SumDiagnosis> sumDiagnosisRepository,
            IConfiguration configuration,
            MyUserAppService myUserAppService,
            ColumnReferenceAppService columnReferenceAppService,
            IRepository<CardType, Guid> cardTypeRepository,
            IRepository<CardRegister, Guid> cardRegisterRepository,
            IServiceScopeFactory serviceScopeFactory,
            IDbContextProvider<PeisDbContext> dbContextProvider,
            ICurrentUser currentUser,
            IRepository<GuideType, char> guideTypeRepository,
            IRepository<MedicalReportType, char> medicalReportTypeRepository,
            IRepository<MedicalConclusionType> medicalConclusionTypeRepository,
            IRepository<SampleContainer, Guid> sampleContainerRepository,
            IRepository<CustomerOrgType, Guid> customerOrgTypeRepository,
            IRepository<OrganizationUnit, Guid> organizationUnitRepository,
            PeisOrganizationUnitManager organizationUnitManager,
            IRepository<Sex> sexRepository,
            IRepository<ForSex> forSexRepository,
            IRepository<MaritalStatus> maritalStatusRepository,
            IRepository<ResultStatus> resultStatusRepository,
            IRepository<PayMode> payModeRepository,
            IRepository<DiagnosisLevel, short> diagnosisLevelRepository,
            IdentityUserManager identityUserManager,
            IRepository<IdentityUserOrganizationUnit> identityUserOrganizationUnitRepository,
            IRepository<CommonTable, Guid> commonTableRepository,
            IRepository<Room, Guid> roomRepository,
            IRepository<RoomDetail> roomDetailRepository,
            IRepository<UserItemType> userItemTypeRepository)
        {
            _unitOfWorkManager = unitOfWorkManager;
            _deviceTypeRepository = deviceTypeRepository;
            _itemTypeRepository = itemTypeRepository;
            _itemTypeManager = itemTypeManager;
            _unitRepository = unitRepository;
            _medicalTypeRepository = medicalTypeRepository;
            _personnelTypeRepository = personnelTypeRepository;
            _invoiceItemTypeRepository = invoiceItemTypeRepository;
            _fieldComparisonRepository = fieldComparisonRepository;
            _sampleTypeRepository = sampleTypeRepository;
            _itemRepository = itemRepository;
            _referenceRangeRepository = referenceRangeRepository;
            _asbitemRepository = asbitemRepository;
            _asbitemDetailRepository = asbitemDetailRepository;
            _medicalPackageRepository = medicalPackageRepository;
            _medicalPackageDetailRepository = medicalPackageDetailRepository;
            _diagnosisRepository = diagnosisRepository;
            _suggestionRepository = suggestionRepository;
            _itemResultTemplateRepository = itemResultTemplateRepository;
            _ItemResultMatchRepository = itemResultMatchRepository;
            _menuInfoRepository = menuInfoRepository;
            _customerOrgRepository = customerOrgRepository;
            _customerOrgManager = customerOrgManager;
            _customerOrgRegisterRepository = customerOrgRegisterRepository;
            _customerOrgGroupRepository = customerOrgGroupRepository;
            _customerOrgGroupDetailRepository = customerOrgGroupDetailRepository;
            _nationRepository = nationRepository;
            _logger = logger;
            _identityUserRepository = identityUserRepository;
            _medicalConclusionRepository = medicalConclusionRepository;
            _sampleGroupRepository = sampleGroupRepository;
            _sampleGroupDetailRepository = sampleGroupDetailRepository;
            _sysParmTypeRepository = sysParmTypeRepository;
            _sysParmRepository = sysParmRepository;
            _sysParmValueRepository = sysParmValueRepository;
            _collectItemTypeRepository = collectItemTypeRepository;
            _asbitemGuideRepository = asbitemGuideRepository;
            _patientRepository = patientRepository;
            _patientRegisterRepository = patientRegisterRepository;
            _registerCheckRepository = registerCheckRepository;
            _registerCheckAsbitemRepository = registerCheckAsbitemRepository;
            _registerCheckItemRepository = registerCheckItemRepository;
            _registerCheckSummaryRepository = registerCheckSummaryRepository;
            _registerCheckItemManager = registerCheckItemManager;
            _sumSuggestionHeaderRepository = sumSuggestionHeaderRepository;
            _sumSuggestionContentRepository = sumSuggestionContentRepository;
            _sumSummaryHeaderRepository = sumSummaryHeaderRepository;
            _sumSummaryContentRepository = sumSummaryContentRepository;
            _sumDiagnosisRepository = sumDiagnosisRepository;
            _configuration = configuration;
            _myUserAppService = myUserAppService;
            _columnReferenceAppService = columnReferenceAppService;
            _cardTypeRepository = cardTypeRepository;
            _cardRegisterRepository = cardRegisterRepository;
            _serviceScopeFactory = serviceScopeFactory;
            _dbContextProvider = dbContextProvider;
            _currentUser = currentUser;
            _guideTypeRepository = guideTypeRepository;
            _medicalReportTypeRepository = medicalReportTypeRepository;
            _medicalConclusionTypeRepository = medicalConclusionTypeRepository;
            _sampleContainerRepository = sampleContainerRepository;
            _customerOrgTypeRepository = customerOrgTypeRepository;
            _organizationUnitRepository = organizationUnitRepository;
            _organizationUnitManager = organizationUnitManager;
            _sexRepository = sexRepository;
            _forSexRepository = forSexRepository;
            _maritalStatusRepository = maritalStatusRepository;
            _resultStatusRepository = resultStatusRepository;
            _payModeRepository = payModeRepository;
            _diagnosisLevelRepository = diagnosisLevelRepository;
            _identityUserManager = identityUserManager;
            _identityUserOrganizationUnitRepository = identityUserOrganizationUnitRepository;
            _commonTableRepository = commonTableRepository;
            _roomRepository = roomRepository;
            _roomDetailRepository = roomDetailRepository;
            _userItemTypeRepository = userItemTypeRepository;
        }




        /// <summary>
        /// 默认数据处理
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/CCTJExportData/HandDefaultData")]
        public async Task HandDefaultData()
        {
            #region 默认指引类别
            var isDefaultGuidType = await _guideTypeRepository.FirstOrDefaultAsync(f => f.Id == defaultGuidTypeId);
            if (isDefaultGuidType == null)
            {
                List<GuideType> guideTypes = new List<GuideType>();

                guideTypes.Add(new GuideType(defaultGuidTypeId)
                {
                    DisplayName = "普通检查",
                    SimpleCode = "PTJC",
                    DisplayOrder = 1
                });
                guideTypes.Add(new GuideType('1')
                {
                    DisplayName = "检验",
                    SimpleCode = "JY",
                    DisplayOrder = 2
                });
                guideTypes.Add(new GuideType('2')
                {
                    DisplayName = "特检",
                    SimpleCode = "TJ",
                    DisplayOrder = 3
                });
                guideTypes.Add(new GuideType('3')
                {
                    DisplayName = "放射",
                    SimpleCode = "FS",
                    DisplayOrder = 4
                });

                await _guideTypeRepository.InsertManyAsync(guideTypes);
            }
            #endregion

            #region 默认体检报告类别
            var isDefaultMedicalReportType = await _medicalReportTypeRepository.FirstOrDefaultAsync(f => f.Id == defaultMedicalReportTypeId);
            if (isDefaultMedicalReportType == null)
            {
                List<MedicalReportType> medicalReportTypes = new List<MedicalReportType>();
                medicalReportTypes.Add(new MedicalReportType(defaultMedicalReportTypeId)
                {
                    DisplayName = "普通检查",
                    SimpleCode = "PTJC",
                    DisplayOrder = 1
                });
                medicalReportTypes.Add(new MedicalReportType('1')
                {
                    DisplayName = "检验",
                    SimpleCode = "JY",
                    DisplayOrder = 2
                });
                medicalReportTypes.Add(new MedicalReportType('2')
                {
                    DisplayName = "特检",
                    SimpleCode = "TJ",
                    DisplayOrder = 3
                });
                medicalReportTypes.Add(new MedicalReportType('3')
                {
                    DisplayName = "放射",
                    SimpleCode = "FS",
                    DisplayOrder = 4
                });

                await _medicalReportTypeRepository.InsertManyAsync(medicalReportTypes);
            }
            #endregion

            #region 默认体检结论类别
            var isDefaultMedicalConclusionType = await _medicalConclusionTypeRepository.FirstOrDefaultAsync(f => f.Id == defaultMedicalConclusionType);
            if (isDefaultMedicalConclusionType == null)
            {
                var defaultEnt = new MedicalConclusionType
                {
                    Id = defaultMedicalConclusionType,
                    DisplayName = "社会体检",
                    DisplayOrder = 1
                };

                await _medicalConclusionTypeRepository.InsertAsync(defaultEnt);
            }
            #endregion

            #region 默认体检中心
            var isDefaultMedicalCenter = await _organizationUnitRepository.FirstOrDefaultAsync(f => f.Id == defaultMedicalCenterId);
            if (isDefaultMedicalCenter == null)
            {
                OrganizationUnit defaultEnt = new OrganizationUnit(defaultMedicalCenterId, "石家庄长城体检中心", null);
                defaultEnt.SetProperty("IsPeis", 'Y');

                await _organizationUnitManager.CreateAsync(defaultEnt);
            }
            #endregion

            #region 默认容器
            var isDefaultSampleContainer = await _sampleContainerRepository.FirstOrDefaultAsync(f => f.Id == defaultSampleContainerId);
            if (isDefaultSampleContainer == null)
            {
                var defaultEnt = new SampleContainer(defaultSampleContainerId)
                {
                    DisplayName = "管子",
                    SimpleCode = "GZ",
                    DisplayOrder = 1,
                    ContainerColor = 16711680,
                    ContainerColorName = "其它",
                    ContainerRemark = ""
                };

                await _sampleContainerRepository.InsertAsync(defaultEnt);
            }
            //var isDefaultSampleContainer = await _sampleContainerRepository.CountAsync();
            //if (isDefaultSampleContainer == 0)
            //{
            //    List<SampleContainer> sampleContainers = new List<SampleContainer>();

            //    var oldSpecimenTypeList = await oldDb.Ado.GetDataTableAsync(" select * from specimen_type order by display_order asc");
            //    if (oldSpecimenTypeList.Rows.Count > 0)
            //    {
            //        foreach (DataRow row in oldSpecimenTypeList.Rows)
            //        {

            //            using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
            //            {
            //                var tempId = GuidGenerator.Create();
            //                if (row["specimen_type_id"].ToString() == "0011")
            //                {
            //                    tempId = defaultSampleContainerId;
            //                }
            //                var defaultEnt = new SampleContainer(tempId)
            //                {
            //                    DisplayName = row["specimen_type_name"].ToString(),
            //                    SimpleCode = LanguageConverter.GetPYSimpleCode(row["specimen_type_name"].ToString()),
            //                    DisplayOrder = oldSpecimenTypeList.Rows.IndexOf(row) + 1,
            //                    ContainerColor = 16711680,
            //                    ContainerColorName = "其它",
            //                    ContainerRemark = ""
            //                };

            //                await _sampleContainerRepository.InsertAsync(defaultEnt);

            //                var fieldComparison = new FieldComparison
            //                {
            //                    TableName = "sample_container",
            //                    FieldName = "id",
            //                    NewKeyValue = tempId.ToString(),
            //                    OldKeyValue = row["specimen_type_id"].ToString()
            //                };

            //                await _fieldComparisonRepository.InsertAsync(fieldComparison);

            //                await uow.CompleteAsync();
            //            }

            //        }

            //    }


            //    await _diagnosisLevelRepository.InsertManyAsync(diagnosisLevels);
            //}
            #endregion

            #region 默认单位性质
            var isDefaultOrgType = await _customerOrgTypeRepository.FirstOrDefaultAsync(f => f.Id == defaultOrgTypeId);
            if (isDefaultOrgType == null)
            {
                var defaultEnt = new CustomerOrgType(defaultOrgTypeId)
                {
                    DisplayName = "其它",
                    SimpleCode = "QT",
                    DisplayOrder = 1
                };

                await _customerOrgTypeRepository.InsertAsync(defaultEnt);
            }
            #endregion


            #region 诊断级别
            var isDiagnosisLevel = await _diagnosisLevelRepository.CountAsync();
            if (isDiagnosisLevel == 0)
            {
                List<DiagnosisLevel> diagnosisLevels = new List<DiagnosisLevel>();

                diagnosisLevels.Add(new DiagnosisLevel(1)
                {
                    DisplayName = "一级",
                    DisplayOrder = 1

                });
                diagnosisLevels.Add(new DiagnosisLevel(2)
                {
                    DisplayName = "二级",
                    DisplayOrder = 2
                });
                diagnosisLevels.Add(new DiagnosisLevel(3)
                {
                    DisplayName = "三级",
                    DisplayOrder = 3
                });
                diagnosisLevels.Add(new DiagnosisLevel(4)
                {
                    DisplayName = "四级",
                    DisplayOrder = 4
                });

                await _diagnosisLevelRepository.InsertManyAsync(diagnosisLevels);
            }
            #endregion

            await CreateSexAsync();

            await CreateForSexAsync();

            await CreateMaritalStatusAsync();

            await CreateResultStatusAsync();
        }


        /// <summary>
        /// 处理基础数据
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/CCTJExportData/HandBaseData")]
        public async Task HandBaseData()
        {
            await TransferDeviceTypeData();
            await TransferUnitData();
            await TransferMedicalTypeData();
            await TransferPersonnelTypeData();
            await TransferInvoiceItemTypeData();
            await TransferCollectItemTypeData();
            await TransferItemTypeData();
            await TransferSampleTypeData();
            await TransferNationData();
            await TransferMedicalConclusionData();
            await TransferUserData();
            await TransferUserOrganizationUnitData();
            await TransferPayModeData();
        }


        /// <summary>
        /// 处理基础项目相关数据
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/CCTJExportData/HandBaseItemData")]
        public async Task HandBaseItemData()
        {
            await TransferItemData();
            await TransferAsbitemData();
            await TransferAsbitemDetailData();
            await TransferMedicalPackageData();
            await TransferMedicalPackageDetailData();
            await TransferDiagnosisData();
            await TransferSuggestionData();
            await TransferItemResultTemplateData();
            await TransferItemResultMatchData();
            await TransferReferenceRangeData();
            await TransferSampleGroupData();
            await TransferSampleGroupDetailData();
            await TransferTopCustomerOrgData();
            await TransferTwoCustomerOrgData();
            await TransferThreeCustomerOrgData();
            await TransferFourCustomerOrgData();
            await TransferCustomerOrgRegisterData();
            await TransferCustomerOrgGroupData();
            await TransferCustomerOrgGroupDetailData();
        }



        #region 基础数据

        /// <summary>
        /// 迁移仪器类别数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferDeviceTypeData()
        {
            var count = await _deviceTypeRepository.GetCountAsync();
            if (count == 0)
            {
                var oldDeviceTypeList = await oldDb.Ado.GetDataTableAsync("select device_type_id,device_type_name from device_type order by display_order asc");
                if (oldDeviceTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldDeviceTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid deviceTypeId = GuidGenerator.Create();

                            var data = new DeviceType(deviceTypeId)
                            {
                                CheckTypeFlag = '0',
                                DisplayName = row["device_type_name"].ToString(),
                                DisplayOrder = oldDeviceTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["device_type_name"].ToString())
                            };

                            await _deviceTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "device_type",
                                FieldName = "id",
                                NewKeyValue = deviceTypeId.ToString(),
                                OldKeyValue = row["device_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }
                }

                _logger.LogInformation($"仪器类别数据处理完毕,处理数量{oldDeviceTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("仪器类别数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移数值单位数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferUnitData()
        {
            var count = await _unitRepository.GetCountAsync();
            if (count == 0)
            {
                var oldUnitList = await oldDb.Ado.GetDataTableAsync("select unit_id,unit_name from unit order by display_order asc");
                if (oldUnitList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldUnitList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid unitId = GuidGenerator.Create();
                            var data = new Unit(unitId)
                            {
                                DisplayName = row["unit_name"].ToString(),
                                DisplayOrder = oldUnitList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["unit_name"].ToString())
                            };

                            await _unitRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "unit",
                                FieldName = "id",
                                NewKeyValue = unitId.ToString(),
                                OldKeyValue = row["unit_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }

                    }

                    _logger.LogInformation($"数值单位数据处理完毕,处理数量{oldUnitList.Rows.Count}");

                }
                else
                {
                    _logger.LogInformation($"数值单位数据已存在，未处理");
                }
            }
        }

        /// <summary>
        /// 迁移体检类别数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferMedicalTypeData()
        {
            var count = await _medicalTypeRepository.GetCountAsync();
            if (count == 0)
            {

                var oldMedicalTypeList = await oldDb.Ado.GetDataTableAsync("select medical_type_id,medical_type_name from medical_type order by display_order asc");
                if (oldMedicalTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldMedicalTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid medicalTypeId = GuidGenerator.Create();
                            var data = new MedicalType(medicalTypeId)
                            {
                                DisplayName = row["medical_type_name"].ToString(),
                                DisplayOrder = oldMedicalTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["medical_type_name"].ToString())
                            };

                            await _medicalTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "medical_type",
                                FieldName = "id",
                                NewKeyValue = medicalTypeId.ToString(),
                                OldKeyValue = row["medical_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }

                    }

                    _logger.LogInformation($"体检类别数据处理完毕,处理数量{oldMedicalTypeList.Rows.Count}");

                }
                else
                {
                    _logger.LogInformation($"体检类别数据已存在，未处理");
                }
            }
        }


        /// <summary>
        /// 迁移人员类别数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferPersonnelTypeData()
        {
            var count = await _personnelTypeRepository.GetCountAsync();
            if (count == 0)
            {

                var oldPersonnelTypeList = await oldDb.Ado.GetDataTableAsync("select personnel_type_id,personnel_type_name from personnel_type order by display_order asc");
                if (oldPersonnelTypeList.Rows.Count > 0)
                {


                    foreach (DataRow row in oldPersonnelTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid personnelTypeId = GuidGenerator.Create();

                            var data = new PersonnelType(personnelTypeId)
                            {
                                DisplayName = row["personnel_type_name"].ToString(),
                                DisplayOrder = oldPersonnelTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["personnel_type_name"].ToString())
                            };

                            await _personnelTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "personnel_type",
                                FieldName = "id",
                                NewKeyValue = personnelTypeId.ToString(),
                                OldKeyValue = row["personnel_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }


                    }


                }
                _logger.LogInformation($"人员类别数据处理完毕,处理数量{oldPersonnelTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"人员类别数据已存在，未处理");
            }
        }



        /// <summary>
        /// 迁移发票项目类别数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferInvoiceItemTypeData()
        {
            var count = await _invoiceItemTypeRepository.GetCountAsync();
            if (count == 0)
            {
                var oldInvoiceItemTypeList = await oldDb.Ado.GetDataTableAsync("select invoice_item_type_id,invoice_item_type_name from invoice_item_type order by display_order asc");
                if (oldInvoiceItemTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldInvoiceItemTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid invoiceItemTypeId = GuidGenerator.Create();

                            var data = new InvoiceItemType(invoiceItemTypeId)
                            {
                                DisplayName = row["invoice_item_type_name"].ToString(),
                                DisplayOrder = oldInvoiceItemTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["invoice_item_type_name"].ToString())
                            };

                            await _invoiceItemTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "invoice_item_type",
                                FieldName = "id",
                                NewKeyValue = invoiceItemTypeId.ToString(),
                                OldKeyValue = row["invoice_item_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }


                }
                _logger.LogInformation($"发票项目类别数据处理完毕,处理数量{oldInvoiceItemTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"发票项目类别数据已存在，未处理");
            }
        }



        /// <summary>
        /// 迁移汇总项目类别数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferCollectItemTypeData()
        {
            var count = await _collectItemTypeRepository.GetCountAsync();
            if (count == 0)
            {
                var oldCollectItemTypeList = await oldDb.Ado.GetDataTableAsync("select collect_item_type_id,collect_item_type_name,invoice_item_type_id from collect_item_type order by display_order asc");
                if (oldCollectItemTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldCollectItemTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid collectItemTypeId = GuidGenerator.Create();


                            Guid invoiceItemTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "invoice_item_type" && m.OldKeyValue == row["invoice_item_type_id"].ToString()).FirstOrDefault().NewKeyValue);

                            var data = new CollectItemType(collectItemTypeId)
                            {
                                DisplayName = row["collect_item_type_name"].ToString(),
                                DisplayOrder = oldCollectItemTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["collect_item_type_name"].ToString()),
                                InvoiceItemTypeId = invoiceItemTypeId
                            };

                            await _collectItemTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "collect_item_type",
                                FieldName = "id",
                                NewKeyValue = collectItemTypeId.ToString(),
                                OldKeyValue = row["collect_item_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }

                    _logger.LogInformation($"汇总项目类别数据处理完毕,处理数量{oldCollectItemTypeList.Rows.Count}");
                }
                else
                {
                    _logger.LogInformation($"汇总项目类别数据已存在，未处理");
                }
            }
        }


        /// <summary>
        /// 迁移项目类别-科室数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferItemTypeData()
        {
            var count = await _itemTypeRepository.GetCountAsync();
            if (count == 0)
            {

                var oldItemTypeList = await oldDb.Ado.GetDataTableAsync("select department_id,department_type,department_name,merge_asbitem_flag,print_pacs_barcode_flag from department order by display_order asc");
                if (oldItemTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldItemTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid itemTypeId = GuidGenerator.Create();

                            var data = new ItemType(itemTypeId)
                            {
                                DisplayName = row["department_name"].ToString(),
                                DisplayOrder = oldItemTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["department_name"].ToString()),
                                CheckTypeFlag = Convert.ToChar(row["department_type"]),
                                // GuidTypeId = defaultGuidTypeId,
                                GuidTypeId = Convert.ToChar(row["department_type"]),
                                IsMergeAsbitem = Convert.ToChar(row["merge_asbitem_flag"]),
                                IsWrap = 'N',
                                MedicalReportTypeId = Convert.ToChar(row["department_type"]),
                                //MedicalReportTypeId = defaultMedicalReportTypeId,
                                ParentId = null,
                                PathCode = _itemTypeManager.CreatePathCode(null).Result,
                                IsCheckRequest = Convert.ToChar(row["print_pacs_barcode_flag"])
                            };

                            await _itemTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "item_type",
                                FieldName = "id",
                                NewKeyValue = itemTypeId.ToString(),
                                OldKeyValue = row["department_id"].ToString()
                            };
                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }


                }
                _logger.LogInformation($"项目类别数据处理完毕,处理数量{oldItemTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"项目类别数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移标本类型数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferSampleTypeData()
        {
            var count = await _sampleTypeRepository.GetCountAsync();
            if (count == 0)
            {
                var oldSampleTypeList = await oldDb.Ado.GetDataTableAsync("select specimen_type_id,specimen_type_name from specimen_type order by display_order asc");
                if (oldSampleTypeList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldSampleTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid sampleTypeId = GuidGenerator.Create();

                            var data = new SampleType(sampleTypeId)
                            {
                                DisplayName = row["specimen_type_name"].ToString(),
                                DisplayOrder = oldSampleTypeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["specimen_type_name"].ToString())
                            };

                            await _sampleTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "sample_type",
                                FieldName = "id",
                                NewKeyValue = sampleTypeId.ToString(),
                                OldKeyValue = row["specimen_type_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }

                }
                _logger.LogInformation($"标本类型数据处理完毕,处理数量{oldSampleTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"标本类型数据已存在，未处理");
            }
        }


        /// <summary>
        /// 民族数据对照   
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferNationData()
        {
            var count = await _nationRepository.GetCountAsync();
            if (count == 0)
            {
                var oldNationList = await oldDb.Ado.GetDataTableAsync("select * from nation order by nation_id asc");
                if (oldNationList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldNationList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            var data = new Nation()
                            {
                                Id = row["nation_id"].ToString(),
                                CountryCode = "",
                                DisplayName = row["nation_name"].ToString(),
                                DisplayOrder = oldNationList.Rows.IndexOf(row) + 1,
                                SimpleCode = row["py_simple_code"].ToString()
                            };

                            await _nationRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "nation",
                                FieldName = "id",
                                NewKeyValue = row["nation_id"].ToString(),
                                OldKeyValue = row["nation_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }

                }
                _logger.LogInformation($"民族数据处理完毕,处理数量{oldNationList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"民族数据已存在，未处理");
            }


        }


        /// <summary>
        /// 迁移体检结论数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferMedicalConclusionData()
        {
            var count = await _medicalConclusionRepository.GetCountAsync();
            if (count == 0)
            {
                var oldMedicalConclusionList = await oldDb.Ado.GetDataTableAsync("select medical_conclusion_id,medical_conclusion_name from medical_conclusion order by display_order asc");
                if (oldMedicalConclusionList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldMedicalConclusionList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid medicalConclusionId = GuidGenerator.Create();

                            var data = new MedicalConclusion(medicalConclusionId)
                            {
                                DisplayName = row["medical_conclusion_name"].ToString(),
                                DisplayOrder = oldMedicalConclusionList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["medical_conclusion_name"].ToString()),
                                MedicalConclusionTypeId = defaultMedicalConclusionType
                            };

                            await _medicalConclusionRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "medical_conclusion",
                                FieldName = "id",
                                NewKeyValue = medicalConclusionId.ToString(),
                                OldKeyValue = row["medical_conclusion_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"体检结论数据处理完毕,处理数量{oldMedicalConclusionList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检结论数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移用户对应的科室
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferUserOrganizationUnitData()
        {
            var count = await _identityUserOrganizationUnitRepository.CountAsync();
            if (count == 0)
            {
                var identityUserList = await _identityUserRepository.GetListAsync();
                if (identityUserList.Count > 0)
                {
                    foreach (var item in identityUserList)
                    {
                        await _identityUserManager.SetOrganizationUnitsAsync(item.Id, defaultMedicalCenterId);
                    }
                }
                _logger.LogInformation($"用户对应的科室处理完毕,处理数量{identityUserList.Count}");
            }
            else
            {
                _logger.LogInformation("用户对应的科室已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移收费方式数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferPayModeData()
        {
            var count = await _payModeRepository.GetCountAsync();
            if (count == 0)
            {
                var oldPaymentModeList = await oldDb.Ado.GetDataTableAsync("select payment_mode_id,payment_mode_name from payment_mode order by display_order asc");
                if (oldPaymentModeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldPaymentModeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            var data = new PayMode()
                            {
                                Id = row["payment_mode_id"].ToString(),
                                DisplayName = row["payment_mode_name"].ToString(),
                                DisplayOrder = oldPaymentModeList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["payment_mode_name"].ToString()),
                                IsActive = 'Y'
                            };

                            await _payModeRepository.InsertAsync(data);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"收费方式数据处理完毕,处理数量{oldPaymentModeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("收费方式数据已存在，未处理");
            }
        }

        #endregion



        #region 基础项目相关数据

        /// <summary>
        /// 迁移项目数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferItemData()
        {
            var count = await _itemRepository.GetCountAsync();
            if (count == 0)
            {

                var oldItemList = await oldDb.Ado.GetDataTableAsync("select a.* from item as a left join department as b on a.department_id=b.department_id order by b.display_order,a.display_order");
                if (oldItemList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldItemList.Rows)
                    {

                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            #region 根据仪器类别生成二级科室

                            var itemTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item_type" && m.OldKeyValue == row["department_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid? deviceTypeId = null;

                            if (!string.IsNullOrWhiteSpace(row["device_type_id"].ToString()))
                            {
                                deviceTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "device_type" && m.OldKeyValue == row["device_type_id"].ToString()).FirstOrDefault().NewKeyValue);

                                var itemTypeEnt = await _itemTypeRepository.GetAsync(itemTypeId);
                                var deviceTypeEnt = await _deviceTypeRepository.GetAsync(deviceTypeId.Value);


                                var itemTypeChildEnt = await _itemTypeRepository.FirstOrDefaultAsync(m => m.ParentId == itemTypeEnt.Id && m.DisplayName == deviceTypeEnt.DisplayName);
                                if (itemTypeChildEnt == null)
                                {
                                    Guid autoItemTypeId = GuidGenerator.Create();

                                    #region 排序值

                                    int displayOrder = (await _itemTypeRepository.CountAsync(m => m.ParentId == itemTypeEnt.Id)) + 1;

                                    #endregion

                                    var item_type_data = new ItemType(autoItemTypeId)
                                    {
                                        DisplayName = deviceTypeEnt.DisplayName,
                                        DisplayOrder = displayOrder,
                                        SimpleCode = LanguageConverter.GetPYSimpleCode(deviceTypeEnt.DisplayName),
                                        CheckTypeFlag = itemTypeEnt.CheckTypeFlag,
                                        GuidTypeId = itemTypeEnt.GuidTypeId,
                                        IsMergeAsbitem = itemTypeEnt.IsMergeAsbitem,
                                        IsWrap = itemTypeEnt.IsWrap,
                                        MedicalReportTypeId = itemTypeEnt.MedicalReportTypeId,
                                        ParentId = itemTypeEnt.Id,
                                        PathCode = _itemTypeManager.CreatePathCode(itemTypeEnt.Id).Result,
                                        IsCheckRequest = itemTypeEnt.IsCheckRequest
                                    };

                                    await _itemTypeRepository.InsertAsync(item_type_data);
                                    itemTypeId = autoItemTypeId;
                                }
                                else
                                {
                                    itemTypeId = itemTypeChildEnt.Id;
                                }

                            }

                            #endregion



                            Guid? unitId = null;
                            if (!string.IsNullOrWhiteSpace(row["unit_id"].ToString()))
                                unitId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "unit" && m.OldKeyValue == row["unit_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid itemId = GuidGenerator.Create();

                            var data = new Item(itemId)
                            {
                                DisplayName = row["item_name"].ToString(),
                                DisplayOrder = oldItemList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["item_name"].ToString()),
                                CalculationFunction = "",
                                DefaultResult = row["default_result"].ToString(),
                                DiagnosisFunction = "",
                                EnglishShortName = row["english_abbreviation"].ToString(),
                                InputCheck = row["input_check"].ToString(),
                                IsActive = Convert.ToChar(row["valid_flag"].ToString()),
                                IsCalculationItem = 'N',
                                IsContinueProcess = 'N',
                                IsDiagnosisFunction = 'N',
                                IsNameIntoSummary = Convert.ToChar(row["name_into_summary_flag"]),
                                IsProduceSummary = Convert.ToChar(row["produce_summary_flag"]),
                                ItemTypeId = itemTypeId,
                                LineModeFlag = '0',
                                Price = Convert.ToDecimal(row["price"]),
                                PriceItemId = null,
                                ReferenceRangeTypeFlag = Convert.ToChar(row["reference_range_type"]),
                                ResultTemplateTypeFlag = '0',
                                UnitId = unitId,
                                DeviceTypeId = deviceTypeId
                            };

                            await _itemRepository.InsertAsync(data);

                            if (row["reference_range_type"].ToString() == "2" && !string.IsNullOrWhiteSpace(row["reference_range_value"].ToString()))
                            {
                                //增加字符型参考范围到参考范围表

                                Guid referenceRangeId = GuidGenerator.Create();

                                var referenceRange = new ReferenceRange(referenceRangeId)
                                {
                                    AgeLowerLimit = 0,
                                    AgeUpperLimit = 200,
                                    CriticalRangeValue = "",
                                    ItemId = itemId,
                                    ForSexId = ForSexFlag.All,
                                    LowerDiagnosisId = null,
                                    ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Character,
                                    UpperDiagnosisId = null,
                                    ReferenceRangeValue = row["reference_range_value"].ToString()
                                };

                                //referenceRanges.Add(referenceRange);
                                await _referenceRangeRepository.InsertAsync(referenceRange);
                            }


                            var fieldComparison = new FieldComparison
                            {
                                TableName = "item",
                                FieldName = "id",
                                NewKeyValue = itemId.ToString(),
                                OldKeyValue = row["item_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }




                }
                _logger.LogInformation($"项目数据处理完毕,处理数量{oldItemList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("项目数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移组合项目数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferAsbitemData()
        {
            var count = await _asbitemRepository.GetCountAsync();

            if (count == 0)
            {
                var oldAsbitemList = await oldDb.Ado.GetDataTableAsync("select a.* from asbitem as a left join department as b on a.department_id=b.department_id order by b.display_order,a.display_order ");
                if (oldAsbitemList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldAsbitemList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            #region 根据仪器类别生成二级科室

                            var itemTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item_type" && m.OldKeyValue == row["department_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid? deviceTypeId = null;

                            if (!string.IsNullOrWhiteSpace(row["device_type_id"].ToString()))
                            {
                                deviceTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "device_type" && m.OldKeyValue == row["device_type_id"].ToString()).FirstOrDefault().NewKeyValue);

                                var itemTypeEnt = await _itemTypeRepository.GetAsync(itemTypeId);
                                var deviceTypeEnt = await _deviceTypeRepository.GetAsync(deviceTypeId.Value);


                                var itemTypeChildEnt = await _itemTypeRepository.FirstOrDefaultAsync(m => m.ParentId == itemTypeEnt.Id && m.DisplayName == deviceTypeEnt.DisplayName);
                                if (itemTypeChildEnt == null)
                                {
                                    Guid autoItemTypeId = GuidGenerator.Create();

                                    #region 排序值

                                    int displayOrder = (await _itemTypeRepository.CountAsync(m => m.ParentId == itemTypeEnt.Id)) + 1;

                                    #endregion

                                    var item_type_data = new ItemType(autoItemTypeId)
                                    {
                                        DisplayName = deviceTypeEnt.DisplayName,
                                        DisplayOrder = displayOrder,
                                        SimpleCode = LanguageConverter.GetPYSimpleCode(deviceTypeEnt.DisplayName),
                                        CheckTypeFlag = itemTypeEnt.CheckTypeFlag,
                                        GuidTypeId = itemTypeEnt.GuidTypeId,
                                        IsMergeAsbitem = itemTypeEnt.IsMergeAsbitem,
                                        IsWrap = itemTypeEnt.IsWrap,
                                        MedicalReportTypeId = itemTypeEnt.MedicalReportTypeId,
                                        ParentId = itemTypeEnt.Id,
                                        PathCode = _itemTypeManager.CreatePathCode(itemTypeEnt.Id).Result,
                                        IsCheckRequest = itemTypeEnt.IsCheckRequest
                                    };

                                    await _itemTypeRepository.InsertAsync(item_type_data);
                                    itemTypeId = autoItemTypeId;
                                }
                                else
                                {
                                    itemTypeId = itemTypeChildEnt.Id;
                                }

                            }

                            #endregion

                            Guid collectItemTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "collect_item_type" && m.OldKeyValue == row["collect_item_type_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid asbitemId = GuidGenerator.Create();


                            var data = new Asbitem(asbitemId)
                            {
                                DisplayName = row["asbitem_name"].ToString(),
                                DisplayOrder = oldAsbitemList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["asbitem_name"].ToString()),
                                DefaultResult = row["default_result"].ToString(),
                                DiagnosisFunction = "",
                                IsActive = Convert.ToChar(row["valid_flag"].ToString()),
                                IsContinueProcess = 'N',
                                IsDiagnosisFunction = 'N',
                                ItemTypeId = itemTypeId,
                                Price = Convert.ToDecimal(row["price"]),
                                DeviceTypeId = deviceTypeId,
                                ClinicalMeaning = row["clinical_meaning"].ToString(),
                                ForSexId = ConvertForSex(row["for_sex_id"].ToString()),
                                CollectItemTypeId = collectItemTypeId,
                                //InvoiceItemTypeId = InvoiceItemTypeId,
                                IsBeforeEat = Convert.ToChar(row["before_eat_flag"].ToString()),
                                IsCheck = Convert.ToChar(row["check_flag"].ToString()),
                                IsItemResultMerger = Convert.ToChar(row["item_result_merger_flag"].ToString()),
                                IsPictureRotate = Convert.ToChar(row["picture_rotate_flag"].ToString()),
                                QueueTime = string.IsNullOrEmpty(row["queue_time"].ToString()) ? 0 : Convert.ToDecimal(row["queue_time"].ToString()),
                                ShortName = row["short_name"].ToString(),
                                BarcodeMode = '0',
                                DiseaseScreeningTypeId = null,
                                ForPregnantFlag = 'A',
                                IsWebAppoint = 'N',
                                MaritalStatusId = 'A',
                                Warn = "",
                                IsOutsend = Convert.ToChar(string.IsNullOrWhiteSpace(row["outsend_flag"].ToString()) ? "N" : row["outsend_flag"].ToString())
                            };

                            await _asbitemRepository.InsertAsync(data);


                            #region 指引信息

                            if (!string.IsNullOrWhiteSpace(row["prompt"].ToString()))
                            {
                                var asbitemGuideData = new AsbitemGuide
                                {
                                    AsbitemId = asbitemId,
                                    ForSexId = ForSexFlag.All,
                                    Guide = row["prompt"].ToString(),
                                    MedicalCenterId = defaultMedicalCenterId
                                };

                                await _asbitemGuideRepository.InsertAsync(asbitemGuideData);
                            }

                            #endregion

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "asbitem",
                                FieldName = "id",
                                NewKeyValue = asbitemId.ToString(),
                                OldKeyValue = row["asbitem_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }




                }
                _logger.LogInformation($"组合项目数据处理完毕,处理数量{oldAsbitemList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("组合项目数据已存在，未处理");
            }


        }


        /// <summary>
        /// 迁移组合项目明细数据 无字典
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferAsbitemDetailData()
        {
            var count = await _asbitemDetailRepository.GetCountAsync();

            if (count == 0)
            {
                var oldAsbitemDetailList = await oldDb.Ado.GetDataTableAsync("select  * from asbitem_detail ");
                if (oldAsbitemDetailList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldAsbitemDetailList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid asbitemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "asbitem" && m.OldKeyValue == row["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);
                            Guid itemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item" && m.OldKeyValue == row["item_id"].ToString()).FirstOrDefault().NewKeyValue);
                            var data = new AsbitemDetail
                            {
                                AsbitemId = asbitemId,
                                ItemId = itemId
                            };

                            await _asbitemDetailRepository.InsertAsync(data);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"组合项目明细数据处理完毕,处理数量{oldAsbitemDetailList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("组合项目明细数据已存在，未处理");
            }


        }


        /// <summary>
        /// 迁移体检套餐数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferMedicalPackageData()
        {
            var count = await _medicalPackageRepository.GetCountAsync();

            if (count == 0)
            {
                var oldMedicalPackageList = await oldDb.Ado.GetDataTableAsync("select  * from medical_package order by display_order");
                if (oldMedicalPackageList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldMedicalPackageList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid medicalPackageId = GuidGenerator.Create();

                            var data = new MedicalPackage(medicalPackageId)
                            {
                                DisplayName = row["medical_package_name"].ToString(),
                                DisplayOrder = oldMedicalPackageList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["medical_package_name"].ToString()),
                                ForSexId = ConvertForSex(row["for_sex_id"].ToString()),
                                IsActive = Convert.ToChar(row["valid_flag"].ToString()),
                                Price = Convert.ToDecimal(row["price"].ToString()),
                                Remark = row["remark"].ToString(),
                                AgeLowerLimit = 0,
                                AgeUpperLimit = 200,
                                IsBasicRecommend = 'N',
                                IsWebAppoint = 'N',
                                MaritalStatusId = 'A'
                            };

                            await _medicalPackageRepository.InsertAsync(data);


                            var fieldComparison = new FieldComparison
                            {
                                TableName = "medical_package",
                                FieldName = "id",
                                NewKeyValue = medicalPackageId.ToString(),
                                OldKeyValue = row["medical_package_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"体检套餐数据处理完毕,处理数量{oldMedicalPackageList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检套餐数据已存在，未处理");
            }


        }


        /// <summary>
        /// 迁移体检套餐明细数据  无字典
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferMedicalPackageDetailData()
        {
            var count = await _medicalPackageDetailRepository.GetCountAsync();

            if (count == 0)
            {
                var oldMedicalPackageDetailList = await oldDb.Ado.GetDataTableAsync("select  * from medical_package_detail ");
                if (oldMedicalPackageDetailList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldMedicalPackageDetailList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid asbitemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "asbitem" && m.OldKeyValue == row["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);
                            Guid MedicalPackageId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "medical_package" && m.OldKeyValue == row["medical_package_id"].ToString()).FirstOrDefault().NewKeyValue);

                            var asbitemEnt = await _asbitemRepository.GetAsync(asbitemId);

                            var data = new MedicalPackageDetail
                            {
                                AsbitemId = asbitemId,
                                Amount = 1,
                                MedicalPackageId = MedicalPackageId,
                                Price = asbitemEnt.Price
                            };

                            await _medicalPackageDetailRepository.InsertAsync(data);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"体检套餐明细数据处理完毕,处理数量{oldMedicalPackageDetailList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检套餐明细数据已存在，未处理");
            }

        }

        /// <summary>
        /// 迁移诊断设置数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferDiagnosisData()
        {
            var count = await _diagnosisRepository.GetCountAsync();
            if (count == 0)
            {

                var oldDiagnosisList = await oldDb.Ado.GetDataTableAsync("select a.* from diagnosis as a left join department as b on a.department_id=b.department_id order by b.display_order,a.display_order ");
                if (oldDiagnosisList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldDiagnosisList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            #region 根据仪器类别生成二级科室

                            var itemTypeId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item_type" && m.OldKeyValue == row["department_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid? deviceTypeId = null;

                            if (!string.IsNullOrWhiteSpace(row["device_type_id"].ToString()))
                            {
                                var fieldComparisonEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "device_type" && m.OldKeyValue == row["device_type_id"].ToString()).FirstOrDefault();
                                if (fieldComparisonEnt != null)
                                {
                                    deviceTypeId = Guid.Parse(fieldComparisonEnt.NewKeyValue);
                                    var itemTypeEnt = await _itemTypeRepository.GetAsync(itemTypeId);
                                    var deviceTypeEnt = await _deviceTypeRepository.GetAsync(deviceTypeId.Value);


                                    var itemTypeChildEnt = await _itemTypeRepository.FirstOrDefaultAsync(m => m.ParentId == itemTypeEnt.Id && m.DisplayName == deviceTypeEnt.DisplayName);
                                    if (itemTypeChildEnt == null)
                                    {
                                        Guid autoItemTypeId = GuidGenerator.Create();

                                        #region 排序值

                                        int displayOrder = (await _itemTypeRepository.CountAsync(m => m.ParentId == itemTypeEnt.Id)) + 1;

                                        #endregion

                                        var item_type_data = new ItemType(autoItemTypeId)
                                        {
                                            DisplayName = deviceTypeEnt.DisplayName,
                                            DisplayOrder = displayOrder,
                                            SimpleCode = LanguageConverter.GetPYSimpleCode(deviceTypeEnt.DisplayName),
                                            CheckTypeFlag = itemTypeEnt.CheckTypeFlag,
                                            GuidTypeId = itemTypeEnt.GuidTypeId,
                                            IsMergeAsbitem = itemTypeEnt.IsMergeAsbitem,
                                            IsWrap = itemTypeEnt.IsWrap,
                                            MedicalReportTypeId = itemTypeEnt.MedicalReportTypeId,
                                            ParentId = itemTypeEnt.Id,
                                            PathCode = _itemTypeManager.CreatePathCode(itemTypeEnt.Id).Result,
                                            IsCheckRequest = itemTypeEnt.IsCheckRequest
                                        };

                                        await _itemTypeRepository.InsertAsync(item_type_data);
                                        itemTypeId = autoItemTypeId;
                                    }
                                    else
                                    {
                                        itemTypeId = itemTypeChildEnt.Id;
                                    }
                                }

                            }

                            #endregion


                            Guid diagnosisId = GuidGenerator.Create();

                            var data = new Diagnosis(diagnosisId)
                            {
                                DisplayName = row["diagnosis_name"].ToString(),
                                DisplayOrder = oldDiagnosisList.Rows.IndexOf(row) + 1,
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["diagnosis_name"].ToString()),
                                ItemTypeId = itemTypeId,
                                DiagnosisLevelId = 1,
                                ForSexId = 'A',
                                IsIll = Convert.ToChar(row["ill_flag"].ToString()),
                                IsSummaryTemplate = Convert.ToChar(row["template_flag"].ToString()),
                                SuggestionName = row["suggestion_name"].ToString()
                            };

                            await _diagnosisRepository.InsertAsync(data);


                            var fieldComparison = new FieldComparison
                            {
                                TableName = "diagnosis",
                                FieldName = "id",
                                NewKeyValue = diagnosisId.ToString(),
                                OldKeyValue = row["diagnosis_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }




                }
                _logger.LogInformation($"诊断设置数据处理完毕,处理数量{oldDiagnosisList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("诊断设置数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移诊断建议数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferSuggestionData()
        {
            var count = await _suggestionRepository.GetCountAsync();
            if (count == 0)
            {

                var oldSuggestionList = await oldDb.Ado.GetDataTableAsync("select  * from suggestion  order by   display_order,suggestion_id ");
                if (oldSuggestionList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldSuggestionList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            Guid DiagnosisId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "diagnosis" && m.OldKeyValue == row["diagnosis_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid suggestionId = GuidGenerator.Create();

                            if (await _suggestionRepository.FirstOrDefaultAsync(f => f.DiagnosisId == DiagnosisId && f.SuggestionContent == row["suggestion_content"].ToString()) == null)
                            {
                                var data = new Suggestion(suggestionId)
                                {
                                    DisplayOrder = oldSuggestionList.Rows.IndexOf(row) + 1,
                                    DiagnosisId = DiagnosisId,
                                    SuggestionType = SuggestionTypeFlag.HealthGuidance,
                                    SuggestionContent = row["suggestion_content"].ToString()
                                };

                                await _suggestionRepository.InsertAsync(data);


                                var fieldComparison = new FieldComparison
                                {
                                    TableName = "suggestion",
                                    FieldName = "id",
                                    NewKeyValue = suggestionId.ToString(),
                                    OldKeyValue = row["suggestion_id"].ToString()
                                };

                                await _fieldComparisonRepository.InsertAsync(fieldComparison);
                            }
                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"诊断建议数据处理完毕,处理数量{oldSuggestionList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("诊断建议数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移项目结果模板数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferItemResultTemplateData()
        {
            var count = await _itemResultTemplateRepository.GetCountAsync();
            if (count == 0)
            {
                var oldItemResultTemplateList = await oldDb.Ado.GetDataTableAsync("select  * from item_result_template order by display_order,item_result_template_id ");
                if (oldItemResultTemplateList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldItemResultTemplateList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid? DiagnosisId = null;
                            if (!string.IsNullOrWhiteSpace(row["diagnosis_id"].ToString()))
                            {
                                var fieldComparisonDiagnosisEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "diagnosis" && m.OldKeyValue == row["diagnosis_id"].ToString()).FirstOrDefault();
                                if (fieldComparisonDiagnosisEnt != null)
                                {
                                    DiagnosisId = Guid.Parse(fieldComparisonDiagnosisEnt.NewKeyValue);
                                }
                            }

                            Guid ItemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item" && m.OldKeyValue == row["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid itemResultTemplateId = GuidGenerator.Create();

                            if (await _itemResultTemplateRepository.FirstOrDefaultAsync(f => f.ItemId == ItemId && f.Result == row["result"].ToString()) == null)
                            {

                                var data = new ItemResultTemplate(itemResultTemplateId)
                                {
                                    DisplayOrder = oldItemResultTemplateList.Rows.IndexOf(row) + 1,
                                    DiagnosisId = DiagnosisId,
                                    IsNameIntoSummary = Convert.ToChar(row["name_into_summary_flag"].ToString()),
                                    IsResultIntoSummary = Convert.ToChar(row["result_into_summary_flag"].ToString()),
                                    ItemId = ItemId,
                                    Result = row["result"].ToString(),
                                    SimpleCode = LanguageConverter.GetPYSimpleCode(row["result"].ToString()),
                                    ResultStatusId = row["result_status_id"].ToString()
                                };

                                await _itemResultTemplateRepository.InsertAsync(data);


                                var fieldComparison = new FieldComparison
                                {
                                    TableName = "item_result_template",
                                    FieldName = "id",
                                    NewKeyValue = itemResultTemplateId.ToString(),
                                    OldKeyValue = row["item_result_template_id"].ToString()
                                };

                                await _fieldComparisonRepository.InsertAsync(fieldComparison);
                            }
                            await uow.CompleteAsync();

                        }
                    }
                }
                _logger.LogInformation($"项目结果模板数据处理完毕,处理数量{oldItemResultTemplateList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("项目结果模板数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移项目结果匹配数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferItemResultMatchData()
        {
            var count = await _ItemResultMatchRepository.GetCountAsync();
            if (count == 0)
            {
                var oldItemResultMatchList = await oldDb.Ado.GetDataTableAsync("select  * from item_result_match order by  display_order,item_result_match_id ");
                if (oldItemResultMatchList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldItemResultMatchList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            var fieldComparisonDiagnosisEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "diagnosis" && m.OldKeyValue == row["diagnosis_id"].ToString()).FirstOrDefault();
                            if (fieldComparisonDiagnosisEnt != null)
                            {
                                Guid DiagnosisId = Guid.Parse(fieldComparisonDiagnosisEnt.NewKeyValue);
                                Guid ItemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item" && m.OldKeyValue == row["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                                Guid itemResultMatchId = GuidGenerator.Create();

                                var data = new ItemResultMatch(itemResultMatchId)
                                {
                                    DisplayOrder = oldItemResultMatchList.Rows.IndexOf(row) + 1,
                                    DiagnosisId = DiagnosisId,
                                    ItemId = ItemId,
                                    Result = row["result"].ToString()
                                };

                                var ent = await _ItemResultMatchRepository.InsertAsync(data, true);


                                var fieldComparison = new FieldComparison
                                {
                                    TableName = "item_result_match",
                                    FieldName = "id",
                                    NewKeyValue = ent.Id.ToString(),
                                    OldKeyValue = row["item_result_match_id"].ToString()
                                };

                                await _fieldComparisonRepository.InsertAsync(fieldComparison);
                            }

                            await uow.CompleteAsync();
                        }

                    }




                }
                _logger.LogInformation($"项目结果匹配数据处理完毕,处理数量{oldItemResultMatchList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("项目结果匹配数据已存在，未处理");
            }
        }



        /// <summary>
        /// 迁移项目参考范围数据 无字典
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferReferenceRangeData()
        {
            var count = (await _referenceRangeRepository.GetQueryableAsync()).Where(m => m.ReferenceRangeTypeFlag != ItemReferenceRangeTypeFlag.Character).Count();
            if (count == 0)
            {

                var oldReferenceRangeList = await oldDb.Ado.GetDataTableAsync("select  * from reference_range order by  reference_range_id  ");
                if (oldReferenceRangeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldReferenceRangeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid? LowerDiagnosisId = null;
                            Guid? UpperDiagnosisId = null;

                            var fieldComparisonLowerDiagnosisEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "diagnosis" && m.OldKeyValue == row["lower_diagnosis_id"].ToString()).FirstOrDefault();
                            var fieldComparisonUpperDiagnosisEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "diagnosis" && m.OldKeyValue == row["upper_diagnosis_id"].ToString()).FirstOrDefault();
                            if (fieldComparisonLowerDiagnosisEnt != null)
                            {
                                LowerDiagnosisId = Guid.Parse(fieldComparisonLowerDiagnosisEnt.NewKeyValue);
                            }
                            if (fieldComparisonUpperDiagnosisEnt != null)
                            {
                                UpperDiagnosisId = Guid.Parse(fieldComparisonUpperDiagnosisEnt.NewKeyValue);
                            }

                            Guid ItemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "item" && m.OldKeyValue == row["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid referenceRangeId = GuidGenerator.Create();

                            var data = new ReferenceRange(referenceRangeId)
                            {
                                ItemId = ItemId,
                                AgeLowerLimit = (short)Convert.ToInt32(row["age_lower_limit"].ToString()),
                                AgeUpperLimit = (short)Convert.ToInt32(row["age_upper_limit"].ToString()),
                                CriticalRangeValue = string.Empty,
                                ForSexId = ConvertForSex(row["for_sex_id"].ToString()),
                                LowerDiagnosisId = LowerDiagnosisId,
                                ReferenceRangeTypeFlag = ItemReferenceRangeTypeFlag.Number,
                                ReferenceRangeValue = Convert.ToDecimal(row["lower_limit"].ToString()).ToString("#0.####") + "-" + Convert.ToDecimal(row["upper_limit"].ToString()).ToString("#0.####"),
                                UpperDiagnosisId = UpperDiagnosisId
                            };

                            await _referenceRangeRepository.InsertAsync(data);

                            await uow.CompleteAsync();
                        }
                    }


                }
                _logger.LogInformation($"项目参考范围数据处理完毕,处理数量{oldReferenceRangeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("项目参考范围数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移条码分组数据  
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferSampleGroupData()
        {
            var count = await _sampleGroupRepository.GetCountAsync();
            if (count == 0)
            {
                //获取一条条码类型的数据  
                Guid defaultSampleTypeId = Guid.Empty;
                var sampleTypeEnt = await _sampleTypeRepository.FirstOrDefaultAsync();
                if (sampleTypeEnt != null)
                {
                    defaultSampleTypeId = sampleTypeEnt.Id;
                }
                if (defaultSampleTypeId != Guid.Empty)
                {
                    var oldSampleGroupList = await oldDb.Ado.GetDataTableAsync("select * from vessels_type order by display_order");
                    if (oldSampleGroupList.Rows.Count > 0)
                    {
                        foreach (DataRow row in oldSampleGroupList.Rows)
                        {
                            using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                            {
                                #region 转成成新的标本类型ID

                                Guid newSampleTypeId = defaultSampleTypeId; //默认取其他 ID

                                if (!string.IsNullOrWhiteSpace(row["specimen_type_id"].ToString()))
                                {
                                    var oldSampleType = (await _fieldComparisonRepository.GetQueryableAsync())
                                    .Where(m => m.TableName == "sample_type" && m.OldKeyValue == row["specimen_type_id"].ToString()).FirstOrDefault();
                                    if (oldSampleType != null)
                                    {
                                        newSampleTypeId = Guid.Parse(oldSampleType.NewKeyValue);
                                    }
                                }
                                #endregion

                                Guid sampleGroupId = GuidGenerator.Create();

                                var data = new SampleGroup(sampleGroupId)
                                {
                                    DisplayName = row["vessels_type_name"].ToString(),
                                    DisplayOrder = oldSampleGroupList.Rows.IndexOf(row) + 1,
                                    SimpleCode = LanguageConverter.GetPYSimpleCode(row["vessels_type_name"].ToString()),
                                    SampleContainerId = defaultSampleContainerId,
                                    SamplePrintCount = string.IsNullOrWhiteSpace(row["label_num"].ToString()) ? 0 : Convert.ToInt32(row["label_num"].ToString()),
                                    SampleTypeId = newSampleTypeId
                                };

                                await _sampleGroupRepository.InsertAsync(data);

                                var fieldComparison = new FieldComparison
                                {
                                    TableName = "sample_group",
                                    FieldName = "id",
                                    NewKeyValue = sampleGroupId.ToString(),
                                    OldKeyValue = row["vessels_type_id"].ToString()
                                };

                                await _fieldComparisonRepository.InsertAsync(fieldComparison);

                                await uow.CompleteAsync();
                            }
                        }


                    }

                    _logger.LogInformation($"条码分组数据处理完毕,处理数量{oldSampleGroupList.Rows.Count}");
                }
                else
                {
                    _logger.LogInformation($"条码类型未获取到默认数据，跳过条码分组数据处理");
                }
            }
            else
            {
                _logger.LogInformation("条码分组数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移条码分组明细数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferSampleGroupDetailData()
        {
            var count = await _sampleGroupDetailRepository.GetCountAsync();
            if (count == 0)
            {
                var oldSampleGroupDetailList = await oldDb.Ado.GetDataTableAsync("select * from vessels_type_detail ");
                if (oldSampleGroupDetailList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldSampleGroupDetailList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid newSampleGroupId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                        .Where(m => m.TableName == "sample_group" && m.OldKeyValue == row["vessels_type_id"].ToString()).FirstOrDefault().NewKeyValue);

                            Guid newAsbitemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                           .Where(m => m.TableName == "asbitem" && m.OldKeyValue == row["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);

                            var data = new SampleGroupDetail
                            {
                                AsbitemId = newAsbitemId,
                                SampleGroupId = newSampleGroupId
                            };

                            await _sampleGroupDetailRepository.InsertAsync(data);

                            await uow.CompleteAsync();

                        }
                    }


                }
                _logger.LogInformation($"条码分组明细数据处理完毕,处理数量{oldSampleGroupDetailList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("条码分组明细数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移体检单位数据 一级
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferTopCustomerOrgData()
        {
            var count = await _customerOrgRepository.GetCountAsync();
            if (count == 0)
            {

                var medicalTypeIdFieldComparisonList = (await _fieldComparisonRepository.GetQueryableAsync())
                       .Where(m => m.TableName == "medical_Type").ToList();

                var oldCustomerOrgList = await oldDb.Ado.GetDataTableAsync("select  * from org where len(org_id)=5 order by display_order asc");
                if (oldCustomerOrgList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldCustomerOrgList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid customerOrgId = GuidGenerator.Create();

                            if (row["org_id"].ToString() == "00000")
                            {
                                customerOrgId = Guid.Parse("00000000-0000-0000-0000-000000000001");
                            }

                            #region 备注  导入联系人姓名、电话
                            string remark = "";
                            if (!string.IsNullOrWhiteSpace(row["linkman"].ToString()))
                            {
                                remark = row["linkman"].ToString();
                            }
                            if (!string.IsNullOrWhiteSpace(row["telephone"].ToString()))
                            {
                                if (!string.IsNullOrWhiteSpace(remark))
                                {
                                    remark += "|" + row["telephone"].ToString();
                                }
                                else
                                {
                                    remark = row["telephone"].ToString();
                                }
                            }
                            #endregion
                            #region 转换体检类别ID


                            Guid? medicalTypeId = null;

                            var oldMedicalTypeId = row["medical_type_id"].ToString();
                            if (!string.IsNullOrWhiteSpace(oldMedicalTypeId))
                            {
                                var medicalTypeIdFieldComparison = medicalTypeIdFieldComparisonList.FirstOrDefault(f => f.OldKeyValue == oldMedicalTypeId);
                                if (medicalTypeIdFieldComparison != null)
                                    medicalTypeId = Guid.Parse(medicalTypeIdFieldComparison.NewKeyValue);
                            }
                            #endregion


                            var data = new CustomerOrg(customerOrgId)
                            {
                                Accounts = row["accounts"].ToString(),
                                Address = row["address"].ToString(),
                                Bank = row["bank"].ToString(),
                                DisplayName = row["org_name"].ToString(),
                                DisplayOrder = oldCustomerOrgList.Rows.IndexOf(row) + 1,
                                Fax = row["fax"].ToString(),
                                InvoiceName = row["org_name"].ToString(),
                                IsActive = 'Y',
                                IsLock = Convert.ToChar(row["lock_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                OrgTypeId = defaultOrgTypeId,  //默认为私营
                                ParentId = null,
                                PathCode = (oldCustomerOrgList.Rows.IndexOf(row) + 1).ToString().PadLeft(5, '0'),
                                PostalCode = row["postalcode"].ToString(),
                                Remark = remark,
                                ShortName = row["short_name"].ToString(),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["org_name"].ToString()),
                                Telephone = row["telephone"].ToString(),
                                CountryOrgCode = row["org_id"].ToString(),
                                SalesPerson = "",
                                SalesPersonPhone = "",
                                MedicalTypeId = medicalTypeId
                            };

                            await _customerOrgRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                FieldName = "id",
                                NewKeyValue = customerOrgId.ToString(),
                                OldKeyValue = row["org_id"].ToString(),
                                TableName = "customer_org"
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();

                        }

                    }
                }
                _logger.LogInformation($"体检单位一级数据处理完毕,处理数量{oldCustomerOrgList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检单位一级数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移体检单位数据 二级
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferTwoCustomerOrgData()
        {
            var count = (await _customerOrgRepository.GetQueryableAsync()).Where(m => m.PathCode.Length > 5).Count();
            if (count == 0)
            {
                var medicalTypeIdFieldComparisonList = (await _fieldComparisonRepository.GetQueryableAsync())
                     .Where(m => m.TableName == "medical_Type").ToList();


                var oldCustomerOrgList = await oldDb.Ado.GetDataTableAsync("select * from [dbo].[org] where len(org_id)=8 order by org_id asc");
                if (oldCustomerOrgList.Rows.Count > 0)
                {
                    List<CustomerOrg> customerOrgList = await _customerOrgRepository.GetListAsync(m => m.ParentId == null);
                    List<FieldComparison> fieldComparisonList = await _fieldComparisonRepository.GetListAsync(m => m.TableName == "customer_org");

                    foreach (DataRow row in oldCustomerOrgList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            #region 查找上级ID
                            string oldId = row["org_id"].ToString();
                            string oldParentId = oldId.Substring(0, 5);
                            Guid parentId = Guid.Parse(fieldComparisonList.Where(m => m.OldKeyValue == oldParentId).FirstOrDefault().NewKeyValue);
                            #endregion


                            Guid customerOrgId = GuidGenerator.Create();

                            #region 转换体检类别ID


                            Guid? medicalTypeId = null;

                            var oldMedicalTypeId = row["medical_type_id"].ToString();
                            if (!string.IsNullOrWhiteSpace(oldMedicalTypeId))
                            {
                                var medicalTypeIdFieldComparison = medicalTypeIdFieldComparisonList.FirstOrDefault(f => f.OldKeyValue == oldMedicalTypeId);
                                if (medicalTypeIdFieldComparison != null)
                                    medicalTypeId = Guid.Parse(medicalTypeIdFieldComparison.NewKeyValue);
                            }
                            #endregion

                            #region 备注  导入联系人姓名、电话
                            string remark = "";
                            if (!string.IsNullOrWhiteSpace(row["linkman"].ToString()))
                            {
                                remark = row["linkman"].ToString();
                            }
                            if (!string.IsNullOrWhiteSpace(row["telephone"].ToString()))
                            {
                                if (!string.IsNullOrWhiteSpace(remark))
                                {
                                    remark += "|" + row["telephone"].ToString();
                                }
                                else
                                {
                                    remark = row["telephone"].ToString();
                                }
                            }
                            #endregion

                            var data = new CustomerOrg(customerOrgId)
                            {
                                Accounts = row["accounts"].ToString(),
                                Address = row["address"].ToString(),
                                Bank = row["bank"].ToString(),
                                DisplayName = row["org_name"].ToString(),
                                DisplayOrder = oldCustomerOrgList.Rows.IndexOf(row) + 1,
                                Fax = row["fax"].ToString(),
                                InvoiceName = row["org_name"].ToString(),
                                IsActive = 'Y',
                                IsLock = Convert.ToChar(row["lock_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                OrgTypeId = defaultOrgTypeId,  //默认为私营
                                ParentId = parentId,
                                PathCode = _customerOrgManager.CreatePathCode(parentId).Result,
                                PostalCode = row["postalcode"].ToString(),
                                Remark = remark,
                                ShortName = row["short_name"].ToString(),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["org_name"].ToString()),
                                Telephone = row["telephone"].ToString(),
                                CountryOrgCode = row["org_id"].ToString(),
                                SalesPerson = "",
                                SalesPersonPhone = "",
                                MedicalTypeId = medicalTypeId
                            };

                            await _customerOrgRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                FieldName = "id",
                                NewKeyValue = customerOrgId.ToString(),
                                OldKeyValue = row["org_id"].ToString(),
                                TableName = "customer_org"
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }

                    }

                }
                _logger.LogInformation($"体检单位二级数据处理完毕,处理数量{oldCustomerOrgList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检单位二级数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移体检单位数据 三级
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferThreeCustomerOrgData()
        {
            var count = (await _customerOrgRepository.GetQueryableAsync()).Where(m => m.PathCode.Length > 11).Count();
            if (count == 0)
            {
                var medicalTypeIdFieldComparisonList = (await _fieldComparisonRepository.GetQueryableAsync())
                   .Where(m => m.TableName == "medical_Type").ToList();

                var oldCustomerOrgList = await oldDb.Ado.GetDataTableAsync("select * from [dbo].[org] where len(org_id)=11 order by org_id asc");
                if (oldCustomerOrgList.Rows.Count > 0)
                {
                    List<CustomerOrg> customerOrgList = await _customerOrgRepository.GetListAsync(m => m.ParentId == null);
                    List<FieldComparison> fieldComparisonList = await _fieldComparisonRepository.GetListAsync(m => m.TableName == "customer_org");

                    foreach (DataRow row in oldCustomerOrgList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            #region 查找上级ID
                            string oldId = row["org_id"].ToString();
                            string oldParentId = oldId.Substring(0, 8);
                            Guid parentId = Guid.Parse(fieldComparisonList.Where(m => m.OldKeyValue == oldParentId).FirstOrDefault().NewKeyValue);
                            #endregion


                            Guid customerOrgId = GuidGenerator.Create();

                            #region 备注  导入联系人姓名、电话
                            string remark = "";
                            if (!string.IsNullOrWhiteSpace(row["linkman"].ToString()))
                            {
                                remark = row["linkman"].ToString();
                            }
                            if (!string.IsNullOrWhiteSpace(row["telephone"].ToString()))
                            {
                                if (!string.IsNullOrWhiteSpace(remark))
                                {
                                    remark += "|" + row["telephone"].ToString();
                                }
                                else
                                {
                                    remark = row["telephone"].ToString();
                                }
                            }
                            #endregion

                            #region 转换体检类别ID


                            Guid? medicalTypeId = null;

                            var oldMedicalTypeId = row["medical_type_id"].ToString();
                            if (!string.IsNullOrWhiteSpace(oldMedicalTypeId))
                            {
                                var medicalTypeIdFieldComparison = medicalTypeIdFieldComparisonList.FirstOrDefault(f => f.OldKeyValue == oldMedicalTypeId);
                                if (medicalTypeIdFieldComparison != null)
                                    medicalTypeId = Guid.Parse(medicalTypeIdFieldComparison.NewKeyValue);
                            }
                            #endregion

                            var data = new CustomerOrg(customerOrgId)
                            {
                                Accounts = row["accounts"].ToString(),
                                Address = row["address"].ToString(),
                                Bank = row["bank"].ToString(),
                                DisplayName = row["org_name"].ToString(),
                                DisplayOrder = oldCustomerOrgList.Rows.IndexOf(row) + 1,
                                Fax = row["fax"].ToString(),
                                InvoiceName = row["org_name"].ToString(),
                                IsActive = 'Y',
                                IsLock = Convert.ToChar(row["lock_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                OrgTypeId = defaultOrgTypeId,  //默认为私营
                                ParentId = parentId,
                                PathCode = _customerOrgManager.CreatePathCode(parentId).Result,
                                PostalCode = row["postalcode"].ToString(),
                                Remark = remark,
                                ShortName = row["short_name"].ToString(),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["org_name"].ToString()),
                                Telephone = row["telephone"].ToString(),
                                CountryOrgCode = row["org_id"].ToString(),
                                SalesPerson = "",
                                SalesPersonPhone = "",
                                MedicalTypeId = medicalTypeId
                            };

                            await _customerOrgRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                FieldName = "id",
                                NewKeyValue = customerOrgId.ToString(),
                                OldKeyValue = row["org_id"].ToString(),
                                TableName = "customer_org"
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"体检单位三级数据处理完毕,处理数量{oldCustomerOrgList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检单位三级数据已存在，未处理");
            }
        }



        /// <summary>
        /// 迁移体检单位数据 四级
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferFourCustomerOrgData()
        {
            var count = (await _customerOrgRepository.GetQueryableAsync()).Where(m => m.PathCode.Length > 17).Count();
            if (count == 0)
            {
                var medicalTypeIdFieldComparisonList = (await _fieldComparisonRepository.GetQueryableAsync())
                  .Where(m => m.TableName == "medical_Type").ToList();

                var oldCustomerOrgList = await oldDb.Ado.GetDataTableAsync("select * from [dbo].[org] where len(org_id)=14 order by org_id asc");
                if (oldCustomerOrgList.Rows.Count > 0)
                {
                    List<CustomerOrg> customerOrgList = await _customerOrgRepository.GetListAsync(m => m.ParentId == null);
                    List<FieldComparison> fieldComparisonList = await _fieldComparisonRepository.GetListAsync(m => m.TableName == "customer_org");

                    foreach (DataRow row in oldCustomerOrgList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            #region 查找上级ID
                            string oldId = row["org_id"].ToString();
                            string oldParentId = oldId.Substring(0, 11);
                            Guid parentId = Guid.Parse(fieldComparisonList.Where(m => m.OldKeyValue == oldParentId).FirstOrDefault().NewKeyValue);
                            #endregion


                            Guid customerOrgId = GuidGenerator.Create();

                            #region 备注  导入联系人姓名、电话
                            string remark = "";
                            if (!string.IsNullOrWhiteSpace(row["linkman"].ToString()))
                            {
                                remark = row["linkman"].ToString();
                            }
                            if (!string.IsNullOrWhiteSpace(row["telephone"].ToString()))
                            {
                                if (!string.IsNullOrWhiteSpace(remark))
                                {
                                    remark += "|" + row["telephone"].ToString();
                                }
                                else
                                {
                                    remark = row["telephone"].ToString();
                                }
                            }
                            #endregion

                            #region 转换体检类别ID


                            Guid? medicalTypeId = null;

                            var oldMedicalTypeId = row["medical_type_id"].ToString();
                            if (!string.IsNullOrWhiteSpace(oldMedicalTypeId))
                            {
                                var medicalTypeIdFieldComparison = medicalTypeIdFieldComparisonList.FirstOrDefault(f => f.OldKeyValue == oldMedicalTypeId);
                                if (medicalTypeIdFieldComparison != null)
                                    medicalTypeId = Guid.Parse(medicalTypeIdFieldComparison.NewKeyValue);
                            }
                            #endregion

                            var data = new CustomerOrg(customerOrgId)
                            {
                                Accounts = row["accounts"].ToString(),
                                Address = row["address"].ToString(),
                                Bank = row["bank"].ToString(),
                                DisplayName = row["org_name"].ToString(),
                                DisplayOrder = oldCustomerOrgList.Rows.IndexOf(row) + 1,
                                Fax = row["fax"].ToString(),
                                InvoiceName = row["org_name"].ToString(),
                                IsActive = 'Y',
                                IsLock = Convert.ToChar(row["lock_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                OrgTypeId = defaultOrgTypeId,  //默认为私营
                                ParentId = parentId,
                                PathCode = _customerOrgManager.CreatePathCode(parentId).Result,
                                PostalCode = row["postalcode"].ToString(),
                                Remark = remark,
                                ShortName = row["short_name"].ToString(),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["org_name"].ToString()),
                                Telephone = row["telephone"].ToString(),
                                CountryOrgCode = row["org_id"].ToString(),
                                SalesPerson = "",
                                SalesPersonPhone = "",
                                MedicalTypeId = medicalTypeId
                            };

                            await _customerOrgRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                FieldName = "id",
                                NewKeyValue = customerOrgId.ToString(),
                                OldKeyValue = row["org_id"].ToString(),
                                TableName = "customer_org"
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"体检单位四级数据处理完毕,处理数量{oldCustomerOrgList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("体检单位四级数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移单位体检次数数据  无字典
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferCustomerOrgRegisterData()
        {
            var count = await _customerOrgRegisterRepository.GetCountAsync();
            if (count == 0)
            {
                var oldCustomerOrgRegisterList = await oldDb.Ado.GetDataTableAsync("select  * from org_medical_register order by org_medical_times");
                if (oldCustomerOrgRegisterList.Rows.Count > 0)
                {
                    List<FieldComparison> fieldComparisonList = await _fieldComparisonRepository.GetListAsync(m => m.TableName == "customer_org");

                    foreach (DataRow row in oldCustomerOrgRegisterList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid customerOrgId = Guid.Parse(fieldComparisonList.Where(m => m.OldKeyValue == row["org_id"].ToString()).FirstOrDefault().NewKeyValue);
                            Guid customerOrgRegisterId = GuidGenerator.Create();

                            if (customerOrgId == GuidFlag.PersonCustomerOrgId)
                                customerOrgRegisterId = GuidFlag.PersonCustomerOrgRegisterId;
                            var data = new CustomerOrgRegister(customerOrgRegisterId)
                            {
                                BeginTime = Convert.ToDateTime(row["start_time"].ToString()),
                                CustomerOrgId = customerOrgId,
                                EndTime = !string.IsNullOrWhiteSpace(row["end_time"].ToString()) ? Convert.ToDateTime(row["end_time"].ToString()) : null,
                                IsComplete = Convert.ToChar(row["complete_flag"].ToString()),
                                MedicalTimes = (short)Convert.ToInt32(row["org_medical_times"].ToString()),
                                RegisterName = "",
                                RegisterNo = ""
                            };

                            await _customerOrgRegisterRepository.InsertAsync(data);

                            await uow.CompleteAsync();
                        }
                    }
                }
                _logger.LogInformation($"单位体检次数数据处理完毕,处理数量{oldCustomerOrgRegisterList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("单位体检次数数据已存在，未处理");
            }
        }

        /// <summary>
        /// 迁移单位分组
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferCustomerOrgGroupData()
        {
            var count = await _customerOrgGroupRepository.GetCountAsync();
            if (count == 0)
            {

                var oldCustomerOrgGroupList = await oldDb.Ado.GetDataTableAsync("select  * from org_group order by display_order asc");
                if (oldCustomerOrgGroupList.Rows.Count > 0)
                {
                    List<FieldComparison> fieldComparisonList = await _fieldComparisonRepository.GetListAsync(m => m.TableName == "customer_org");
                    List<CustomerOrgRegister> customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();

                    foreach (DataRow row in oldCustomerOrgGroupList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            //新系统单位ID
                            Guid customerOrgId = Guid.Parse(fieldComparisonList.Where(m => m.OldKeyValue == row["org_id"].ToString()).FirstOrDefault().NewKeyValue);
                            Guid customerOrgRegisterId = customerOrgRegisterList.Where(m => m.CustomerOrgId == customerOrgId
                            && m.MedicalTimes == (short)Convert.ToInt32(row["org_medical_times"].ToString())).FirstOrDefault().Id;
                            Guid customerOrgGroupId = GuidGenerator.Create();

                            var data = new CustomerOrgGroup(customerOrgGroupId)
                            {
                                AgeLowerLimit = (short)Convert.ToInt32(row["age_lower_limit"].ToString()),
                                AgeUpperLimit = (short)Convert.ToInt32(row["age_upper_limit"].ToString()),
                                CustomerOrgRegisterId = customerOrgRegisterId,
                                DisplayName = row["org_group_name"].ToString(),
                                DisplayOrder = oldCustomerOrgGroupList.Rows.IndexOf(row) + 1,
                                ForSexId = ConvertForSex(row["for_sex_id"].ToString()),
                                JobPost = row["job_post"].ToString(),
                                JobTitle = row["job_title"].ToString(),
                                MaritalStatusId = Convert.ToChar(row["marital_status_id"].ToString()),
                                Price = Convert.ToDecimal(row["price"].ToString()),
                                Remark = row["remark"].ToString(),
                                CanAddMoney = 0
                            };

                            await _customerOrgGroupRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                FieldName = "id",
                                NewKeyValue = customerOrgGroupId.ToString(),
                                OldKeyValue = row["org_group_id"].ToString(),
                                TableName = "customer_org_group"
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }

                    }


                }
                _logger.LogInformation($"单位分组数据处理完毕,处理数量{oldCustomerOrgGroupList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("单位分组数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移单位分组明细数据
        /// </summary>
        /// <returns></returns>
        [RemoteService(false)]
        public async Task TransferCustomerOrgGroupDetailData()
        {
            var count = await _customerOrgGroupDetailRepository.GetCountAsync();
            if (count == 0)
            {

                int pclcount = 200;

                var oldCustomerOrgGroupList = await oldDb.Ado.GetDataTableAsync("select  * from org_group_detail ");
                if (oldCustomerOrgGroupList.Rows.Count > 0)
                {
                    List<CustomerOrgGroupDetail> tempList = new List<CustomerOrgGroupDetail>();

                    foreach (DataRow row in oldCustomerOrgGroupList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            //新系统单位分组ID
                            Guid customerOrgGroupId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                                .Where(m => m.TableName == "customer_org_group" && m.OldKeyValue == row["org_group_id"].ToString()).FirstOrDefault().NewKeyValue);
                            Guid asbitemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                                 .Where(m => m.TableName == "asbitem" && m.OldKeyValue == row["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);

                            decimal price = 0;
                            if (!decimal.TryParse(row["price"].ToString(), out price))
                            {
                                price = 0;
                            }

                            var data = new CustomerOrgGroupDetail
                            {
                                AsbitemId = asbitemId,
                                CustomerOrgGroupId = customerOrgGroupId,
                                Price = price,
                                Amount = 1
                            };

                            tempList.Add(data);

                            if (tempList.Count >= pclcount)
                            {
                                await _customerOrgGroupDetailRepository.InsertManyAsync(tempList);

                                tempList = new List<CustomerOrgGroupDetail>();

                            }
                            else
                            {
                                if (oldCustomerOrgGroupList.Rows.IndexOf(row) == oldCustomerOrgGroupList.Rows.Count - 1)
                                {
                                    await _customerOrgGroupDetailRepository.InsertManyAsync(tempList);
                                }
                            }

                            await uow.CompleteAsync();

                        }

                    }


                }
                _logger.LogInformation($"单位分组明细数据处理完毕,处理数量{oldCustomerOrgGroupList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation("单位分组明细数据已存在，未处理");
            }
        }

        #endregion



        #region 导入业务数据
        [HttpPost("api/app/CCTJExportData/InitFieldComparisonCache")]
        public async Task InitFieldComparisonCache()
        {
            fieldComparisonTempList = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName != "patient_register").ToList();
            asbitemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "asbitem").ToList();
            itemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "item").ToList();
            _customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();
            _userList = await _identityUserRepository.GetListAsync();
            _logger.LogInformation($"组合项目数：{asbitemFieldComparisonTempList.Count},项目数：{itemFieldComparisonTempList.Count}");
        }


        private int hangPatientRegisterCount = 0;
        private int hangPatientRegisterErrorCount = 0;
        private int hangPatientRegisterReverseCount = 0;

        /// <summary>
        /// 迁移人员、检查单、登记项目、项目结果、医生小结、修改人员创建者、创建时间
        /// </summary>
        /// <param name="handCount">每次处理的人员数量</param>
        /// <param name="startdate">开始日期</param>
        /// <param name="enddate">截止日期</param>
        /// <param name="isGo">是否继续处理</param>
        /// <returns></returns>
        [HttpPost("api/app/CCTJExportData/TransferPatientRegisterWithDetailData")]
        [RemoteService(false)]
        public async Task TransferPatientRegisterWithDetailData(int handCount, string startdate, string enddate, bool isGo = false)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            _logger.LogInformation($"开始导入数据");
            //当前导入的ID
            string nextKeyValue = oldDb.Ado.GetString("select keyvalue from tb_export_key where tablename='patient_register' ");

            string sqlPatientRegister = "";

            if (!string.IsNullOrWhiteSpace(startdate) && !string.IsNullOrWhiteSpace(enddate))
            {
                sqlPatientRegister = $"select top {handCount} * from patient_register where patient_register_id>'{nextKeyValue}'" +
                    $" and register_date>='{startdate}' and  register_date<'{enddate}'  order by patient_register_id asc";

            }
            else
            {
                sqlPatientRegister = $"select top {handCount} * from patient_register where patient_register_id>'{nextKeyValue}' order by patient_register_id asc";

            }

            DataTable oldPatientRegisterList = await oldDb.Ado.GetDataTableAsync(sqlPatientRegister);
            stopwatch.Stop();
            _logger.LogInformation($"获取要导入的人员总数耗时：{stopwatch.ElapsedMilliseconds}" + $"共{oldPatientRegisterList.Rows.Count}条");
            if (oldPatientRegisterList.Rows.Count > 0)
            {
                Stopwatch stopwatch2 = new Stopwatch();
                stopwatch2.Start();
                var userList = await _identityUserRepository.GetListAsync();
                List<CustomerOrgRegister> customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();
                stopwatch2.Stop();
                _logger.LogInformation($"获取所有客户单位耗时：{stopwatch2.ElapsedMilliseconds}");
                Stopwatch stopwatch5 = new Stopwatch();
                stopwatch5.Start();
                //Parallel.ForEach(oldPatientRegisterList.AsEnumerable(), row =>
                //{

                //});
                foreach (DataRow row in oldPatientRegisterList.Rows)
                {
                    hangPatientRegisterCount++;
                    await ImportSingle(customerOrgRegisterList, userList, row);
                }


                //await Parallel.ForEachAsync(oldPatientRegisterList.AsEnumerable(), async (row, token) =>
                //{
                //    hangPatientRegisterCount++;
                //    await ImportSingleParallel(customerOrgRegisterList, userList, row);
                //});
                stopwatch5.Stop();
                _logger.LogInformation($"处理完全部人员耗时：{stopwatch5.ElapsedMilliseconds}");
                _logger.LogInformation($"人员数据处理{oldPatientRegisterList.Rows.Count}条,当前总数{hangPatientRegisterCount}");
                if (isGo)
                    await TransferPatientRegisterWithDetailData(handCount, startdate, enddate, isGo);
            }
            else
            {
                _logger.LogInformation("人员数据已处理完,没有查询到需要处理的人员");
            }



        }


        /// <summary>
        /// 人员信息导入
        /// </summary>
        /// <param name="patientRegisterIdFrom"></param>
        /// <param name="patientRegisterIdTo"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost("api/app/CCTJExportData/TransferPatientRegisterWithDetailDataById")]
        public async Task TransferPatientRegisterWithDetailDataById(long patientRegisterIdFrom, long patientRegisterIdTo)
        {

            #region 初始数据
            if (fieldComparisonTempList.Count == 0)
            {
                fieldComparisonTempList = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName != "patient_register").ToList();
                asbitemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "asbitem").ToList();
                itemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "item").ToList();
            }
            if (!_customerOrgRegisterList.Any())
                _customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();
            if (!_userList.Any())
                _userList = await _identityUserRepository.GetListAsync();
            _logger.LogInformation($"组合项目数：{asbitemFieldComparisonTempList.Count},项目数：{itemFieldComparisonTempList.Count}");

            #endregion

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            _logger.LogInformation($"开始导入数据");
            //当前导入的ID
            //string nextKeyValue = oldDb.Ado.GetString("select keyvalue from tb_export_key where tablename='patient_register' ");

            string sqlPatientRegister = "";
            if (patientRegisterIdFrom >= patientRegisterIdTo)
            {
                throw new Exception("开始值必须小于等于结束值");

            }
            var sql = $"select  count(*) as cnt from patient_register where patient_register_id>='{patientRegisterIdFrom}'" +
                  $" and patient_register_id<'{patientRegisterIdTo}' ";

            DataTable oldPatientRegisterCount = await oldDb.Ado.GetDataTableAsync(sql);
            if (oldPatientRegisterCount.Rows.Count == 0)
            {
                return;
            }
            _logger.LogInformation($"共有{oldPatientRegisterCount.Rows[0]["cnt"].ToString()}条");

            sqlPatientRegister = $"select  top 1000 * from patient_register where patient_register_id>='{patientRegisterIdFrom}'" +
                   $" and patient_register_id<'{patientRegisterIdTo}'  order by patient_register_id asc";



            DataTable oldPatientRegisterList = await oldDb.Ado.GetDataTableAsync(sqlPatientRegister);
            stopwatch.Stop();
            _logger.LogInformation($"获取要导入的人员列表耗时：{stopwatch.ElapsedMilliseconds}" + $"共{oldPatientRegisterList.Rows.Count}条");
            //Stopwatch stopwatch2 = new Stopwatch();
            //stopwatch2.Start();
            //var userList = await _identityUserRepository.GetListAsync();
            //List<CustomerOrgRegister> customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();
            //stopwatch2.Stop();
            Stopwatch stopwatch5 = new Stopwatch();
            stopwatch5.Start();
            while (oldPatientRegisterList.Rows.Count > 0)
            {
                foreach (DataRow row in oldPatientRegisterList.Rows)
                {
                    hangPatientRegisterCount++;
                    await ImportSingle(_customerOrgRegisterList, _userList, row);
                }
                patientRegisterIdFrom = Convert.ToInt64(oldPatientRegisterList.Rows[oldPatientRegisterList.Rows.Count - 1]["patient_register_id"]);
                patientRegisterIdFrom++;
                sqlPatientRegister = $"select  top 1000 * from patient_register where patient_register_id>='{patientRegisterIdFrom}'" +
                $" and patient_register_id<'{patientRegisterIdTo}'  order by patient_register_id asc";
                Stopwatch stopwatch6 = new Stopwatch();
                stopwatch6.Start();
                oldPatientRegisterList = await oldDb.Ado.GetDataTableAsync(sqlPatientRegister);
                _logger.LogInformation($"获取要导入的人员列表耗时：{stopwatch6.ElapsedMilliseconds}" + $"共{oldPatientRegisterList.Rows.Count}条");
            }
            stopwatch5.Stop();
            _logger.LogInformation($"处理完全部人员耗时：{stopwatch5.ElapsedMilliseconds}");
            _logger.LogInformation($"人员数据处理{oldPatientRegisterList.Rows.Count}条,当前总数{hangPatientRegisterCount}");



        }
        private async Task ImportSingle(List<CustomerOrgRegister> customerOrgRegisterList, List<IdentityUser> userList, DataRow row)
        {
            try
            {
                Stopwatch stopwatch3 = new Stopwatch();
                stopwatch3.Start();
                using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                {
                    var dbContext = await _dbContextProvider.GetDbContextAsync();
                    //Stopwatch stopwatch31 = new Stopwatch();
                    //stopwatch31.Start();
                    string oldPatientRegisterId = row["patient_register_id"].ToString();
                    string barcodeNo = row["barcode_no"].ToString();
                    //检查是否已经导入
                    var patRegisterLis = await _patientRegisterRepository.GetListAsync(o => o.PatientRegisterNo == barcodeNo);
                    if (patRegisterLis.Count > 0)
                    {
                        return;
                    }
                    //检查是否已经导入
                    //var isDZPatientRegisterTemp = (await _fieldComparisonRepository.GetListAsync(f => f.TableName == "patient_register"
                    //    && f.OldKeyValue == oldPatientRegisterId));


                    //if (isDZPatientRegisterTemp.Count > 0)
                    //{
                    //    return;
                    //    //continue;//并行处理不使用该语句
                    //}



                    //档案ID
                    Guid patientId = Guid.Empty;

                    #region 处理档案，未找到档案就生成

                    var patientEnt = await _patientRepository.FirstOrDefaultAsync(m => m.PatientNo == row["patient_id"].ToString());
                    if (patientEnt == null)
                    {
                        string nationId = null;
                        if (!string.IsNullOrWhiteSpace(row["nation_id"].ToString()))
                        {
                            var nationEnt = fieldComparisonTempList.Where(m => m.TableName == "nation" && m.OldKeyValue == row["nation_id"].ToString()).FirstOrDefault();
                            if (nationEnt == null)
                            {
                                nationId = row["nation_id"].ToString();
                            }
                            else
                            {
                                nationId = nationEnt.NewKeyValue;
                            }
                        }

                        Guid autoPatientId = GuidGenerator.Create();  //档案ID
                        var dataPatient = new Patient(autoPatientId)
                        {
                            Address = row["address"].ToString(),
                            BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                            BirthPlaceId = null,
                            DisplayName = row["name"].ToString(),
                            Email = row["email"].ToString(),
                            IdNo = row["id_card_no"].ToString(),
                            MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                            MedicalCenterId = defaultMedicalCenterId,
                            MobileTelephone = row["mobile_telephone"].ToString(),
                            NationId = nationId,
                            PatientNo = row["patient_id"].ToString(),
                            PatientPassword = row["patient_password"].ToString(),
                            PostalCode = row["postalcode"].ToString(),
                            SexId = ConvertSex(row["sex_id"].ToString()),
                            SimpleCode = LanguageConverter.GetPYSimpleCode(row["name"].ToString()),
                            Telephone = row["telephone"].ToString()
                        };

                        await _patientRepository.InsertAsync(dataPatient, true);
                        patientId = autoPatientId;
                    }
                    else
                    {
                        patientId = patientEnt.Id;
                    }


                    #endregion



                    Guid patientRegisterId = GuidGenerator.Create();  //生成登记ID

                    #region 转换审核医生ID
                    Guid? AuditDoctorId = null;
                    if (!string.IsNullOrWhiteSpace(row["audit_doctor"].ToString()))
                    {
                        var userEnt = userList.Where(m => m.Name == row["audit_doctor"].ToString().Trim()
                          || m.Surname == row["audit_doctor"].ToString().Trim()
                          || m.UserName == row["audit_doctor"].ToString().Trim()).FirstOrDefault();
                        if (userEnt != null)
                        {
                            AuditDoctorId = userEnt.Id;
                        }
                    }
                    #endregion

                    #region 转换单位分组ID
                    Guid? customerOrgGroupId = null;
                    if (!string.IsNullOrWhiteSpace(row["org_group_id"].ToString()))
                    {

                        var customerOrgGroupEnt = fieldComparisonTempList.Where(m => m.TableName == "customer_org_group" && m.OldKeyValue == row["org_group_id"].ToString()).FirstOrDefault();
                        if (customerOrgGroupEnt != null)
                        {
                            customerOrgGroupId = Guid.Parse(customerOrgGroupEnt.NewKeyValue);
                        }

                    }
                    #endregion

                    #region 转换单位ID  部门
                    Guid customerOrgId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString()).FirstOrDefault().NewKeyValue);
                    #endregion

                    #region 转换单位体检次数ID   没有增加默认值
                    Guid customerOrgRegisterId = GuidFlag.PersonCustomerOrgRegisterId;
                    if (row["org_id"].ToString() != "00000")
                    {
                        Guid topCustomerOrgId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString().Substring(0, 5)).FirstOrDefault().NewKeyValue);
                        var customerOrgRegisterEnt = customerOrgRegisterList.Where(m => m.CustomerOrgId == topCustomerOrgId
                            && m.MedicalTimes == (short)Convert.ToInt32(row["org_medical_times"].ToString())).FirstOrDefault();
                        if (customerOrgRegisterEnt != null)
                        {
                            customerOrgRegisterId = customerOrgRegisterEnt.Id;
                        }
                    }

                    #endregion

                    #region 转换体检结论ID   
                    Guid? medicalConclusionId = null;
                    if (!string.IsNullOrWhiteSpace(row["medical_conclusion_id"].ToString()))
                    {
                        var medicalConclusionEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_conclusion"
                            && m.OldKeyValue == row["medical_conclusion_id"].ToString()).FirstOrDefault();
                        if (medicalConclusionEnt != null)
                        {
                            medicalConclusionId = Guid.Parse(medicalConclusionEnt.NewKeyValue);
                        }
                    }
                    #endregion

                    #region 转换套餐ID
                    Guid? medicalPackageId = null;
                    if (!string.IsNullOrWhiteSpace(row["medical_package_id"].ToString()))
                    {
                        var medicalPackageEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_package" && m.OldKeyValue == row["medical_package_id"].ToString()).FirstOrDefault();
                        if (medicalPackageEnt != null)
                        {
                            medicalPackageId = Guid.Parse(medicalPackageEnt.NewKeyValue);
                        }
                    }
                    #endregion

                    #region 转换体检类别ID
                    Guid? medicalTypeId = null;
                    if (!string.IsNullOrWhiteSpace(row["medical_type_id"].ToString()))
                    {
                        var medicalTypeEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_type" && m.OldKeyValue == row["medical_type_id"].ToString()).FirstOrDefault();
                        if (medicalTypeEnt != null)
                        {
                            medicalTypeId = Guid.Parse(medicalTypeEnt.NewKeyValue);
                        }
                    }
                    #endregion



                    #region 转换人员类别ID
                    Guid? personnelTypeId = null;
                    if (!string.IsNullOrWhiteSpace(row["personnel_type_id"].ToString()))
                    {
                        var personnelTypeEnt = fieldComparisonTempList.Where(m => m.TableName == "personnel_type" && m.OldKeyValue == row["personnel_type_id"].ToString()).FirstOrDefault();
                        if (personnelTypeEnt != null)
                        {
                            personnelTypeId = Guid.Parse(personnelTypeEnt.NewKeyValue);
                        }
                    }
                    #endregion

                    #region 转换总检医生ID
                    Guid? summaryDoctorId = null;
                    if (!string.IsNullOrWhiteSpace(row["summary_doctor"].ToString()))
                    {
                        var userEnt = userList.Where(m => m.Name == row["summary_doctor"].ToString().Trim()
                          || m.Surname == row["summary_doctor"].ToString().Trim()
                          || m.UserName == row["summary_doctor"].ToString().Trim()).FirstOrDefault();
                        if (userEnt != null)
                        {
                            summaryDoctorId = userEnt.Id;
                        }
                    }
                    #endregion


                    #region 上传图片，获取地址

                    string photo = "";
                    if (!string.IsNullOrEmpty(row["photograph"].ToString()))
                    {
                        photo = UpLoadImg(patientRegisterId, Convert.ToDateTime(row["register_date"].ToString()), (byte[])row["photograph"]);
                    }

                    #endregion

                    var data = new PatientRegister(patientRegisterId)
                    {
                        BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                        MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                        MedicalCenterId = defaultMedicalCenterId,
                        SexId = ConvertSex(row["sex_id"].ToString()),
                        Age = string.IsNullOrWhiteSpace(row["age"].ToString()) ? null : Convert.ToInt16(row["age"].ToString()),
                        AuditDate = string.IsNullOrWhiteSpace(row["audit_date"].ToString()) ? null : Convert.ToDateTime(row["audit_date"].ToString()),
                        AuditDoctorId = AuditDoctorId,
                        CompleteFlag = Convert.ToChar(row["complete_flag"].ToString()),
                        CustomerOrgGroupId = customerOrgGroupId,
                        CustomerOrgId = customerOrgId,
                        CustomerOrgRegisterId = customerOrgRegisterId,
                        GuidePrintTimes = string.IsNullOrWhiteSpace(row["instruct_print_times"].ToString()) ? (short)0 : Convert.ToInt16(row["instruct_print_times"].ToString()),
                        InterposeMeasure = null,
                        IsAudit = string.IsNullOrWhiteSpace(row["audit_flag"].ToString()) ? 'N' : Convert.ToChar(row["audit_flag"].ToString()),
                        IsLock = string.IsNullOrWhiteSpace(row["lock_flag"].ToString()) ? 'N' : Convert.ToChar(row["lock_flag"].ToString()),
                        IsMedicalStart = string.IsNullOrWhiteSpace(row["medical_start_flag"].ToString()) ? 'N' : Convert.ToChar(row["medical_start_flag"].ToString()),
                        IsNameHide = string.IsNullOrWhiteSpace(row["name_encrypt_flag"].ToString()) ? 'N' : Convert.ToChar(row["name_encrypt_flag"].ToString()),
                        IsPhoneFollow = 'N',
                        IsRecoverGuide = string.IsNullOrWhiteSpace(row["recover_form_flag"].ToString()) ? 'N' : Convert.ToChar(row["recover_form_flag"].ToString()),
                        IsUpload = string.IsNullOrWhiteSpace(row["upload_flag"].ToString()) ? 'N' : Convert.ToChar(row["upload_flag"].ToString()),
                        IsVip = string.IsNullOrWhiteSpace(row["vip_flag"].ToString()) ? 'N' : Convert.ToChar(row["vip_flag"].ToString()),
                        JobCardNo = row["job_card_no"].ToString(),
                        JobPost = row["job_post"].ToString(),
                        JobTitle = row["job_title"].ToString(),
                        MedicalCardNo = row["medical_card_no"].ToString(),
                        MedicalConclusionId = medicalConclusionId,
                        MedicalPackageId = medicalPackageId,
                        MedicalStartDate = string.IsNullOrEmpty(row["medical_start_date"].ToString()) ? null : Convert.ToDateTime(row["medical_start_date"].ToString()),
                        MedicalTimes = Convert.ToInt16(row["medical_times"].ToString()),
                        MedicalTypeId = medicalTypeId,
                        PatientId = patientId,
                        PatientName = row["name"].ToString(),
                        PatientRegisterNo = row["barcode_no"].ToString(),
                        PersonnelTypeId = personnelTypeId,
                        Photo = photo,
                        Remark = row["remark"].ToString(),
                        ReportPrintTimes = Convert.ToInt16(row["report_print_times"].ToString()),
                        Salesman = row["salesman"].ToString(),
                        SexHormoneTermId = null,
                        SummaryDate = string.IsNullOrEmpty(row["summary_date"].ToString()) ? null : Convert.ToDateTime(row["summary_date"].ToString()),
                        SummaryDoctorId = summaryDoctorId,
                        ThirdInfo = row["third_info"].ToString(),
                    };
                    await _patientRegisterRepository.InsertAsync(data, true);

                    //stopwatch31.Stop();
                    //_logger.LogInformation($"{row["patient_register_id"]}_第31片段耗时：{stopwatch31.ElapsedMilliseconds}");

                    //Stopwatch stopwatch32 = new Stopwatch();
                    //stopwatch32.Start();

                    #region 登记的项目、结果、小结

                    var oldRegisterAsbitemList = await oldDb.Ado.GetDataTableAsync($"select * from register_asbitem where patient_register_id='{row["patient_register_id"].ToString()}'");

                    if (oldRegisterAsbitemList.Rows.Count > 0)
                    {
                        var oldRegisterCheckItemListAll = await oldDb.Ado.GetDataTableAsync($"select * from register_item where patient_register_id='{row["patient_register_id"].ToString()}'");

                        var registerCheckList = new List<RegisterCheck>();
                        var registerCheckAsbitemList = new List<RegisterCheckAsbitem>();
                        var registerCheckItemList = new List<RegisterCheckItem>();
                        var registerCheckSummaryList = new List<RegisterCheckSummary>();
                        var registerCheckPictureList = new List<RegisterCheckPicture>();
                        foreach (DataRow rowAsbitem in oldRegisterAsbitemList.Rows)
                        {
                            //Stopwatch stopwatch34 = new Stopwatch();
                            //stopwatch34.Start();
                            #region 转换审核医生ID
                            Guid? auditorUserId = null;
                            if (!string.IsNullOrWhiteSpace(rowAsbitem["audit_doctor"].ToString()))
                            {
                                var userEnt = userList.Where(m => m.Name == rowAsbitem["audit_doctor"].ToString().Trim()
                                || m.Surname == rowAsbitem["audit_doctor"].ToString().Trim()
                                || m.UserName == rowAsbitem["audit_doctor"].ToString().Trim()).FirstOrDefault();
                                if (userEnt != null)
                                {
                                    auditorUserId = userEnt.Id;
                                }
                            }
                            #endregion

                            #region 转换检查医生ID
                            string checkDoctorId = null;
                            if (!string.IsNullOrWhiteSpace(rowAsbitem["check_doctor"].ToString()))
                            {
                                var userEnt = userList.Where(m => m.Name == rowAsbitem["check_doctor"].ToString().Trim()
                                 || m.Surname == rowAsbitem["check_doctor"].ToString().Trim()
                                 || m.UserName == rowAsbitem["check_doctor"].ToString().Trim()).FirstOrDefault();
                                if (userEnt != null)
                                {
                                    checkDoctorId = userEnt.Id.ToString();
                                }
                                else
                                {
                                    checkDoctorId = rowAsbitem["check_doctor"].ToString().Trim();
                                }
                            }
                            #endregion

                            #region 转换组合项目ID
                            Guid newAsbitemId = Guid.Parse(asbitemFieldComparisonTempList.Where(m => m.OldKeyValue == rowAsbitem["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);
                            #endregion

                            //stopwatch34.Stop();
                            //_logger.LogInformation($"{row["patient_register_id"]}_第34片段耗时：{stopwatch34.ElapsedMilliseconds}");
                            #region 插入register_check
                            Guid registerCheckId = GuidGenerator.Create();
                            var dataRegisterCheck = new RegisterCheck(registerCheckId)
                            {
                                AuditorUserId = auditorUserId,
                                AuditTime = string.IsNullOrEmpty(rowAsbitem["audit_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["audit_date"].ToString()),
                                CheckDate = string.IsNullOrEmpty(rowAsbitem["check_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["check_date"].ToString()),
                                CheckDoctorId = checkDoctorId,
                                CheckRequestNo = "",
                                CheckRequestPrintTimes = (short)1,
                                CompleteFlag = Convert.ToChar(rowAsbitem["complete_flag"].ToString()),
                                CriticalRangeValue = null,
                                //CriticalValueCreateDate = null,
                                IsCriticalValue = null,
                                CriticalValueContent = null,
                                //CriticalValueProcessDate = null,
                                //CriticalValueProcessDoctor = null,
                                //CriticalValueProcessFlag = null,
                                IsAudit = string.IsNullOrEmpty(rowAsbitem["audit_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["audit_flag"].ToString()),
                                IsLock = string.IsNullOrEmpty(rowAsbitem["lock_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["lock_flag"].ToString()),
                                PatientRegisterId = patientRegisterId,
                                ThirdInfo = rowAsbitem["third_info"].ToString()
                            };

                            //await _registerCheckRepository.InsertAsync(dataRegisterCheck, true);
                            dataRegisterCheck.SetCreateId(_currentUser.Id);
                            dataRegisterCheck.SetCreationTime(DateTime.Now);
                            dataRegisterCheck.SetLastModifierId(_currentUser.Id);
                            dataRegisterCheck.SetLastModificationTime(DateTime.Now);
                            registerCheckList.Add(dataRegisterCheck);
                            #endregion



                            #region 插入register_check_asbitem
                            Guid registerCheckAsbitemId = GuidGenerator.Create();

                            var dataRegisterAsbitem = new RegisterCheckAsbitem(registerCheckAsbitemId)
                            {
                                Amount = 1,
                                IsCharge = Convert.ToChar(rowAsbitem["charge_flag"].ToString()),
                                AsbitemId = newAsbitemId,
                                ChargePrice = Convert.ToDecimal(rowAsbitem["price"].ToString()),
                                GroupPackageId = null,
                                LisRequestId = null,
                                PatientRegisterId = patientRegisterId,
                                PayTypeFlag = Convert.ToChar(rowAsbitem["payment_mode"].ToString()),
                                RegisterCheckId = registerCheckId,
                                StandardPrice = Convert.ToDecimal(rowAsbitem["standard_price"].ToString()),

                            };

                            //await _registerCheckAsbitemRepository.InsertAsync(dataRegisterAsbitem);

                            dataRegisterAsbitem.SetCreateId(_currentUser.Id);
                            dataRegisterAsbitem.SetCreationTime(DateTime.Now);
                            dataRegisterAsbitem.SetLastModifierId(_currentUser.Id);
                            dataRegisterAsbitem.SetLastModificationTime(DateTime.Now);
                            registerCheckAsbitemList.Add(dataRegisterAsbitem);
                            #endregion


                            #region 插入医生小结


                            var oldSummary = rowAsbitem["summary"].ToString();
                            if (!string.IsNullOrWhiteSpace(oldSummary))
                            {
                                Guid dataRegisterCheckSummaryId = GuidGenerator.Create();
                                var dataRegisterCheckSummary = new RegisterCheckSummary(dataRegisterCheckSummaryId)
                                {
                                    RegisterCheckId = registerCheckId,
                                    DisplayOrder = 1,
                                    Summary = oldSummary,
                                    SummaryFlag = '0'
                                };

                                //await _registerCheckSummaryRepository.InsertAsync(dataRegisterCheckSummary);

                                dataRegisterCheckSummary.SetCreateId(_currentUser.Id);
                                dataRegisterCheckSummary.SetCreationTime(DateTime.Now);
                                dataRegisterCheckSummary.SetLastModifierId(_currentUser.Id);
                                dataRegisterCheckSummary.SetLastModificationTime(DateTime.Now);
                                registerCheckSummaryList.Add(dataRegisterCheckSummary);
                            }

                            #endregion

                            #region 插入检查图片

                            string sql_check_picture = $"select * from check_picture where patient_register_id='{row["patient_register_id"]}' and asbitem_id='{rowAsbitem["asbitem_id"]}' ";
                            DataTable dt_check_picture = await oldDb.Ado.GetDataTableAsync(sql_check_picture);
                            if (dt_check_picture.Rows.Count > 0)
                            {
                                foreach (DataRow checkPictureRow in dt_check_picture.Rows)
                                {
                                    Guid tempRegisterCheckPictureId = GuidGenerator.Create();
                                    var fileName = checkPictureRow["picture_filename"].ToString();
                                    fileName = fileName.Replace("\\\\192.168.0.3", "").Replace(@"\", "/").Replace("//", "/");
                                    var tempRegisterCheckPicture = new RegisterCheckPicture(tempRegisterCheckPictureId)
                                    {
                                        DisplayOrder = dt_check_picture.Rows.IndexOf(checkPictureRow) + 1,
                                        IsPrint = 'Y',
                                        LocalPathName = "",
                                        PictureFileType = '0',
                                        PictureFilename = fileName,
                                        RegisterCheckId = registerCheckId
                                    };
                                    tempRegisterCheckPicture.SetCreateId(_currentUser.Id);
                                    tempRegisterCheckPicture.SetCreationTime(DateTime.Now);
                                    tempRegisterCheckPicture.SetLastModifierId(_currentUser.Id);
                                    tempRegisterCheckPicture.SetLastModificationTime(DateTime.Now);
                                    registerCheckPictureList.Add(tempRegisterCheckPicture);
                                }
                            }

                            #endregion


                            #region 插入明细项目
                            oldRegisterCheckItemListAll.DefaultView.RowFilter = $"asbitem_id={rowAsbitem["asbitem_id"].ToString()}";
                            var oldRegisterCheckItemList = oldRegisterCheckItemListAll.DefaultView.ToTable();
                            //var oldRegisterCheckItemList = await oldDb.Ado.GetDataTableAsync($"select * from register_item where patient_register_id='{row["patient_register_id"].ToString()}' and asbitem_id='{rowAsbitem["asbitem_id"].ToString()}'");

                            if (oldRegisterCheckItemList.Rows.Count > 0)
                            {

                                foreach (DataRow rowRegisterCheckItem in oldRegisterCheckItemList.Rows)
                                {
                                    #region 转换项目ID  老转新
                                    Guid newItemId = Guid.Parse(itemFieldComparisonTempList.Where(m => m.OldKeyValue == rowRegisterCheckItem["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                                    #endregion


                                    var dataRegisterCheckItem = new RegisterCheckItem
                                    {
                                        CheckDate = string.IsNullOrEmpty(rowRegisterCheckItem["check_date"].ToString()) ? null : Convert.ToDateTime(rowRegisterCheckItem["check_date"].ToString()),
                                        CriticalValue = null,
                                        CheckDoctorName = rowRegisterCheckItem["check_doctor"].ToString().Trim(),
                                        CriticalRangeValue = null,
                                        ItemId = newItemId,
                                        ReferenceRangeValue = rowRegisterCheckItem["reference_range_value"].ToString(),
                                        RegisterCheckId = registerCheckId,
                                        Result = rowRegisterCheckItem["result"].ToString(),
                                        ResultStatusId = _registerCheckItemManager.GetResultStatusId(rowRegisterCheckItem["result"].ToString(), rowRegisterCheckItem["reference_range_value"].ToString()),
                                        Unit = rowRegisterCheckItem["Unit"].ToString()
                                    };

                                    //await _registerCheckItemRepository.InsertAsync(dataRegisterCheckItem);
                                    dataRegisterCheckItem.SetCreateId(_currentUser.Id);
                                    dataRegisterCheckItem.SetCreationTime(DateTime.Now);
                                    dataRegisterCheckItem.SetLastModifierId(_currentUser.Id);
                                    dataRegisterCheckItem.SetLastModificationTime(DateTime.Now);
                                    registerCheckItemList.Add(dataRegisterCheckItem);
                                }

                            }



                            #endregion



                        }

                        //await _registerCheckRepository.InsertManyAsync(registerCheckList, true);
                        //await _registerCheckAsbitemRepository.InsertManyAsync(registerCheckAsbitemList, true);
                        //if (registerCheckSummaryList.Count > 0)
                        //{
                        //    await _registerCheckSummaryRepository.InsertManyAsync(registerCheckSummaryList, true);
                        //}
                        //if (registerCheckItemList.Count > 0)
                        //{
                        //    await _registerCheckItemRepository.InsertManyAsync(registerCheckItemList, true);
                        //}


                        await dbContext.BulkInsertAsync<RegisterCheck>(registerCheckList, new BulkConfig
                        {
                            PreserveInsertOrder = false, // 如果不需要顺序，可以关掉
                            SetOutputIdentity = false,   // Guid 主键时一定要关掉
                            BatchSize = 10000,           // 大数据量时调整批次大小
                            TrackingEntities = false     // 禁用跟踪，加快速度
                        });



                        await dbContext.BulkInsertAsync<RegisterCheckAsbitem>(registerCheckAsbitemList, new BulkConfig
                        {
                            PreserveInsertOrder = false, // 如果不需要顺序，可以关掉
                            SetOutputIdentity = false,   // Guid 主键时一定要关掉
                            BatchSize = 10000,           // 大数据量时调整批次大小
                            TrackingEntities = false     // 禁用跟踪，加快速度
                        });
                        if (registerCheckSummaryList.Count > 0)
                        {
                            await dbContext.BulkInsertAsync<RegisterCheckSummary>(registerCheckSummaryList, new BulkConfig
                            {
                                PreserveInsertOrder = false, // 如果不需要顺序，可以关掉
                                SetOutputIdentity = false,   // Guid 主键时一定要关掉
                                BatchSize = 10000,           // 大数据量时调整批次大小
                                TrackingEntities = false     // 禁用跟踪，加快速度
                            });
                        }

                        if (registerCheckItemList.Count > 0)
                        {
                            await dbContext.BulkInsertAsync<RegisterCheckItem>(registerCheckItemList, new BulkConfig
                            {
                                PreserveInsertOrder = false, // 如果不需要顺序，可以关掉
                                SetOutputIdentity = false,   // Guid 主键时一定要关掉
                                BatchSize = 10000,           // 大数据量时调整批次大小
                                TrackingEntities = false     // 禁用跟踪，加快速度
                            });

                        }
                        if (registerCheckPictureList.Count > 0)
                        {
                            await dbContext.BulkInsertAsync<RegisterCheckPicture>(registerCheckPictureList, new BulkConfig
                            {
                                PreserveInsertOrder = false, // 如果不需要顺序，可以关掉
                                SetOutputIdentity = false,   // Guid 主键时一定要关掉
                                BatchSize = 10000,           // 大数据量时调整批次大小
                                TrackingEntities = false     // 禁用跟踪，加快速度
                            });
                        }
                    }


                    #endregion

                    //stopwatch32.Stop();
                    //_logger.LogInformation($"{row["patient_register_id"]}_第32片段耗时：{stopwatch32.ElapsedMilliseconds}");


                    #region 总检建议、综述、总检诊断


                    var oldSum = await oldDb.Ado.GetDataTableAsync($"select summary,suggestion,barcode_no from patient_register where patient_register_id='{oldPatientRegisterId}' ");

                    if (oldSum.Rows.Count == 1)
                    {
                        string oldSummary = oldSum.Rows[0][0].ToString();
                        string oldSuggestion = oldSum.Rows[0][1].ToString();

                        if (!string.IsNullOrWhiteSpace(oldSummary))
                        {

                            Guid sumSummaryHeaderId = GuidGenerator.Create();

                            var dataSumSummaryHeader = new SumSummaryHeader(sumSummaryHeaderId)
                            {
                                DisplayOrder = 1,
                                SummaryFlag = '0',
                                PatientRegisterId = patientRegisterId,
                                SummaryTitle = "异常结果如下"
                            };

                            await _sumSummaryHeaderRepository.InsertAsync(dataSumSummaryHeader);

                            Guid sumSummaryContentId = GuidGenerator.Create();
                            var dataSumSummaryContent = new SumSummaryContent(sumSummaryContentId)
                            {
                                DisplayOrder = 1,
                                SumSummaryHeaderId = sumSummaryHeaderId,
                                SummaryContent = oldSummary
                            };

                            await _sumSummaryContentRepository.InsertAsync(dataSumSummaryContent);

                        }


                        if (!string.IsNullOrWhiteSpace(oldSuggestion))
                        {

                            Guid sumSuggestionHeaderId = GuidGenerator.Create();

                            var dataSumSuggestionHeader = new SumSuggestionHeader(sumSuggestionHeaderId)
                            {
                                DisplayOrder = 1,
                                SuggestionFlag = '0',
                                PatientRegisterId = patientRegisterId,
                                SuggestionTitle = "健康建议如下"
                            };

                            await _sumSuggestionHeaderRepository.InsertAsync(dataSumSuggestionHeader);

                            Guid sumSuggestionContentId = GuidGenerator.Create();
                            var dataSumSuggestionContent = new SumSuggestionContent(sumSuggestionContentId)
                            {
                                DisplayOrder = 1,
                                SuggestionContent = oldSuggestion,
                                SuggestionType = SuggestionTypeFlag.HealthGuidance,
                                SumSuggestionHeaderId = sumSuggestionHeaderId
                            };

                            await _sumSuggestionContentRepository.InsertAsync(dataSumSuggestionContent);



                            #region 总症诊断
                            var oldSummaryDiagnosis = await oldDb.Ado.GetDataTableAsync($"select diagnosis_id from summary_diagnosis where patient_register_id='{oldPatientRegisterId}' order by display_order asc ");

                            if (oldSummaryDiagnosis.Rows.Count > 0)
                            {
                                List<SumDiagnosis> sumDiagnosisInsert = new List<SumDiagnosis>();

                                foreach (DataRow summaryDiagnosis in oldSummaryDiagnosis.Rows)
                                {
                                    var diagnosisEnt = fieldComparisonTempList.Where(m => m.TableName == "diagnosis" && m.OldKeyValue == summaryDiagnosis["diagnosis_id"].ToString()).FirstOrDefault();
                                    if (diagnosisEnt != null)
                                    {

                                        var dataSumDiagnosis = new SumDiagnosis
                                        {
                                            DisplayOrder = oldSummaryDiagnosis.Rows.IndexOf(summaryDiagnosis) + 1,
                                            PatientRegisterId = patientRegisterId,
                                            DiagnosisId = Guid.Parse(diagnosisEnt.NewKeyValue),
                                            SumSuggestionHeaderId = sumSuggestionHeaderId
                                        };

                                        sumDiagnosisInsert.Add(dataSumDiagnosis);


                                    }


                                }

                                if (sumDiagnosisInsert.Any())
                                    await _sumDiagnosisRepository.InsertManyAsync(sumDiagnosisInsert);

                            }
                            #endregion


                        }


                    }


                    #endregion

                    /* 已不需要，暂时屏蔽
                    var fieldComparison = new FieldComparison
                    {
                        FieldName = "id",
                        NewKeyValue = patientRegisterId.ToString(),
                        OldKeyValue = row["patient_register_id"].ToString(),
                        TableName = "patient_register"
                    };


                    await _fieldComparisonRepository.InsertAsync(fieldComparison);


                    await oldDb.Ado.ExecuteCommandAsync($"update  tb_export_key set  keyvalue='{row["patient_register_id"].ToString()}',addtime=getdate(),handlecount+=1 where tablename='patient_register' ");
                    */
                    await uow.CompleteAsync();


                    #region 修改创建者日期跟id
                    Guid registerDoctorId = Guid.Parse(_configuration.GetValue<string>("AdminId"));
                    var registerDoctorEnt = userList.Where(m => m.Name == row["register_doctor"].ToString().Trim()).FirstOrDefault();
                    if (registerDoctorEnt != null)
                    {
                        registerDoctorId = registerDoctorEnt.Id;
                    }
                    string sql_update = $"update patient_register set creator_id='{registerDoctorId}',creation_time='{Convert.ToDateTime(row["register_date"]).ToString("yyyy-MM-dd HH:mm:ss")}'";
                    sql_update += $" where id='{patientRegisterId}' ";
                    await newDb.Ado.ExecuteCommandAsync(sql_update);
                    #endregion
                    ;
                }
                stopwatch3.Stop();
                _logger.LogInformation($"{row["patient_register_id"]}_处理单个人总耗时：{stopwatch3.ElapsedMilliseconds}");
            }
            catch (Exception ex)
            {
                hangPatientRegisterErrorCount++;
                _logger.LogInformation($"数据处理失败，人员id为：{row["patient_register_id"]}");
                #region 添加到tb_error_log表
                await oldDb.Ado.ExecuteCommandAsync($"insert into  tb_error_log(old_patient_register_id,error_message,addtime) values ('{row["patient_register_id"]}','{ex.StackTrace}',getdate()) ");
                #endregion
            }
        }


        /// <summary>
        /// 失败人员处理
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/CCTJExportData/HandErrorPatientRegisterData")]
        public async Task HandErrorPatientRegisterData()
        {
            string sql_error = "select old_patient_register_id from tb_error_log";
            var errorPatientRegister = await oldDb.Ado.GetDataTableAsync(sql_error);
            if (errorPatientRegister.Rows.Count > 0)
            {
                if (fieldComparisonTempList.Count == 0)
                {
                    fieldComparisonTempList = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName != "patient_register").ToList();
                    asbitemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "asbitem").ToList();
                    itemFieldComparisonTempList = fieldComparisonTempList.Where(o => o.TableName == "item").ToList();
                }

                if (!_customerOrgRegisterList.Any())
                    _customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();
                if (!_userList.Any())
                    _userList = await _identityUserRepository.GetListAsync();

                foreach (DataRow row in errorPatientRegister.Rows)
                {
                    string sql = $"select * from patient_register where patient_register_id={row["old_patient_register_id"]}";
                    var tempdt = await oldDb.Ado.GetDataTableAsync(sql);
                    if (tempdt.Rows.Count > 0)
                    {
                        await ImportSingle(_customerOrgRegisterList, _userList, tempdt.Rows[0]);
                    }
                    await oldDb.Ado.ExecuteCommandAsync($"delete from tb_error_log where old_patient_register_id='{row["old_patient_register_id"]}'");
                }

            }

        }

        private async Task ImportSingleParallel(List<CustomerOrgRegister> customerOrgRegisterList, List<IdentityUser> userList, DataRow row)
        {
            try
            {
                Stopwatch stopwatch3 = new Stopwatch();
                stopwatch3.Start();

                using (var scope = _serviceScopeFactory.CreateScope())
                {
                    var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
                    using (var uow = unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                    {
                        using (var oldDb2 = new SqlSugarClient(new ConnectionConfig()
                        {
                            ConnectionString = "server=192.168.0.3;uid=sa;pwd=132****6302;database=oldPeis;Encrypt=false;",
                            DbType = SqlSugar.DbType.SqlServer,
                            IsAutoCloseConnection = true
                        }))
                        {
                            using (var newDb2 = new SqlSugarClient(new ConnectionConfig()
                            {
                                ConnectionString = "Host=192.168.0.188;Port=5432;Database=ShentunPeis;User ID=postgres;Password=St123456;",
                                DbType = SqlSugar.DbType.PostgreSQL,
                                IsAutoCloseConnection = true
                            }))
                            {


                                Stopwatch stopwatch31 = new Stopwatch();
                                stopwatch31.Start();
                                string oldPatientRegisterId = row["patient_register_id"].ToString();

                                //检查是否已经导入
                                var isDZPatientRegisterTemp = (await _fieldComparisonRepository.GetListAsync(f => f.TableName == "patient_register"
                                    && f.OldKeyValue == oldPatientRegisterId));


                                if (isDZPatientRegisterTemp.Count > 0)
                                {
                                    return;
                                    //continue;//并行处理不使用该语句
                                }



                                //档案ID
                                Guid patientId = Guid.Empty;

                                #region 处理档案，未找到档案就生成

                                var patientEnt = await _patientRepository.FirstOrDefaultAsync(m => m.PatientNo == row["patient_id"].ToString());
                                if (patientEnt == null)
                                {
                                    string nationId = null;
                                    if (!string.IsNullOrWhiteSpace(row["nation_id"].ToString()))
                                    {
                                        var nationEnt = fieldComparisonTempList.Where(m => m.TableName == "nation" && m.OldKeyValue == row["nation_id"].ToString()).FirstOrDefault();
                                        if (nationEnt == null)
                                        {
                                            nationId = row["nation_id"].ToString();
                                        }
                                        else
                                        {
                                            nationId = nationEnt.NewKeyValue;
                                        }
                                    }

                                    Guid autoPatientId = GuidGenerator.Create();  //档案ID
                                    var patientRepository = scope.ServiceProvider.GetRequiredService<IRepository<Patient, Guid>>();
                                    var dataPatient = new Patient(autoPatientId)
                                    {
                                        Address = row["address"].ToString(),
                                        BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                                        BirthPlaceId = null,
                                        DisplayName = row["name"].ToString(),
                                        Email = row["email"].ToString(),
                                        IdNo = row["id_card_no"].ToString(),
                                        MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                                        MedicalCenterId = defaultMedicalCenterId,
                                        MobileTelephone = row["mobile_telephone"].ToString(),
                                        NationId = nationId,
                                        PatientNo = row["patient_id"].ToString(),
                                        PatientPassword = row["patient_password"].ToString(),
                                        PostalCode = row["postalcode"].ToString(),
                                        SexId = ConvertSex(row["sex_id"].ToString()),
                                        SimpleCode = LanguageConverter.GetPYSimpleCode(row["name"].ToString()),
                                        Telephone = row["telephone"].ToString()
                                    };

                                    await patientRepository.InsertAsync(dataPatient, true);
                                    patientId = autoPatientId;
                                }
                                else
                                {
                                    patientId = patientEnt.Id;
                                }


                                #endregion



                                Guid patientRegisterId = GuidGenerator.Create();  //生成登记ID

                                #region 转换审核医生ID
                                Guid? AuditDoctorId = null;
                                if (!string.IsNullOrWhiteSpace(row["audit_doctor"].ToString()))
                                {
                                    var userEnt = userList.Where(m => m.Name == row["audit_doctor"].ToString().Trim()).FirstOrDefault();
                                    if (userEnt != null)
                                    {
                                        AuditDoctorId = userEnt.Id;
                                    }
                                }
                                #endregion

                                #region 转换单位分组ID
                                Guid? customerOrgGroupId = null;
                                if (!string.IsNullOrWhiteSpace(row["org_group_id"].ToString()))
                                {

                                    var customerOrgGroupEnt = fieldComparisonTempList.Where(m => m.TableName == "customer_org_group" && m.OldKeyValue == row["org_group_id"].ToString()).FirstOrDefault();
                                    if (customerOrgGroupEnt != null)
                                    {
                                        customerOrgGroupId = Guid.Parse(customerOrgGroupEnt.NewKeyValue);
                                    }

                                }
                                #endregion

                                #region 转换单位ID  部门
                                Guid customerOrgId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString()).FirstOrDefault().NewKeyValue);
                                #endregion

                                #region 转换单位体检次数ID   没有增加默认值
                                Guid customerOrgRegisterId = GuidFlag.PersonCustomerOrgRegisterId;
                                if (row["org_id"].ToString() != "00000")
                                {
                                    Guid topCustomerOrgId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString().Substring(0, 5)).FirstOrDefault().NewKeyValue);
                                    var customerOrgRegisterEnt = customerOrgRegisterList.Where(m => m.CustomerOrgId == topCustomerOrgId
                                        && m.MedicalTimes == (short)Convert.ToInt32(row["org_medical_times"].ToString())).FirstOrDefault();
                                    if (customerOrgRegisterEnt != null)
                                    {
                                        customerOrgRegisterId = customerOrgRegisterEnt.Id;
                                    }
                                }

                                #endregion

                                #region 转换体检结论ID   
                                Guid? medicalConclusionId = null;
                                if (!string.IsNullOrWhiteSpace(row["medical_conclusion_id"].ToString()))
                                {
                                    var medicalConclusionEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_conclusion"
                                        && m.OldKeyValue == row["medical_conclusion_id"].ToString()).FirstOrDefault();
                                    if (medicalConclusionEnt != null)
                                    {
                                        medicalConclusionId = Guid.Parse(medicalConclusionEnt.NewKeyValue);
                                    }
                                }
                                #endregion

                                #region 转换套餐ID
                                Guid? medicalPackageId = null;
                                if (!string.IsNullOrWhiteSpace(row["medical_package_id"].ToString()))
                                {
                                    var medicalPackageEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_package" && m.OldKeyValue == row["medical_package_id"].ToString()).FirstOrDefault();
                                    if (medicalPackageEnt != null)
                                    {
                                        medicalPackageId = Guid.Parse(medicalPackageEnt.NewKeyValue);
                                    }
                                }
                                #endregion

                                #region 转换体检类别ID
                                Guid? medicalTypeId = null;
                                if (!string.IsNullOrWhiteSpace(row["medical_type_id"].ToString()))
                                {
                                    var medicalTypeEnt = fieldComparisonTempList.Where(m => m.TableName == "medical_type" && m.OldKeyValue == row["medical_type_id"].ToString()).FirstOrDefault();
                                    if (medicalTypeEnt != null)
                                    {
                                        medicalTypeId = Guid.Parse(medicalTypeEnt.NewKeyValue);
                                    }
                                }
                                #endregion



                                #region 转换人员类别ID
                                Guid? personnelTypeId = null;
                                if (!string.IsNullOrWhiteSpace(row["personnel_type_id"].ToString()))
                                {
                                    var personnelTypeEnt = fieldComparisonTempList.Where(m => m.TableName == "personnel_type" && m.OldKeyValue == row["personnel_type_id"].ToString()).FirstOrDefault();
                                    if (personnelTypeEnt != null)
                                    {
                                        personnelTypeId = Guid.Parse(personnelTypeEnt.NewKeyValue);
                                    }
                                }
                                #endregion

                                #region 转换总检医生ID
                                Guid? summaryDoctorId = null;
                                if (!string.IsNullOrWhiteSpace(row["summary_doctor"].ToString()))
                                {
                                    var userEnt = userList.Where(m => m.Name == row["summary_doctor"].ToString().Trim()).FirstOrDefault();
                                    if (userEnt != null)
                                    {
                                        summaryDoctorId = userEnt.Id;
                                    }
                                }
                                #endregion


                                #region 上传图片，获取地址

                                string photo = "";
                                if (!string.IsNullOrEmpty(row["photograph"].ToString()))
                                {
                                    photo = UpLoadImg(patientRegisterId, Convert.ToDateTime(row["register_date"].ToString()), (byte[])row["photograph"]);
                                }

                                #endregion

                                var data = new PatientRegister(patientRegisterId)
                                {
                                    BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                                    MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                                    MedicalCenterId = defaultMedicalCenterId,
                                    SexId = ConvertSex(row["sex_id"].ToString()),
                                    Age = string.IsNullOrWhiteSpace(row["age"].ToString()) ? null : Convert.ToInt16(row["age"].ToString()),
                                    AuditDate = string.IsNullOrWhiteSpace(row["audit_date"].ToString()) ? null : Convert.ToDateTime(row["audit_date"].ToString()),
                                    AuditDoctorId = AuditDoctorId,
                                    CompleteFlag = Convert.ToChar(row["complete_flag"].ToString()),
                                    CustomerOrgGroupId = customerOrgGroupId,
                                    CustomerOrgId = customerOrgId,
                                    CustomerOrgRegisterId = customerOrgRegisterId,
                                    GuidePrintTimes = string.IsNullOrWhiteSpace(row["instruct_print_times"].ToString()) ? (short)0 : Convert.ToInt16(row["instruct_print_times"].ToString()),
                                    InterposeMeasure = null,
                                    IsAudit = string.IsNullOrWhiteSpace(row["audit_flag"].ToString()) ? 'N' : Convert.ToChar(row["audit_flag"].ToString()),
                                    IsLock = string.IsNullOrWhiteSpace(row["lock_flag"].ToString()) ? 'N' : Convert.ToChar(row["lock_flag"].ToString()),
                                    IsMedicalStart = string.IsNullOrWhiteSpace(row["medical_start_flag"].ToString()) ? 'N' : Convert.ToChar(row["medical_start_flag"].ToString()),
                                    IsNameHide = string.IsNullOrWhiteSpace(row["name_encrypt_flag"].ToString()) ? 'N' : Convert.ToChar(row["name_encrypt_flag"].ToString()),
                                    IsPhoneFollow = 'N',
                                    IsRecoverGuide = string.IsNullOrWhiteSpace(row["recover_form_flag"].ToString()) ? 'N' : Convert.ToChar(row["recover_form_flag"].ToString()),
                                    IsUpload = string.IsNullOrWhiteSpace(row["upload_flag"].ToString()) ? 'N' : Convert.ToChar(row["upload_flag"].ToString()),
                                    IsVip = string.IsNullOrWhiteSpace(row["vip_flag"].ToString()) ? 'N' : Convert.ToChar(row["vip_flag"].ToString()),
                                    JobCardNo = row["job_card_no"].ToString(),
                                    JobPost = row["job_post"].ToString(),
                                    JobTitle = row["job_title"].ToString(),
                                    MedicalCardNo = row["medical_card_no"].ToString(),
                                    MedicalConclusionId = medicalConclusionId,
                                    MedicalPackageId = medicalPackageId,
                                    MedicalStartDate = string.IsNullOrEmpty(row["medical_start_date"].ToString()) ? null : Convert.ToDateTime(row["medical_start_date"].ToString()),
                                    MedicalTimes = Convert.ToInt16(row["medical_times"].ToString()),
                                    MedicalTypeId = medicalTypeId,
                                    PatientId = patientId,
                                    PatientName = row["name"].ToString(),
                                    PatientRegisterNo = row["barcode_no"].ToString(),
                                    PersonnelTypeId = personnelTypeId,
                                    Photo = photo,
                                    Remark = row["remark"].ToString(),
                                    ReportPrintTimes = Convert.ToInt16(row["report_print_times"].ToString()),
                                    Salesman = row["salesman"].ToString(),
                                    SexHormoneTermId = null,
                                    SummaryDate = string.IsNullOrEmpty(row["summary_date"].ToString()) ? null : Convert.ToDateTime(row["summary_date"].ToString()),
                                    SummaryDoctorId = summaryDoctorId,
                                    ThirdInfo = row["third_info"].ToString(),
                                };
                                var patientRegisterRepository = scope.ServiceProvider.GetRequiredService<IRepository<PatientRegister, Guid>>();
                                await patientRegisterRepository.InsertAsync(data, true);

                                stopwatch31.Stop();
                                _logger.LogInformation($"{row["patient_register_id"]}_第31片段耗时：{stopwatch31.ElapsedMilliseconds}");

                                Stopwatch stopwatch32 = new Stopwatch();
                                stopwatch32.Start();

                                #region 登记的项目、结果、小结

                                var oldRegisterAsbitemList = await oldDb2.Ado.GetDataTableAsync($"select * from register_asbitem where patient_register_id='{row["patient_register_id"].ToString()}'");

                                if (oldRegisterAsbitemList.Rows.Count > 0)
                                {
                                    foreach (DataRow rowAsbitem in oldRegisterAsbitemList.Rows)
                                    {
                                        Stopwatch stopwatch34 = new Stopwatch();
                                        stopwatch34.Start();
                                        #region 转换审核医生ID
                                        Guid? auditorUserId = null;
                                        if (!string.IsNullOrWhiteSpace(rowAsbitem["audit_doctor"].ToString()))
                                        {
                                            var userEnt = userList.Where(m => m.Name == rowAsbitem["audit_doctor"].ToString().Trim()).FirstOrDefault();
                                            if (userEnt != null)
                                            {
                                                auditorUserId = userEnt.Id;
                                            }
                                        }
                                        #endregion

                                        #region 转换检查医生ID
                                        string checkDoctorId = null;
                                        if (!string.IsNullOrWhiteSpace(rowAsbitem["check_doctor"].ToString()))
                                        {
                                            var userEnt = userList.Where(m => m.Name == rowAsbitem["check_doctor"].ToString().Trim()).FirstOrDefault();
                                            if (userEnt != null)
                                            {
                                                checkDoctorId = userEnt.Id.ToString();
                                            }
                                            else
                                            {
                                                checkDoctorId = rowAsbitem["check_doctor"].ToString().Trim();
                                            }
                                        }
                                        #endregion

                                        #region 转换组合项目ID
                                        Guid newAsbitemId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "asbitem" && m.OldKeyValue == rowAsbitem["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);
                                        #endregion

                                        stopwatch34.Stop();
                                        _logger.LogInformation($"{row["patient_register_id"]}_第34片段耗时：{stopwatch34.ElapsedMilliseconds}");
                                        #region 插入register_check
                                        Guid registerCheckId = GuidGenerator.Create();
                                        var dataRegisterCheck = new RegisterCheck(registerCheckId)
                                        {
                                            AuditorUserId = auditorUserId,
                                            AuditTime = string.IsNullOrEmpty(rowAsbitem["audit_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["audit_date"].ToString()),
                                            CheckDate = string.IsNullOrEmpty(rowAsbitem["check_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["check_date"].ToString()),
                                            CheckDoctorId = checkDoctorId,
                                            CheckRequestNo = "",
                                            CheckRequestPrintTimes = (short)1,
                                            CompleteFlag = Convert.ToChar(rowAsbitem["complete_flag"].ToString()),
                                            CriticalRangeValue = null,
                                            //CriticalValueCreateDate = null,
                                            IsCriticalValue = null,
                                            CriticalValueContent = null,
                                            //CriticalValueProcessDate = null,
                                            //CriticalValueProcessDoctor = null,
                                            //CriticalValueProcessFlag = null,
                                            IsAudit = string.IsNullOrEmpty(rowAsbitem["audit_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["audit_flag"].ToString()),
                                            IsLock = string.IsNullOrEmpty(rowAsbitem["lock_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["lock_flag"].ToString()),
                                            PatientRegisterId = patientRegisterId,
                                            ThirdInfo = rowAsbitem["third_info"].ToString()
                                        };
                                        var registerCheckRepository = scope.ServiceProvider.GetRequiredService<IRepository<RegisterCheck, Guid>>();

                                        await registerCheckRepository.InsertAsync(dataRegisterCheck, true);
                                        #endregion



                                        #region 插入register_check_asbitem
                                        Guid registerCheckAsbitemId = GuidGenerator.Create();

                                        var dataRegisterAsbitem = new RegisterCheckAsbitem(registerCheckAsbitemId)
                                        {
                                            Amount = 1,
                                            IsCharge = Convert.ToChar(rowAsbitem["charge_flag"].ToString()),
                                            AsbitemId = newAsbitemId,
                                            ChargePrice = Convert.ToDecimal(rowAsbitem["price"].ToString()),
                                            GroupPackageId = null,
                                            LisRequestId = null,
                                            PatientRegisterId = patientRegisterId,
                                            PayTypeFlag = Convert.ToChar(rowAsbitem["payment_mode"].ToString()),
                                            RegisterCheckId = registerCheckId,
                                            StandardPrice = Convert.ToDecimal(rowAsbitem["standard_price"].ToString())
                                        };
                                        var registerCheckAsbitemRepository = scope.ServiceProvider.GetRequiredService<IRepository<RegisterCheckAsbitem, Guid>>();
                                        await registerCheckAsbitemRepository.InsertAsync(dataRegisterAsbitem);
                                        #endregion


                                        #region 插入医生小结
                                        var registerCheckSummaryRepository = scope.ServiceProvider.GetRequiredService<IRepository<RegisterCheckSummary, Guid>>();

                                        var oldSummary = rowAsbitem["summary"].ToString();
                                        if (!string.IsNullOrWhiteSpace(oldSummary))
                                        {
                                            var dataRegisterCheckSummary = new RegisterCheckSummary
                                            {
                                                RegisterCheckId = registerCheckId,
                                                DisplayOrder = 1,
                                                Summary = oldSummary,
                                                SummaryFlag = '0'
                                            };

                                            await registerCheckSummaryRepository.InsertAsync(dataRegisterCheckSummary);

                                        }

                                        #endregion



                                        #region 插入明细项目
                                        var registerCheckItemRepository = scope.ServiceProvider.GetRequiredService<IRepository<RegisterCheckItem>>();
                                        var oldRegisterCheckItemList = await oldDb2.Ado.GetDataTableAsync($"select * from register_item where patient_register_id='{row["patient_register_id"].ToString()}' and asbitem_id='{rowAsbitem["asbitem_id"].ToString()}'");

                                        if (oldRegisterCheckItemList.Rows.Count > 0)
                                        {

                                            foreach (DataRow rowRegisterCheckItem in oldRegisterCheckItemList.Rows)
                                            {
                                                #region 转换项目ID  老转新
                                                Guid newItemId = Guid.Parse(fieldComparisonTempList.Where(m => m.TableName == "item" && m.OldKeyValue == rowRegisterCheckItem["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                                                #endregion


                                                var dataRegisterCheckItem = new RegisterCheckItem
                                                {
                                                    CheckDate = string.IsNullOrEmpty(rowRegisterCheckItem["check_date"].ToString()) ? null : Convert.ToDateTime(rowRegisterCheckItem["check_date"].ToString()),
                                                    CriticalValue = null,
                                                    CheckDoctorName = rowRegisterCheckItem["check_doctor"].ToString().Trim(),
                                                    CriticalRangeValue = null,
                                                    ItemId = newItemId,
                                                    ReferenceRangeValue = rowRegisterCheckItem["reference_range_value"].ToString(),
                                                    RegisterCheckId = registerCheckId,
                                                    Result = rowRegisterCheckItem["result"].ToString(),
                                                    ResultStatusId = _registerCheckItemManager.GetResultStatusId(rowRegisterCheckItem["result"].ToString(), rowRegisterCheckItem["reference_range_value"].ToString()),
                                                    Unit = rowRegisterCheckItem["Unit"].ToString()
                                                };

                                                await registerCheckItemRepository.InsertAsync(dataRegisterCheckItem);

                                            }

                                        }

                                        #endregion



                                    }
                                }

                                #endregion

                                stopwatch32.Stop();
                                _logger.LogInformation($"{row["patient_register_id"]}_第32片段耗时：{stopwatch32.ElapsedMilliseconds}");


                                #region 总检建议、综述、总检诊断
                                var sumSummaryHeaderRepository = scope.ServiceProvider.GetRequiredService<IRepository<SumSummaryHeader, Guid>>();
                                var sumSummaryContentRepository = scope.ServiceProvider.GetRequiredService<IRepository<SumSummaryContent, Guid>>();

                                var sumSuggestionHeaderRepository = scope.ServiceProvider.GetRequiredService<IRepository<SumSuggestionHeader, Guid>>();
                                var sumSuggestionContentRepository = scope.ServiceProvider.GetRequiredService<IRepository<SumSuggestionContent, Guid>>();
                                var sumDiagnosisRepository = scope.ServiceProvider.GetRequiredService<IRepository<SumDiagnosis>>();

                                var oldSum = await oldDb2.Ado.GetDataTableAsync($"select summary,suggestion,barcode_no from patient_register where patient_register_id='{oldPatientRegisterId}' ");

                                if (oldSum.Rows.Count == 1)
                                {
                                    string oldSummary = oldSum.Rows[0][0].ToString();
                                    string oldSuggestion = oldSum.Rows[0][1].ToString();

                                    if (!string.IsNullOrWhiteSpace(oldSummary))
                                    {

                                        Guid sumSummaryHeaderId = GuidGenerator.Create();

                                        var dataSumSummaryHeader = new SumSummaryHeader(sumSummaryHeaderId)
                                        {
                                            DisplayOrder = 1,
                                            SummaryFlag = '0',
                                            PatientRegisterId = patientRegisterId,
                                            SummaryTitle = "异常结果如下"
                                        };

                                        await sumSummaryHeaderRepository.InsertAsync(dataSumSummaryHeader);

                                        Guid sumSummaryContentId = GuidGenerator.Create();
                                        var dataSumSummaryContent = new SumSummaryContent(sumSummaryContentId)
                                        {
                                            DisplayOrder = 1,
                                            SumSummaryHeaderId = sumSummaryHeaderId,
                                            SummaryContent = oldSummary
                                        };

                                        await sumSummaryContentRepository.InsertAsync(dataSumSummaryContent);

                                    }


                                    if (!string.IsNullOrWhiteSpace(oldSuggestion))
                                    {

                                        Guid sumSuggestionHeaderId = GuidGenerator.Create();

                                        var dataSumSuggestionHeader = new SumSuggestionHeader(sumSuggestionHeaderId)
                                        {
                                            DisplayOrder = 1,
                                            SuggestionFlag = '0',
                                            PatientRegisterId = patientRegisterId,
                                            SuggestionTitle = "健康建议如下"
                                        };

                                        await sumSuggestionHeaderRepository.InsertAsync(dataSumSuggestionHeader);

                                        Guid sumSuggestionContentId = GuidGenerator.Create();
                                        var dataSumSuggestionContent = new SumSuggestionContent(sumSuggestionContentId)
                                        {
                                            DisplayOrder = 1,
                                            SuggestionContent = oldSuggestion,
                                            SuggestionType = SuggestionTypeFlag.HealthGuidance,
                                            SumSuggestionHeaderId = sumSuggestionHeaderId
                                        };

                                        await sumSuggestionContentRepository.InsertAsync(dataSumSuggestionContent);



                                        #region 总症诊断
                                        var oldSummaryDiagnosis = await oldDb2.Ado.GetDataTableAsync($"select diagnosis_id from summary_diagnosis where patient_register_id='{oldPatientRegisterId}' order by display_order asc ");

                                        if (oldSummaryDiagnosis.Rows.Count > 0)
                                        {
                                            List<SumDiagnosis> sumDiagnosisInsert = new List<SumDiagnosis>();

                                            foreach (DataRow summaryDiagnosis in oldSummaryDiagnosis.Rows)
                                            {
                                                var diagnosisEnt = fieldComparisonTempList.Where(m => m.TableName == "diagnosis" && m.OldKeyValue == summaryDiagnosis["diagnosis_id"].ToString()).FirstOrDefault();
                                                if (diagnosisEnt != null)
                                                {

                                                    var dataSumDiagnosis = new SumDiagnosis
                                                    {
                                                        DisplayOrder = oldSummaryDiagnosis.Rows.IndexOf(summaryDiagnosis) + 1,
                                                        PatientRegisterId = patientRegisterId,
                                                        DiagnosisId = Guid.Parse(diagnosisEnt.NewKeyValue),
                                                        SumSuggestionHeaderId = sumSuggestionHeaderId
                                                    };

                                                    sumDiagnosisInsert.Add(dataSumDiagnosis);


                                                }


                                            }

                                            if (sumDiagnosisInsert.Any())
                                                await sumDiagnosisRepository.InsertManyAsync(sumDiagnosisInsert);

                                        }
                                        #endregion


                                    }


                                }


                                #endregion


                                var fieldComparison = new FieldComparison
                                {
                                    FieldName = "id",
                                    NewKeyValue = patientRegisterId.ToString(),
                                    OldKeyValue = row["patient_register_id"].ToString(),
                                    TableName = "patient_register"
                                };
                                var fieldComparisonRepository = scope.ServiceProvider.GetRequiredService<IRepository<FieldComparison, Guid>>();

                                await fieldComparisonRepository.InsertAsync(fieldComparison);


                                await oldDb2.Ado.ExecuteCommandAsync($"update  tb_export_key set  keyvalue='{row["patient_register_id"].ToString()}',addtime=getdate(),handlecount+=1 where tablename='patient_register' ");

                                await uow.CompleteAsync();


                                #region 修改创建者日期跟id
                                Guid registerDoctorId = Guid.Parse(_configuration.GetValue<string>("AdminId"));
                                var registerDoctorEnt = userList.Where(m => m.Name == row["register_doctor"].ToString().Trim()).FirstOrDefault();
                                if (registerDoctorEnt != null)
                                {
                                    registerDoctorId = registerDoctorEnt.Id;
                                }
                                string sql_update = $"update patient_register set creator_id='{registerDoctorId}',creation_time='{Convert.ToDateTime(row["register_date"]).ToString("yyyy-MM-dd HH:mm:ss")}'";
                                sql_update += $" where id='{patientRegisterId}' ";
                                await newDb2.Ado.ExecuteCommandAsync(sql_update);
                                #endregion
                            }


                        }
                        ;
                    }
                    ;
                }
                stopwatch3.Stop();
                _logger.LogInformation($"{row["patient_register_id"]}_处理单个人总耗时：{stopwatch3.ElapsedMilliseconds}");
            }
            catch (Exception ex)
            {
                hangPatientRegisterErrorCount++;
                _logger.LogInformation($"数据处理失败，人员id为：{row["patient_register_id"]}");
                #region 添加到tb_error_log表
                //await oldDb2.Ado.ExecuteCommandAsync($"insert into  tb_error_log(old_patient_register_id,error_message,addtime) values ('{row["patient_register_id"]}','{ex.StackTrace}',getdate()) ");
                #endregion
            }
        }
        /// <summary>
        /// 反向导入人员等业务信息
        /// </summary>
        /// <param name="handCount">每次处理的人员数量</param>
        /// <param name="isGo">是否继续处理</param>
        /// <returns></returns>
        [RemoteService(false)]
        [HttpPost("api/app/CCTJExportData/TransferPatientRegisterWithDetailReverseData")]
        public async Task TransferPatientRegisterWithDetailReverseData(int handCount, bool isGo = false)
        {
            //当前导入的ID
            string nextKeyValue = oldDb.Ado.GetString("select keyvalue from tb_export_key where tablename='patient_register_reverse' ");

            var oldPatientRegisterList = await oldDb.Ado.GetDataTableAsync($"select top {handCount} * from patient_register where patient_register_id<'{nextKeyValue}' order by patient_register_id desc");

            if (oldPatientRegisterList.Rows.Count > 0)
            {
                var userList = await _identityUserRepository.GetListAsync();
                List<CustomerOrgRegister> customerOrgRegisterList = await _customerOrgRegisterRepository.GetListAsync();

                foreach (DataRow row in oldPatientRegisterList.Rows)
                {
                    hangPatientRegisterReverseCount++;



                    using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                    {
                        string oldPatientRegisterId = row["patient_register_id"].ToString();

                        //检查是否已经导入
                        var isDZPatientRegisterTemp = (await _fieldComparisonRepository.GetListAsync(f => f.TableName == "patient_register"
                        && f.OldKeyValue == oldPatientRegisterId));


                        if (isDZPatientRegisterTemp.Count > 0)
                        {
                            continue;
                        }



                        //档案ID
                        Guid patientId = Guid.Empty;

                        #region 处理档案，未找到档案就生成

                        var patientEnt = await _patientRepository.FirstOrDefaultAsync(m => m.PatientNo == row["patient_id"].ToString());
                        if (patientEnt == null)
                        {
                            string nationId = null;
                            if (!string.IsNullOrWhiteSpace(row["nation_id"].ToString()))
                            {
                                var nationEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "nation" && m.OldKeyValue == row["nation_id"].ToString()).FirstOrDefault();
                                if (nationEnt == null)
                                {
                                    nationId = row["nation_id"].ToString();
                                }
                                else
                                {
                                    nationId = nationEnt.NewKeyValue;
                                }
                            }

                            Guid autoPatientId = GuidGenerator.Create();  //档案ID

                            var dataPatient = new Patient(autoPatientId)
                            {
                                Address = row["address"].ToString(),
                                BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                                BirthPlaceId = null,
                                DisplayName = row["name"].ToString(),
                                Email = row["email"].ToString(),
                                IdNo = row["id_card_no"].ToString(),
                                MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                MobileTelephone = row["mobile_telephone"].ToString(),
                                NationId = nationId,
                                PatientNo = row["patient_id"].ToString(),
                                PatientPassword = row["patient_password"].ToString(),
                                PostalCode = row["postalcode"].ToString(),
                                SexId = ConvertSex(row["sex_id"].ToString()),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["name"].ToString()),
                                Telephone = row["telephone"].ToString()
                            };

                            await _patientRepository.InsertAsync(dataPatient, true);
                            patientId = autoPatientId;
                        }
                        else
                        {
                            patientId = patientEnt.Id;
                        }


                        #endregion



                        Guid patientRegisterId = GuidGenerator.Create();  //生成登记ID

                        #region 转换审核医生ID
                        Guid? AuditDoctorId = null;
                        if (!string.IsNullOrWhiteSpace(row["audit_doctor"].ToString()))
                        {
                            var userEnt = userList.Where(m => m.Name == row["audit_doctor"].ToString().Trim()).FirstOrDefault();
                            if (userEnt != null)
                            {
                                AuditDoctorId = userEnt.Id;
                            }
                        }
                        #endregion

                        #region 转换单位分组ID
                        Guid? customerOrgGroupId = null;
                        if (!string.IsNullOrWhiteSpace(row["org_group_id"].ToString()))
                        {
                            var customerOrgGroupEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "customer_org_group" && m.OldKeyValue == row["org_group_id"].ToString()).FirstOrDefault();
                            if (customerOrgGroupEnt != null)
                            {
                                customerOrgGroupId = Guid.Parse(customerOrgGroupEnt.NewKeyValue);
                            }
                        }
                        #endregion

                        #region 转换单位ID  部门
                        Guid customerOrgId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString()).FirstOrDefault().NewKeyValue);
                        #endregion

                        #region 转换单位体检次数ID   没有增加默认值
                        Guid customerOrgRegisterId = GuidFlag.PersonCustomerOrgRegisterId;
                        if (row["org_id"].ToString() != "00000")
                        {
                            Guid topCustomerOrgId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "customer_org" && m.OldKeyValue == row["org_id"].ToString().Substring(0, 5)).FirstOrDefault().NewKeyValue);
                            var customerOrgRegisterEnt = customerOrgRegisterList.Where(m => m.CustomerOrgId == topCustomerOrgId
                            && m.MedicalTimes == (short)Convert.ToInt32(row["org_medical_times"].ToString())).FirstOrDefault();
                            if (customerOrgRegisterEnt != null)
                            {
                                customerOrgRegisterId = customerOrgRegisterEnt.Id;
                            }
                        }

                        #endregion

                        #region 转换体检结论ID   
                        Guid? medicalConclusionId = null;
                        if (!string.IsNullOrWhiteSpace(row["medical_conclusion_id"].ToString()))
                        {
                            var medicalConclusionEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "medical_conclusion"
                            && m.OldKeyValue == row["medical_conclusion_id"].ToString()).FirstOrDefault();
                            if (medicalConclusionEnt != null)
                            {
                                medicalConclusionId = Guid.Parse(medicalConclusionEnt.NewKeyValue);
                            }
                        }
                        #endregion

                        #region 转换套餐ID
                        Guid? medicalPackageId = null;
                        if (!string.IsNullOrWhiteSpace(row["medical_package_id"].ToString()))
                        {
                            var medicalPackageEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "medical_package" && m.OldKeyValue == row["medical_package_id"].ToString()).FirstOrDefault();
                            if (medicalPackageEnt != null)
                            {
                                medicalPackageId = Guid.Parse(medicalPackageEnt.NewKeyValue);
                            }
                        }
                        #endregion

                        #region 转换体检类别ID
                        Guid? medicalTypeId = null;
                        if (!string.IsNullOrWhiteSpace(row["medical_type_id"].ToString()))
                        {
                            var medicalTypeEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "medical_type" && m.OldKeyValue == row["medical_type_id"].ToString()).FirstOrDefault();
                            if (medicalTypeEnt != null)
                            {
                                medicalTypeId = Guid.Parse(medicalTypeEnt.NewKeyValue);
                            }
                        }
                        #endregion



                        #region 转换人员类别ID
                        Guid? personnelTypeId = null;
                        if (!string.IsNullOrWhiteSpace(row["personnel_type_id"].ToString()))
                        {
                            var personnelTypeEnt = (await _fieldComparisonRepository.GetQueryableAsync()).Where(m => m.TableName == "personnel_type" && m.OldKeyValue == row["personnel_type_id"].ToString()).FirstOrDefault();
                            if (personnelTypeEnt != null)
                            {
                                personnelTypeId = Guid.Parse(personnelTypeEnt.NewKeyValue);
                            }
                        }
                        #endregion

                        #region 转换总检医生ID
                        Guid? summaryDoctorId = null;
                        if (!string.IsNullOrWhiteSpace(row["summary_doctor"].ToString()))
                        {
                            var userEnt = userList.Where(m => m.Name == row["summary_doctor"].ToString().Trim()).FirstOrDefault();
                            if (userEnt != null)
                            {
                                summaryDoctorId = userEnt.Id;
                            }
                        }
                        #endregion


                        #region 上传图片，获取地址

                        string photo = "";
                        if (!string.IsNullOrEmpty(row["photograph"].ToString()))
                        {
                            photo = UpLoadImg(patientRegisterId, Convert.ToDateTime(row["register_date"].ToString()), (byte[])row["photograph"]);
                        }

                        #endregion

                        var data = new PatientRegister(patientRegisterId)
                        {
                            BirthDate = string.IsNullOrEmpty(row["birth_date"].ToString()) ? null : Convert.ToDateTime(row["birth_date"].ToString()),
                            MaritalStatusId = row["marital_status_id"].ToString() == "2" ? '4' : Convert.ToChar(row["marital_status_id"].ToString()),
                            MedicalCenterId = defaultMedicalCenterId,
                            SexId = ConvertSex(row["sex_id"].ToString()),
                            Age = string.IsNullOrWhiteSpace(row["age"].ToString()) ? null : Convert.ToInt16(row["age"].ToString()),
                            AuditDate = string.IsNullOrWhiteSpace(row["audit_date"].ToString()) ? null : Convert.ToDateTime(row["audit_date"].ToString()),
                            AuditDoctorId = AuditDoctorId,
                            CompleteFlag = Convert.ToChar(row["complete_flag"].ToString()),
                            CustomerOrgGroupId = customerOrgGroupId,
                            CustomerOrgId = customerOrgId,
                            CustomerOrgRegisterId = customerOrgRegisterId,
                            GuidePrintTimes = string.IsNullOrWhiteSpace(row["instruct_print_times"].ToString()) ? (short)0 : Convert.ToInt16(row["instruct_print_times"].ToString()),
                            InterposeMeasure = null,
                            IsAudit = string.IsNullOrWhiteSpace(row["audit_flag"].ToString()) ? 'N' : Convert.ToChar(row["audit_flag"].ToString()),
                            IsLock = string.IsNullOrWhiteSpace(row["lock_flag"].ToString()) ? 'N' : Convert.ToChar(row["lock_flag"].ToString()),
                            IsMedicalStart = string.IsNullOrWhiteSpace(row["medical_start_flag"].ToString()) ? 'N' : Convert.ToChar(row["medical_start_flag"].ToString()),
                            IsNameHide = string.IsNullOrWhiteSpace(row["name_encrypt_flag"].ToString()) ? 'N' : Convert.ToChar(row["name_encrypt_flag"].ToString()),
                            IsPhoneFollow = 'N',
                            IsRecoverGuide = string.IsNullOrWhiteSpace(row["recover_form_flag"].ToString()) ? 'N' : Convert.ToChar(row["recover_form_flag"].ToString()),
                            IsUpload = string.IsNullOrWhiteSpace(row["upload_flag"].ToString()) ? 'N' : Convert.ToChar(row["upload_flag"].ToString()),
                            IsVip = string.IsNullOrWhiteSpace(row["vip_flag"].ToString()) ? 'N' : Convert.ToChar(row["vip_flag"].ToString()),
                            JobCardNo = row["job_card_no"].ToString(),
                            JobPost = row["job_post"].ToString(),
                            JobTitle = row["job_title"].ToString(),
                            MedicalCardNo = row["medical_card_no"].ToString(),
                            MedicalConclusionId = medicalConclusionId,
                            MedicalPackageId = medicalPackageId,
                            MedicalStartDate = string.IsNullOrEmpty(row["medical_start_date"].ToString()) ? null : Convert.ToDateTime(row["medical_start_date"].ToString()),
                            MedicalTimes = Convert.ToInt16(row["medical_times"].ToString()),
                            MedicalTypeId = medicalTypeId,
                            PatientId = patientId,
                            PatientName = row["name"].ToString(),
                            PatientRegisterNo = row["barcode_no"].ToString(),
                            PersonnelTypeId = personnelTypeId,
                            Photo = photo,
                            Remark = row["remark"].ToString(),
                            ReportPrintTimes = Convert.ToInt16(row["report_print_times"].ToString()),
                            Salesman = row["salesman"].ToString(),
                            SexHormoneTermId = null,
                            SummaryDate = string.IsNullOrEmpty(row["summary_date"].ToString()) ? null : Convert.ToDateTime(row["summary_date"].ToString()),
                            SummaryDoctorId = summaryDoctorId,
                            ThirdInfo = row["third_info"].ToString(),
                        };

                        await _patientRegisterRepository.InsertAsync(data, true);





                        #region 登记的项目、结果、小结

                        var oldRegisterAsbitemList = await oldDb.Ado.GetDataTableAsync($"select * from register_asbitem where patient_register_id='{row["patient_register_id"].ToString()}'");

                        if (oldRegisterAsbitemList.Rows.Count > 0)
                        {
                            foreach (DataRow rowAsbitem in oldRegisterAsbitemList.Rows)
                            {
                                #region 转换审核医生ID
                                Guid? auditorUserId = null;
                                if (!string.IsNullOrWhiteSpace(rowAsbitem["audit_doctor"].ToString()))
                                {
                                    var userEnt = userList.Where(m => m.Name == rowAsbitem["audit_doctor"].ToString().Trim()).FirstOrDefault();
                                    if (userEnt != null)
                                    {
                                        auditorUserId = userEnt.Id;
                                    }
                                }
                                #endregion

                                #region 转换检查医生ID
                                string checkDoctorId = null;
                                if (!string.IsNullOrWhiteSpace(rowAsbitem["check_doctor"].ToString()))
                                {
                                    var userEnt = userList.Where(m => m.Name == rowAsbitem["check_doctor"].ToString().Trim()).FirstOrDefault();
                                    if (userEnt != null)
                                    {
                                        checkDoctorId = userEnt.Id.ToString();
                                    }
                                    else
                                    {
                                        checkDoctorId = rowAsbitem["check_doctor"].ToString().Trim();
                                    }
                                }
                                #endregion

                                #region 转换组合项目ID
                                Guid newAsbitemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                          .Where(m => m.TableName == "asbitem" && m.OldKeyValue == rowAsbitem["asbitem_id"].ToString()).FirstOrDefault().NewKeyValue);
                                #endregion

                                #region 插入register_check
                                Guid registerCheckId = GuidGenerator.Create();
                                var dataRegisterCheck = new RegisterCheck(registerCheckId)
                                {
                                    AuditorUserId = auditorUserId,
                                    AuditTime = string.IsNullOrEmpty(rowAsbitem["audit_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["audit_date"].ToString()),
                                    CheckDate = string.IsNullOrEmpty(rowAsbitem["check_date"].ToString()) ? null : Convert.ToDateTime(rowAsbitem["check_date"].ToString()),
                                    CheckDoctorId = checkDoctorId,
                                    CheckRequestNo = "",
                                    CheckRequestPrintTimes = (short)1,
                                    CompleteFlag = Convert.ToChar(rowAsbitem["complete_flag"].ToString()),
                                    CriticalRangeValue = null,
                                    //CriticalValueCreateDate = null,
                                    IsCriticalValue = null,
                                    CriticalValueContent = null,
                                    //CriticalValueProcessDate = null,
                                    //CriticalValueProcessDoctor = null,
                                    //CriticalValueProcessFlag = null,
                                    IsAudit = string.IsNullOrEmpty(rowAsbitem["audit_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["audit_flag"].ToString()),
                                    IsLock = string.IsNullOrEmpty(rowAsbitem["lock_flag"].ToString()) ? 'N' : Convert.ToChar(rowAsbitem["lock_flag"].ToString()),
                                    PatientRegisterId = patientRegisterId,
                                    ThirdInfo = rowAsbitem["third_info"].ToString()
                                };


                                await _registerCheckRepository.InsertAsync(dataRegisterCheck, true);
                                #endregion



                                #region 插入register_check_asbitem
                                Guid registerCheckAsbitemId = GuidGenerator.Create();

                                var dataRegisterAsbitem = new RegisterCheckAsbitem(registerCheckAsbitemId)
                                {
                                    Amount = 1,
                                    IsCharge = Convert.ToChar(rowAsbitem["charge_flag"].ToString()),
                                    AsbitemId = newAsbitemId,
                                    ChargePrice = Convert.ToDecimal(rowAsbitem["price"].ToString()),
                                    GroupPackageId = null,
                                    LisRequestId = null,
                                    PatientRegisterId = patientRegisterId,
                                    PayTypeFlag = Convert.ToChar(rowAsbitem["payment_mode"].ToString()),
                                    RegisterCheckId = registerCheckId,
                                    StandardPrice = Convert.ToDecimal(rowAsbitem["standard_price"].ToString())
                                };

                                await _registerCheckAsbitemRepository.InsertAsync(dataRegisterAsbitem);
                                #endregion


                                #region 插入医生小结

                                var oldSummary = rowAsbitem["summary"].ToString();
                                if (!string.IsNullOrWhiteSpace(oldSummary))
                                {
                                    var dataRegisterCheckSummary = new RegisterCheckSummary
                                    {
                                        RegisterCheckId = registerCheckId,
                                        DisplayOrder = 1,
                                        Summary = oldSummary,
                                        SummaryFlag = '0'
                                    };

                                    await _registerCheckSummaryRepository.InsertAsync(dataRegisterCheckSummary);

                                }

                                #endregion

                                #region 插入明细项目

                                var oldRegisterCheckItemList = await oldDb.Ado.GetDataTableAsync($"select * from register_item where patient_register_id='{row["patient_register_id"].ToString()}' and asbitem_id='{rowAsbitem["asbitem_id"].ToString()}'");

                                if (oldRegisterCheckItemList.Rows.Count > 0)
                                {

                                    foreach (DataRow rowRegisterCheckItem in oldRegisterCheckItemList.Rows)
                                    {
                                        #region 转换项目ID  老转新
                                        Guid newItemId = Guid.Parse((await _fieldComparisonRepository.GetQueryableAsync())
                                    .Where(m => m.TableName == "item" && m.OldKeyValue == rowRegisterCheckItem["item_id"].ToString()).FirstOrDefault().NewKeyValue);

                                        #endregion


                                        var dataRegisterCheckItem = new RegisterCheckItem
                                        {
                                            CheckDate = string.IsNullOrEmpty(rowRegisterCheckItem["check_date"].ToString()) ? null : Convert.ToDateTime(rowRegisterCheckItem["check_date"].ToString()),
                                            CriticalValue = null,
                                            CheckDoctorName = rowRegisterCheckItem["check_doctor"].ToString().Trim(),
                                            CriticalRangeValue = null,
                                            ItemId = newItemId,
                                            ReferenceRangeValue = rowRegisterCheckItem["reference_range_value"].ToString(),
                                            RegisterCheckId = registerCheckId,
                                            Result = rowRegisterCheckItem["result"].ToString(),
                                            ResultStatusId = _registerCheckItemManager.GetResultStatusId(rowRegisterCheckItem["result"].ToString(), rowRegisterCheckItem["reference_range_value"].ToString()),
                                            Unit = rowRegisterCheckItem["Unit"].ToString()
                                        };

                                        await _registerCheckItemRepository.InsertAsync(dataRegisterCheckItem);

                                    }

                                }

                                #endregion

                            }
                        }

                        #endregion


                        #region 总检建议、综述、总检诊断


                        var oldSum = await oldDb.Ado.GetDataTableAsync($"select summary,suggestion,barcode_no from patient_register where patient_register_id='{oldPatientRegisterId}' ");

                        if (oldSum.Rows.Count == 1)
                        {
                            string oldSummary = oldSum.Rows[0][0].ToString();
                            string oldSuggestion = oldSum.Rows[0][1].ToString();

                            if (!string.IsNullOrWhiteSpace(oldSummary))
                            {

                                Guid sumSummaryHeaderId = GuidGenerator.Create();

                                var dataSumSummaryHeader = new SumSummaryHeader(sumSummaryHeaderId)
                                {
                                    DisplayOrder = 1,
                                    SummaryFlag = '0',
                                    PatientRegisterId = patientRegisterId,
                                    SummaryTitle = "异常结果如下"
                                };

                                await _sumSummaryHeaderRepository.InsertAsync(dataSumSummaryHeader);

                                Guid sumSummaryContentId = GuidGenerator.Create();
                                var dataSumSummaryContent = new SumSummaryContent(sumSummaryContentId)
                                {
                                    DisplayOrder = 1,
                                    SumSummaryHeaderId = sumSummaryHeaderId,
                                    SummaryContent = oldSummary
                                };

                                await _sumSummaryContentRepository.InsertAsync(dataSumSummaryContent);

                            }


                            if (!string.IsNullOrWhiteSpace(oldSuggestion))
                            {

                                Guid sumSuggestionHeaderId = GuidGenerator.Create();

                                var dataSumSuggestionHeader = new SumSuggestionHeader(sumSuggestionHeaderId)
                                {
                                    DisplayOrder = 1,
                                    SuggestionFlag = '0',
                                    PatientRegisterId = patientRegisterId,
                                    SuggestionTitle = "健康建议如下"
                                };

                                await _sumSuggestionHeaderRepository.InsertAsync(dataSumSuggestionHeader);

                                Guid sumSuggestionContentId = GuidGenerator.Create();
                                var dataSumSuggestionContent = new SumSuggestionContent(sumSuggestionContentId)
                                {
                                    DisplayOrder = 1,
                                    SuggestionContent = oldSuggestion,
                                    SuggestionType = SuggestionTypeFlag.HealthGuidance,
                                    SumSuggestionHeaderId = sumSuggestionHeaderId
                                };

                                await _sumSuggestionContentRepository.InsertAsync(dataSumSuggestionContent);



                                #region 总症诊断
                                var oldSummaryDiagnosis = await oldDb.Ado.GetDataTableAsync($"select diagnosis_id from summary_diagnosis where patient_register_id='{oldPatientRegisterId}' order by display_order asc ");

                                if (oldSummaryDiagnosis.Rows.Count > 0)
                                {
                                    List<SumDiagnosis> sumDiagnosisInsert = new List<SumDiagnosis>();

                                    foreach (DataRow summaryDiagnosis in oldSummaryDiagnosis.Rows)
                                    {
                                        var diagnosisEnt = (await _fieldComparisonRepository.GetQueryableAsync())
                                      .Where(m => m.TableName == "diagnosis" && m.OldKeyValue == summaryDiagnosis["diagnosis_id"].ToString()).FirstOrDefault();
                                        if (diagnosisEnt != null)
                                        {

                                            var dataSumDiagnosis = new SumDiagnosis
                                            {
                                                DisplayOrder = oldSummaryDiagnosis.Rows.IndexOf(summaryDiagnosis) + 1,
                                                PatientRegisterId = patientRegisterId,
                                                DiagnosisId = Guid.Parse(diagnosisEnt.NewKeyValue),
                                                SumSuggestionHeaderId = sumSuggestionHeaderId
                                            };

                                            sumDiagnosisInsert.Add(dataSumDiagnosis);


                                        }


                                    }

                                    if (sumDiagnosisInsert.Any())
                                        await _sumDiagnosisRepository.InsertManyAsync(sumDiagnosisInsert);

                                }
                                #endregion


                            }


                        }


                        #endregion


                        var fieldComparison = new FieldComparison
                        {
                            FieldName = "id",
                            NewKeyValue = patientRegisterId.ToString(),
                            OldKeyValue = row["patient_register_id"].ToString(),
                            TableName = "patient_register"
                        };

                        await _fieldComparisonRepository.InsertAsync(fieldComparison);


                        await oldDb.Ado.ExecuteCommandAsync($"update  tb_export_key set  keyvalue='{row["patient_register_id"].ToString()}',addtime=getdate(),handlecount+=1 where tablename='patient_register_reverse' ");

                        await uow.CompleteAsync();


                        #region 修改创建者日期跟id
                        Guid registerDoctorId = Guid.Parse(_configuration.GetValue<string>("AdminId"));
                        var registerDoctorEnt = userList.Where(m => m.Name == row["register_doctor"].ToString().Trim()).FirstOrDefault();
                        if (registerDoctorEnt != null)
                        {
                            registerDoctorId = registerDoctorEnt.Id;
                        }
                        string sql_update = $"update patient_register set creator_id='{registerDoctorId}',creation_time='{Convert.ToDateTime(row["register_date"]).ToString("yyyy-MM-dd HH:mm:ss")}'";
                        sql_update += $" where id='{patientRegisterId}' ";
                        await newDb.Ado.ExecuteCommandAsync(sql_update);
                        #endregion
                    }
                }

                _logger.LogInformation($"人员数据反向处理{oldPatientRegisterList.Rows.Count}条,当前总数{hangPatientRegisterReverseCount}");
                if (isGo)
                    await TransferPatientRegisterWithDetailReverseData(handCount, isGo);
            }
            else
            {
                _logger.LogInformation("人员数据反向已处理完");
            }

        }


        #endregion


        /// <summary>
        /// 迁移子项目对照数据
        /// </summary>
        /// <returns></returns>
        public async Task TranferItemColumnReferenceData()
        {
            var oldColumnReferenceList = await oldDb.Ado.GetDataTableAsync($"select code_value,interface_code_value from column_reference_detail where column_reference_id=001 and interface_code_value!=''");
            foreach (DataRow item in oldColumnReferenceList.Rows)
            {
                var fieldComparisonEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "item" && f.OldKeyValue == item["code_value"].ToString().Trim());
                if (fieldComparisonEnt != null)
                {
                    var newItemId = Guid.Parse(fieldComparisonEnt.NewKeyValue);



                    string oldInterfaceCodeValue = item["interface_code_value"].ToString();
                    string[] oldInterfaceCodeValues = oldInterfaceCodeValue.Split(',');

                    var inputDto = new UpdateColumnReferenceInterfaceDto
                    {
                        ColumnReferenceId = Guid.Parse("3a1cfe80-ab99-509b-5447-8cf83c25fba6"),
                        AppCode = new UpdateColumnReferenceCodeDto { CodeValue = newItemId.ToString() },
                        InterfaceCodes = oldInterfaceCodeValues.Select(s => new UpdateColumnReferenceInterfaceCodeDto
                        {
                            CodeValue = s
                        }).ToList()
                    };

                    await _columnReferenceAppService.UpdateInterfaceCodeValuesAsync(inputDto);
                }

            }
        }


        /// <summary>
        /// 迁移迪安项目对照数据
        /// </summary>
        /// <returns></returns>
        public async Task TranferDAItemColumnReferenceData()
        {
            List<CommonTable> commonTables = new List<CommonTable>();
            var oldColumnReferenceItemList = await oldDb.Ado.GetDataTableAsync($"select code_value,interface_code_value from column_reference_detail where column_reference_id=002 and interface_code_value!=''");
            foreach (DataRow item in oldColumnReferenceItemList.Rows)
            {
                var fieldComparisonEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "item" && f.OldKeyValue == item["code_value"].ToString().Trim());
                if (fieldComparisonEnt != null)
                {
                    var newItemId = Guid.Parse(fieldComparisonEnt.NewKeyValue);



                    string oldInterfaceCodeValue = item["interface_code_value"].ToString();
                    string[] oldInterfaceCodeValues = oldInterfaceCodeValue.Split(',');

                    foreach (var codeValue in oldInterfaceCodeValues)
                    {
                        commonTables.Add(new CommonTable
                        {
                            CommonTableTypeId = "100",
                            DataCode = codeValue,
                            DisplayName = newItemId.ToString(),
                            DisplayOrder = oldColumnReferenceItemList.Rows.IndexOf(item) + 1,
                            SimpleCode = ""
                        });
                    }
                }

            }

            await _commonTableRepository.InsertManyAsync(commonTables);

            var oldColumnReferenceAsbitemList = await oldDb.Ado.GetDataTableAsync($"select code_value,interface_code_value from column_reference_detail where column_reference_id=003 and interface_code_value!=''");
            foreach (DataRow item in oldColumnReferenceAsbitemList.Rows)
            {
                var fieldComparisonEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "asbitem" && f.OldKeyValue == item["code_value"].ToString().Trim());
                if (fieldComparisonEnt != null)
                {
                    var newItemId = Guid.Parse(fieldComparisonEnt.NewKeyValue);



                    string oldInterfaceCodeValue = item["interface_code_value"].ToString();
                    string[] oldInterfaceCodeValues = oldInterfaceCodeValue.Split(',');

                    foreach (var codeValue in oldInterfaceCodeValues)
                    {
                        commonTables.Add(new CommonTable
                        {
                            CommonTableTypeId = "200",
                            DataCode = codeValue,
                            DisplayName = newItemId.ToString(),
                            DisplayOrder = oldColumnReferenceAsbitemList.Rows.IndexOf(item) + 1,
                            SimpleCode = ""
                        });
                    }
                }

            }

            await _commonTableRepository.InsertManyAsync(commonTables);
        }


        /// <summary>
        /// 迁移lis项目对照
        /// </summary>
        /// <returns></returns>
        public async Task TranferLisAsbitemColumnReferenceData()
        {
            var oldColumnReferenceList = await oldLisDb.Ado.GetDataTableAsync($"select code_value,interface_code_value from column_reference_detail where column_reference_id=001 and interface_code_value!=''");
            foreach (DataRow item in oldColumnReferenceList.Rows)
            {
                string[] oldInterfaceCodeValues = item["interface_code_value"].ToString().Split(',');

                var fieldComparisonList = await _fieldComparisonRepository.GetListAsync(f => f.TableName == "asbitem" && oldInterfaceCodeValues.Contains(f.OldKeyValue));
                if (fieldComparisonList.Any())
                {
                    string newAsbitemIds = string.Join(',', fieldComparisonList.Select(s => s.NewKeyValue));

                    int maxId = oldLisDb.Ado.GetInt("select max(column_reference_detail_id) from column_reference_detail");

                    await oldLisDb.Ado.ExecuteCommandAsync(@"insert into column_reference_detail(column_reference_detail_id,column_reference_id,code_value,interface_code_value) 
                   VALUES (@column_reference_detail_id,@column_reference_id,@code_value,@interface_code_value);",
                     new List<SugarParameter>() {
                            new SugarParameter("column_reference_detail_id",(maxId+1).ToString().PadLeft(6,'0')),
                            new SugarParameter("column_reference_id","003"),
                            new SugarParameter("code_value",item["code_value"]),
                            new SugarParameter("interface_code_value",newAsbitemIds)
                     });
                }

            }
        }

        #region 会员卡相关



        /// <summary>
        /// 迁移会员卡相关数据 金额后面统计
        /// </summary>
        /// <returns></returns>
        public async Task TranferCardData()
        {

            await TransferCardTypeDataAsync();
            await TransferCardRegisterDataAsync();
        }

        /// <summary>
        /// 迁移会员卡类别数据
        /// </summary>
        /// <returns></returns>
        private async Task TransferCardTypeDataAsync()
        {
            var count = await _cardTypeRepository.GetCountAsync();
            if (count == 0)
            {

                var oldCardTypeList = await oldDb.Ado.GetDataTableAsync("select card_type_id,card_type_name,card_mode_id,discount,expiry_day,remark from card_type order by display_order asc");
                if (oldCardTypeList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldCardTypeList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            Guid cardTypeId = GuidGenerator.Create();

                            var data = new CardType(cardTypeId)
                            {
                                DisplayName = row["card_type_name"].ToString(),
                                DisplayOrder = oldCardTypeList.Rows.IndexOf(row) + 1,
                                CardModeId = row["card_mode_id"].ToString() == "1" ? '0' : '1',
                                Discount = Convert.ToInt32(row["discount"].ToString()),
                                ExpiryDay = Convert.ToInt32(row["expiry_day"].ToString()),
                                Remark = row["remark"].ToString()
                            };

                            await _cardTypeRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "card_type",
                                FieldName = "id",
                                NewKeyValue = cardTypeId.ToString(),
                                OldKeyValue = row["card_type_id"].ToString()
                            };
                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }


                }
                _logger.LogInformation($"会员卡类别数据处理完毕,处理数量{oldCardTypeList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"会员卡类别数据已存在，未处理");
            }
        }


        /// <summary>
        /// 迁移会员卡数据
        /// </summary>
        /// <returns></returns>
        private async Task TransferCardRegisterDataAsync()
        {
            var count = await _cardRegisterRepository.GetCountAsync();
            if (count == 0)
            {
                var oldCardRegisterList = await oldDb.Ado.GetDataTableAsync("SELECT [card_register_id],[card_type_id],[card_no],[discount],[expiry_date],[customer_name],[id_card_no]," +
                    "[telephone],[mobile_telephone],[card_flag],[remark],[sale_date],[amender],[amended_date]  FROM [dbo].[card_register] where card_flag='Y' order by card_register_id asc");
                if (oldCardRegisterList.Rows.Count > 0)
                {

                    foreach (DataRow row in oldCardRegisterList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {

                            #region 统计金额 

                            string sql_money = $"select sum(bill_money) as card_balance from card_bill where card_register_id='{row["card_register_id"]}'";
                            var cardBalance = oldDb.Ado.SqlQuerySingle<decimal>(sql_money);
                            #endregion

                            if (cardBalance <= 0)
                                continue;
                            Guid cardRegisterId = GuidGenerator.Create();

                            var cardTypeFieldComparison = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "card_type" && f.OldKeyValue == row["card_type_id"].ToString().Trim());
                            var data = new CardRegister(cardRegisterId)
                            {
                                CardBalance = cardBalance,
                                CardNo = row["card_no"].ToString(),
                                IdNo = row["id_card_no"].ToString(),
                                CardPassword = "",
                                ExpiryDate = Convert.ToDateTime(row["expiry_date"].ToString()),
                                Remark = row["remark"].ToString(),
                                CardTypeId = Guid.Parse(cardTypeFieldComparison.NewKeyValue),
                                CustomerName = row["customer_name"].ToString(),
                                Discount = Convert.ToInt32(row["discount"].ToString()),
                                IsActive = Convert.ToChar(row["card_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                MobileTelephone = row["mobile_telephone"].ToString(),
                                Telephone = row["telephone"].ToString()
                            };

                            await _cardRegisterRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "card_register",
                                FieldName = "id",
                                NewKeyValue = cardRegisterId.ToString(),
                                OldKeyValue = row["card_register_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }

                }
                _logger.LogInformation($"会员卡数据处理完毕,处理数量{oldCardRegisterList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"会员卡数据已存在，未处理");
            }
        }
        #endregion


        /// <summary>
        /// 处理用户签名
        /// </summary>
        /// <returns></returns>
        public async Task TranferUserSignData()
        {
            var userList = await _identityUserRepository.GetListAsync();
            var oldUserList = await oldDb.Ado.GetDataTableAsync("select * from users");
            if (oldUserList.Rows.Count > 0)
            {
                foreach (DataRow row in oldUserList.Rows)
                {
                    if (!string.IsNullOrWhiteSpace(row["signature_image"].ToString()))
                    {
                        var newUser = userList.FirstOrDefault(f => f.UserName == row["user_id"].ToString());
                        if (newUser == null)
                        {
                            newUser = userList.FirstOrDefault(f => f.UserName == row["user_id"].ToString() + "2");
                        }
                        if (newUser != null)
                        {

                            string signImg = UpLoadSignImg(Guid.NewGuid(), DateTime.Now, (byte[])row["signature_image"]);

                            if (signImg != "")
                            {
                                newUser.SetProperty("user_sign", signImg);

                                await _identityUserRepository.UpdateAsync(newUser);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 处理房间数据
        /// </summary>
        /// <returns></returns>
        public async Task TranferRoomData()
        {
            var count = await _roomRepository.GetCountAsync();
            if (count == 0)
            {
                var oldRoomList = await oldDb.Ado.GetDataTableAsync(@"SELECT [room_id],[room_name],[department_id],
[for_sex_id],[room_type],[valid_flag],[display_order],[amender],[amended_date],[upper_limit_num]  FROM [dbo].[room]  order by display_order asc ");
                if (oldRoomList.Rows.Count > 0)
                {
                    foreach (DataRow row in oldRoomList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            var fieldComparisonEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "item_type"
                            && f.OldKeyValue == row["department_id"].ToString().Trim());



                            Guid roomId = GuidGenerator.Create();
                            var data = new Room(roomId)
                            {
                                DisplayName = row["room_name"].ToString(),
                                IsActive = Convert.ToChar(row["valid_flag"].ToString()),
                                MedicalCenterId = defaultMedicalCenterId,
                                DisplayOrder = oldRoomList.Rows.IndexOf(row) + 1,
                                ForSexId = ConvertForSex(row["for_sex_id"].ToString()),
                                QueueTime = 5,
                                RoomNo = row["room_id"].ToString(),
                                SimpleCode = LanguageConverter.GetPYSimpleCode(row["room_name"].ToString()),
                                ItemTypeId = Guid.Parse(fieldComparisonEnt.NewKeyValue),
                                RoomTypeFlag = Convert.ToChar(row["room_type"].ToString())
                            };

                            await _roomRepository.InsertAsync(data);

                            var fieldComparison = new FieldComparison
                            {
                                TableName = "room",
                                FieldName = "id",
                                NewKeyValue = roomId.ToString(),
                                OldKeyValue = row["room_id"].ToString()
                            };

                            await _fieldComparisonRepository.InsertAsync(fieldComparison);

                            await uow.CompleteAsync();
                        }
                    }

                }
                _logger.LogInformation($"房间数据处理完毕,处理数量{oldRoomList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"房间数据已存在，未处理");
            }
        }

        /// <summary>
        /// 处理房间明细数据
        /// </summary>
        /// <returns></returns>
        public async Task TranferRoomDetailData()
        {
            var count = await _roomDetailRepository.GetCountAsync();
            if (count == 0)
            {
                var oldRoomDetailList = await oldDb.Ado.GetDataTableAsync(@"select asbitem_id,room_id from room_asbitem ");
                if (oldRoomDetailList.Rows.Count > 0)
                {
                    var roomNos = (await _roomRepository.GetListAsync()).Select(s => s.RoomNo);
                    foreach (DataRow row in oldRoomDetailList.Rows)
                    {
                        if (roomNos.Contains(row["room_id"].ToString().Trim()))
                        {
                            using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                            {

                                var fieldComparisonEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "room"
                                && f.OldKeyValue == row["room_id"].ToString().Trim());

                                var fieldComparisonAsbitemEnt = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "asbitem"
                             && f.OldKeyValue == row["asbitem_id"].ToString().Trim());


                                var data = new RoomDetail()
                                {
                                    AsbitemId = Guid.Parse(fieldComparisonAsbitemEnt.NewKeyValue),
                                    RoomId = Guid.Parse(fieldComparisonEnt.NewKeyValue)
                                };

                                await _roomDetailRepository.InsertAsync(data);



                                await uow.CompleteAsync();
                            }
                        }
                    }

                }
                _logger.LogInformation($"房间明细数据处理完毕,处理数量{oldRoomDetailList.Rows.Count}");
            }
            else
            {
                _logger.LogInformation($"房间明细数据已存在，未处理");
            }
        }


        /// <summary>
        /// 处理用户科室
        /// </summary>
        /// <returns></returns>
        public async Task TranferUserItemTypeData()
        {
            var userList = await _identityUserRepository.GetListAsync();
            if (userList.Any())
            {
                string sql_old_qx = "select user_id,department_id from security_department order by user_id asc";
                var oldUserItemTypeList = await oldDb.Ado.GetDataTableAsync(sql_old_qx);

                foreach (var item in userList)
                {
                    using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                    {

                        var oldRows = oldUserItemTypeList.Select($"user_id = '{item.UserName}'");
                        if (oldRows.Count() > 0)
                        {
                            List<UserItemType> userItemTypes = new List<UserItemType>();

                            foreach (DataRow row in oldRows)
                            {
                                var oldItemTypeId = row["department_id"].ToString();
                                var newItemTypeId = await _fieldComparisonRepository.FirstOrDefaultAsync(f => f.TableName == "item_type" && f.OldKeyValue == oldItemTypeId);

                                //科室找最后一级
                                var chidrenItemTypeList = await _itemTypeRepository.GetListAsync(m => m.ParentId == Guid.Parse(newItemTypeId.NewKeyValue));
                                if (chidrenItemTypeList.Any())
                                {
                                    foreach (var chidrenItemType in chidrenItemTypeList)
                                    {
                                        var tempEnt = new UserItemType()
                                        {
                                            UserId = item.Id,
                                            ItemTypeId = chidrenItemType.Id
                                        };
                                        userItemTypes.Add(tempEnt);
                                    }
                                }
                                else
                                {
                                    var tempEnt = new UserItemType()
                                    {
                                        UserId = item.Id,
                                        ItemTypeId = Guid.Parse(newItemTypeId.NewKeyValue)
                                    };
                                    userItemTypes.Add(tempEnt);
                                }
                            }

                            await _userItemTypeRepository.InsertManyAsync(userItemTypes);

                        }

                        await uow.CompleteAsync();

                    }
                }

                _logger.LogInformation($"用户科室数据处理完毕,处理数量{oldUserItemTypeList.Rows.Count}");
            }

        }

        #region 私有方法

        /// <summary>
        /// 转换老系统适用性别
        /// </summary>
        /// <param name="forSexId"></param>
        /// <returns></returns>
        private char ConvertForSex(string forSexId)
        {
            if (forSexId == "0")
            {
                return 'M';
            }
            else if (forSexId == "1")
            {
                return 'F';
            }
            else
            {
                return 'A';
            }
        }

        /// <summary>
        /// 转换老系统性别
        /// </summary>
        /// <param name="SexId"></param>
        /// <returns></returns>
        private char ConvertSex(string SexId)
        {
            if (SexId == "0")
            {
                return 'M';
            }
            else if (SexId == "1")
            {
                return 'F';
            }
            else
            {
                return 'U';
            }
        }

        /// <summary>
        /// 转换头像
        /// </summary>
        /// <param name="PatientRegisterId"></param>
        /// <param name="time"></param>
        /// <param name="Photo"></param>
        /// <returns></returns>
        private string UpLoadImg(Guid PatientRegisterId, DateTime time, byte[] Photo)
        {
            string imgurl = $"photo/{time.Year}/{time.Month}/{time.Day}/" + PatientRegisterId;
            var isupload = ImageHelper.ByteToImage(Photo, imgurl);
            if (!string.IsNullOrEmpty(isupload))
                return isupload;
            else
                return "";
        }

        /// <summary>
        /// 转换签名
        /// </summary>
        /// <param name="UserId"></param>
        /// <param name="time"></param>
        /// <param name="Photo"></param>
        /// <returns></returns>
        private string UpLoadSignImg(Guid UserId, DateTime time, byte[] Photo)
        {
            string imgurl = $"UserSign/{time.Year}/{time.Month}/{time.Day}/" + UserId;
            var isupload = ImageHelper.ByteToImage(Photo, imgurl);
            if (!string.IsNullOrEmpty(isupload))
                return isupload;
            else
                return "";
        }


        /// <summary>
        /// 迁移后台用户数据
        /// </summary>
        /// <returns></returns>
        private async Task TransferUserData()
        {

            var oldUserList = await oldDb.Ado.GetDataTableAsync("select * from users");
            if (oldUserList.Rows.Count > 0)
            {
                if (await _identityUserRepository.CountAsync() == 1)
                {
                    foreach (DataRow row in oldUserList.Rows)
                    {
                        using (var uow = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
                        {
                            //#region 上传图片，获取地址

                            //string signImg = "";
                            //if (!string.IsNullOrEmpty(row["signature_image"].ToString()))
                            //{

                            //    signImg = UpLoadSignImg(Guid.NewGuid(), DateTime.Now, (byte[])row["signature_image"]);
                            //}


                            //#endregion

                            string newUserName = LanguageConverter.GetPYSimpleCode(row["user_id"].ToString().Trim());

                            var isUserName = await _identityUserRepository.FirstOrDefaultAsync(m => m.UserName == newUserName);
                            if (isUserName != null)
                            {
                                newUserName += "2";
                            }
                            var userEnt = new IdentityUserCreateNoEmailDto
                            {
                                Email = "",
                                IsActive = row["valid_flag"].ToString() == "Y" ? true : false,
                                LockoutEnabled = false,
                                Name = "",
                                Password = string.IsNullOrWhiteSpace(row["password"].ToString()) ? "888888" : row["password"].ToString(),
                                PhoneNumber = "",
                                RoleNames = new string[] { "admin" },
                                Surname = row["user_name"].ToString().Trim(),
                                UserName = newUserName,
                                UserPhoto = "",
                                UserSign = ""
                            };

                            await _myUserAppService.CreateAsync(userEnt);

                            await uow.CompleteAsync();

                        }
                    }


                }
                else
                {
                    _logger.LogInformation("用户数据已存在，未处理");
                }

            }


        }

        #endregion


        #region 默认数据

        /// <summary>
        /// 生成性别表基础数据
        /// </summary>
        /// <returns></returns>
        private async Task CreateSexAsync()
        {
            if (await _sexRepository.GetCountAsync() == 0)
            {
                List<Sex> sexes = new List<Sex>();
                sexes.Add(new Sex
                {
                    DisplayName = "未知",
                    Id = 'U',
                    DisplayOrder = 1,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("未知")
                });
                sexes.Add(new Sex
                {
                    DisplayName = "男",
                    Id = 'M',
                    DisplayOrder = 2,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("男")
                });
                sexes.Add(new Sex
                {
                    DisplayName = "女",
                    Id = 'F',
                    DisplayOrder = 3,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("女")
                });

                await _sexRepository.InsertManyAsync(sexes);
            }
        }


        /// <summary>
        /// 生成适用性别表基础数据
        /// </summary>
        /// <returns></returns>
        private async Task CreateForSexAsync()
        {
            if (await _forSexRepository.GetCountAsync() == 0)
            {
                List<ForSex> forSexes = new List<ForSex>();
                forSexes.Add(new ForSex
                {
                    DisplayName = "全部",
                    Id = 'A',
                    DisplayOrder = 1,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("全部")
                });
                forSexes.Add(new ForSex
                {
                    DisplayName = "男",
                    Id = 'M',
                    DisplayOrder = 2,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("男")
                });
                forSexes.Add(new ForSex
                {
                    DisplayName = "女",
                    Id = 'F',
                    DisplayOrder = 3,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("女")
                });

                await _forSexRepository.InsertManyAsync(forSexes);
            }
        }

        /// <summary>
        /// 生成婚姻状况表基础数据
        /// </summary>
        /// <returns></returns>
        private async Task CreateMaritalStatusAsync()
        {
            if (await _maritalStatusRepository.GetCountAsync() == 0)
            {
                List<MaritalStatus> maritalStatuses = new List<MaritalStatus>();
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "未婚",
                    Id = '0',
                    DisplayOrder = 1,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("未婚")
                });
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "已婚",
                    Id = '1',
                    DisplayOrder = 2,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("已婚")
                });
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "离异",
                    Id = '2',
                    DisplayOrder = 3,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("离异")
                });
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "丧偶",
                    Id = '3',
                    DisplayOrder = 4,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("丧偶")
                });
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "离异或丧偶",
                    Id = '4',
                    DisplayOrder = 5,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("离异或丧偶")
                });
                maritalStatuses.Add(new MaritalStatus
                {
                    DisplayName = "未知",
                    Id = '9',
                    DisplayOrder = 6,
                    SimpleCode = LanguageConverter.GetPYSimpleCode("未知")
                });



                await _maritalStatusRepository.InsertManyAsync(maritalStatuses);
            }
        }


        /// <summary>
        /// 生成结果状态
        /// </summary>
        /// <returns></returns>
        private async Task CreateResultStatusAsync()
        {
            if (await _resultStatusRepository.GetCountAsync() == 0)
            {
                #region 数据
                List<ResultStatus> resultStatuses = new List<ResultStatus>();
                resultStatuses.Add(new ResultStatus
                {
                    Id = "01",
                    DisplayName = "正常",
                    ReportPrompt = "",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 0,
                    DataInputPrompt = "",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 0,
                    DisplayOrder = 1
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "02",
                    DisplayName = "错误",
                    ReportPrompt = "×",
                    ReportBackgroundColor = 16711680,
                    ReportFontColor = 255,
                    DataInputPrompt = "×",
                    DataInputBackgroundColor = 16711808,
                    DataInputFontColor = 255,
                    DisplayOrder = 2
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "03",
                    DisplayName = "阴性",
                    ReportPrompt = "-",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 0,
                    DataInputPrompt = "-",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 0,
                    DisplayOrder = 3
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "04",
                    DisplayName = "阳性",
                    ReportPrompt = "＋",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 0,
                    DataInputPrompt = "＋",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 0,
                    DisplayOrder = 4
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "05",
                    DisplayName = "弱阳性",
                    ReportPrompt = "±",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 0,
                    DataInputPrompt = "±",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 0,
                    DisplayOrder = 5
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "06",
                    DisplayName = "偏低",
                    ReportPrompt = "↓",
                    ReportBackgroundColor = 65535,
                    ReportFontColor = 16711680,
                    DataInputPrompt = "↓",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 16711680,
                    DisplayOrder = 6
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "07",
                    DisplayName = "偏高",
                    ReportPrompt = "↑",
                    ReportBackgroundColor = 8454143,
                    ReportFontColor = 255,
                    DataInputPrompt = "↑",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 255,
                    DisplayOrder = 7
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "08",
                    DisplayName = "危急值下限",
                    ReportPrompt = "↓",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 8421376,
                    DataInputPrompt = "↓",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 8421376,
                    DisplayOrder = 8
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "09",
                    DisplayName = "危急值上限",
                    ReportPrompt = "↑",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 16711935,
                    DataInputPrompt = "↑",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 16711935,
                    DisplayOrder = 9
                });
                resultStatuses.Add(new ResultStatus
                {
                    Id = "10",
                    DisplayName = "危急值",
                    ReportPrompt = "×",
                    ReportBackgroundColor = 16777215,
                    ReportFontColor = 16711935,
                    DataInputPrompt = "×",
                    DataInputBackgroundColor = 16777215,
                    DataInputFontColor = 16711935,
                    DisplayOrder = 10
                });
                #endregion

                await _resultStatusRepository.InsertManyAsync(resultStatuses);
            }
        }


        #endregion
    }
}