Data_Upload_Api/service/city/auto_create_week_schedules_...

package city

//
import (
	"Data_Upload_Api/models/sz"
	"Data_Upload_Api/service"
	"Data_Upload_Api/utils"
	"fmt"
	_ "github.com/astaxie/beego"
	"github.com/jinzhu/gorm"
	"github.com/robfig/cron/v3"
	"github.com/shopspring/decimal"
	"math"
	"strconv"
	"strings"
	"time"
)

var createUploadDataCronJob *cron.Cron

func init() {

	// createUploadDataCronJob.AddFunc(spec2, func() {
	// 	SyncToSmzy() //深圳市数据上报
	// })
}

// 返回一个支持至 秒 级别的 cron
func newWithSeconds() *cron.Cron {
	secondParser := cron.NewParser(cron.Second | cron.Minute |
		cron.Hour | cron.Dom | cron.Month | cron.DowOptional | cron.Descriptor)
	return cron.New(cron.WithParser(secondParser), cron.WithChain())
}

//
// func BeginAutoJob() {
// 	utils.InfoLog("开启定时任务")
// 	// createUploadDataCronJob = cron.New()
// 	createUploadDataCronJob := newWithSeconds()
// 	spec := "0 30 1 * * ?" // 每天凌晨0点检测数据上报情况
// 	spec1 := "0 45 1 * * ?" // 每天凌晨0点检测数据上报情况
// 	// spec2 := "0 20 0 * * ?" // 每天凌晨0点检测数据上报情况
// 	createUploadDataCronJob.AddFunc(spec, func() {
// 		SyncToSzbl() //深圳市数据上报
// 	})

// 	createUploadDataCronJob.AddFunc(spec1, func() {
// 		SyncToSzblbr() //深圳市数据上报
// 	})
// 	createUploadDataCronJob.Start()
// }

func BeginAutoJob() {
	utils.InfoLog("开启定时任务")
	// createUploadDataCronJob = cron.New()
	createUploadDataCronJob := newWithSeconds()
	//spec := "0 0 1 * * ?"   // 每天凌晨0点检测数据上报情况
	spec1 := "0 30 1 * * ?" // 每天凌晨0点检测数据上报情况
	//spec2 := "0 0 2 * * ?"  // 每天凌晨0点检测数据上报情况
	//spec3 := "0 30 2 * * ?" // 每天凌晨0点检测数据上报情况
	//spec4 := "0 30 3 * * ?" // 每天凌晨0点检测数据上报情况
	//spec5 := "0 10 1 * * ?" // 每天凌晨0点检测数据上报情况
	//spec6 := "0 20 1 * * ?" // 每天凌晨0点检测数据上报情况
	//spec7 := "0 40 1 * * ?" // 每天凌晨0点检测数据上报情况
	//spec8 := "0 40 1 * * ?" // 每天凌晨0点检测数据上报情况
	//createUploadDataCronJob.AddFunc(spec, func() {
	//	SyncToSzbl() //深圳市数据上报
	//})
	//
	createUploadDataCronJob.AddFunc(spec1, func() {
		SyncToLhblYxxxzx() //深圳市数据上报
	})
	//
	//createUploadDataCronJob.AddFunc(spec2, func() {
	//	SyncToSzblbr() //深圳市数据上报
	//})
	//
	//createUploadDataCronJob.AddFunc(spec3, func() {
	//	SyncToSzblbrYxxxzx() //深圳市数据上报
	//})
	//
	//createUploadDataCronJob.AddFunc(spec4, func() {
	//	SyncToSzblgpYxxxzx() //深圳市数据上报
	//})
	//createUploadDataCronJob.AddFunc(spec5, func() {
	//	SyncToWzyy() //深圳市数据上报
	//})

	//createUploadDataCronJob.AddFunc(spec6, func() {
	//	SyncToSmzy() //深圳市数据上报
	//})
	//
	//createUploadDataCronJob.AddFunc(spec7, func() {
	//	SyncToSmzyYxxxzx() //深圳市数据上报
	//})

	//createUploadDataCronJob.AddFunc(spec8, func() {
	//	SyncToLg2h() //深圳市数据上报
	//})

	createUploadDataCronJob.Start()
}

// 龙华百伦
func SyncToLhblYxxxzx() {
	org := &sz.DataUploadConfig{
		OrgId:          19504,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市龙骅百伦血液透析中心",
		HospitalId:     "MA5HTGMX3",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_2019",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		SyncTBDICPractitioner_pg(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines_pg(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd_pg(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml_pg(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd_pg(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation_pg(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription_pg(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail_pg(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge_pg(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail_pg(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report_pg(orgDb, org.OrgId, org.HospitalId)
		SyncDM_pg(orgDb, org.OrgId, org.HospitalId)
		SyncTB_Diagnosis_Detail_pg(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToWzyy() {
	org := &sz.DataUploadConfig{
		OrgId:          10580,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳五洲中医院",
		HospitalId:     "783910835",
		InstType:       2,
		DbHost:         "172.8.110.22",
		DbPort:         "1433",
		DbPass:         "12361myd!@#",
		DbUser:         "sa",
		DbName:         "adapter_2019",
	}

	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		//SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)

		SyncLisIndicatorsBc(orgDb, org.OrgId, org.HospitalId)
		SyncLisReportBc(orgDb, org.OrgId, org.HospitalId)
		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}

func SyncToSzbl() {
	org := &sz.DataUploadConfig{
		OrgId:          10138,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖血液透析中心",
		HospitalId:     "MA5DB4KB6",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_2019",
	}

	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)

		SyncLisIndicatorsBc(orgDb, org.OrgId, org.HospitalId)
		SyncLisReportBc(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}

func SyncToSzblYxxxzx() {
	org := &sz.DataUploadConfig{
		OrgId:          10138,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖血液透析中心",
		HospitalId:     "MA5DB4KB6",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_2019",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 机构人员字典表  t_hd_hospital
		SyncTBDICPractitioner(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report(orgDb, org.OrgId, org.HospitalId)
		SyncTB_Diagnosis_Detail(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToSzblbr() {
	org := &sz.DataUploadConfig{
		OrgId:          10278,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖贝尔血液透析中心",
		HospitalId:     "MA5G5BPX7",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_blbe",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// city.UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)

		SyncLisIndicatorsBc(orgDb, org.OrgId, org.HospitalId)
		SyncLisReportBc(orgDb, org.OrgId, org.HospitalId)
		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToSzblbrYxxxzx() {
	org := &sz.DataUploadConfig{
		OrgId:          10278,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖贝尔血液透析中心",
		HospitalId:     "MA5G5BPX7",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_blbe",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 机构人员字典表  t_hd_hospital
		SyncTBDICPractitioner(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report(orgDb, org.OrgId, org.HospitalId)
		SyncTB_Diagnosis_Detail(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToSzblgpYxxxzx() {
	org := &sz.DataUploadConfig{
		OrgId:          10888,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖鹏港血液透析中心",
		HospitalId:     "MACWP1CB3",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "adapter",
		DbName:         "adapter_blpg",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 机构人员字典表  t_hd_hospital
		SyncTBDICPractitioner_pg(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines_pg(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd_pg(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml_pg(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd_pg(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation_pg(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record_pg(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription_pg(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail_pg(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge_pg(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail_pg(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report_pg(orgDb, org.OrgId, org.HospitalId)
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		SyncTB_Diagnosis_Detail_pg(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToSzjk() {
	org := &sz.DataUploadConfig{
		OrgId:          10245,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳静康医院血液透析中心",
		HospitalId:     "MA5DKWHG3",
		InstType:       1,
		DbHost:         "localhost",
		DbPort:         "1433",
		DbPass:         "Ya2019",
		DbUser:         "sa",
		DbName:         "xtzk",
	}

	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}
		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// city.UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)
		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}

func SyncToLg2h() {
	// 第一步：到上报配置表中找到深圳需要上报的机构
	// sz_province, _ := beego.AppConfig.Int64("sz_province")
	// sz_city, _ := beego.AppConfig.Int64("sz_city")
	// configs, _ := service.FindAllDataUploadConfigOrgInfo(sz_province, sz_city, 3)

	org := &sz.DataUploadConfig{
		OrgId:          9598,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市龙岗区第二人民医院",
		HospitalId:     "455835506",
		InstType:       1,
		DbHost:         "183.62.158.36",
		DbPort:         "61433",
		DbPass:         "LG2H+9897",
		DbUser:         "sa",
		DbName:         "adapter_2019",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}
		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)
		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}

func SyncToHqyy() {
	// 第一步：到上报配置表中找到深圳需要上报的机构
	// sz_province, _ := beego.AppConfig.Int64("sz_province")
	// sz_city, _ := beego.AppConfig.Int64("sz_city")
	// configs, _ := service.FindAllDataUploadConfigOrgInfo(sz_province, sz_city, 3)

	org := &sz.DataUploadConfig{
		OrgId:          9442,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "暨南大学附属深圳华侨医院",
		HospitalId:     "73307826X",
		InstType:       1,
		DbHost:         "183.11.232.26",
		DbPort:         "3306",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "sa",
		DbName:         "xtzk",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}
		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// // 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// // 同步病人 t_hd_patient
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// // 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// // 同步转院信息 t_hd_patient_out
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方信息 t_hd_doctors_advice
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// // 同步设备 t_hd_other_machine
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// // 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// // 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// // 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		//  患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		//  透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		//  血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		//  血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}

func SyncToSmzy() {
	// 第一步：到上报配置表中找到深圳需要上报的机构
	// sz_province, _ := beego.AppConfig.Int64("sz_province")
	// sz_city, _ := beego.AppConfig.Int64("sz_city")
	// configs, _ := service.FindAllDataUploadConfigOrgInfo(sz_province, sz_city, 3)

	org := &sz.DataUploadConfig{
		OrgId:          9504,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳生命之源血液透析中心",
		HospitalId:     "MA5EU4PC0",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "sa",
		DbName:         "adapter_2019",
	}

	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 同步医院信息  t_hd_hospital
		SyncHospital(orgDb, org.OrgId, org.HospitalId, org.InstType, org.DepartmentName)
		// 同步员工 t_hd_staff
		SyncStaff(orgDb, org.OrgId, org.HospitalId)
		// 布局表（T_HD_LAYOUT）
		SyncLayout(orgDb, org.OrgId, org.HospitalId)
		// 同步设备 t_hd_dm
		SyncDM(orgDb, org.OrgId, org.HospitalId)
		// 同步水处理器  t_hd_wm
		SyncWMS(orgDb, org.OrgId, org.HospitalId)
		// 同步维修 t_hd_maintain
		SyncMachineRepair(orgDb, org.OrgId, org.HospitalId)
		// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
		SyncDisinfectMethod(orgDb, org.OrgId, org.HospitalId)
		// 同步其它设备信息表（T_HD_OTHER_MACHINE）
		SyncOtherMachine(orgDb, org.OrgId, org.HospitalId)
		// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
		SyncDmDisinfect(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		SyncLisCulture(orgDb, org.OrgId, org.HospitalId)
		// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN)
		SyncDialysate(orgDb, org.OrgId, org.HospitalId)
		// 水处理机消毒记录表（T_HD_WM_DISINFECT）
		SyncWmDisinfect(orgDb, org.OrgId, org.HospitalId)
		//透析用水PH值检测表(T_HD_WATER_PH)
		SynLisWaterPh(orgDb, org.OrgId, org.HospitalId)
		//透析用水细菌培养检测表(T_HD_WATER_BC)
		SyncLisWaterBc(orgDb, org.OrgId, org.HospitalId)
		//透析用水内毒素检测表(T_HD_WATER_EN)
		SyncLisWaterEn(orgDb, org.OrgId, org.HospitalId)
		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		SynLisWaterNc(orgDb, org.OrgId, org.HospitalId)
		//透析用水水硬度检测表(T_HD_WATER_WH)
		SynListHadWater(orgDb, org.OrgId, org.HospitalId)
		//透析用水游离氯检测表(T_HD_WATER_FC)
		SyncLisWaterFc(orgDb, org.OrgId, org.HospitalId)
		//透析用水电解质检测表（T_HD_WATER_EL）
		SyncLisWaterEl(orgDb, org.OrgId, org.HospitalId)
		//透析用水微量元素检测表（T_HD_WATER_TE）
		SyncLisWaterTe(orgDb, org.OrgId, org.HospitalId)
		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		SyncLisAirDetection(orgDb, org.OrgId, org.HospitalId)
		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		SyncLisBodyDetection(orgDb, org.OrgId, org.HospitalId)
		// 同步血透患者基本信息表（T_HD_PATIENT）
		SyncPatient(orgDb, org.OrgId, org.HospitalId)
		// 同步患者退出信息表（T_HD_PATIENT_QUIT）
		SyncPatientOut(orgDb, org.OrgId, org.HospitalId)
		// 同步处方 t_hd_ps
		SyncPs(orgDb, org.OrgId, org.HospitalId)
		// 同步处方药品 t_hd_ps
		SyncPsMedicine(orgDb, org.OrgId, org.HospitalId)
		// 患者诊断信息表（T_HD_DIAGNOSIS）
		SyncDiagnosis(orgDb, org.OrgId, org.HospitalId)
		// 患者通路信息表（T_HD_ACCESS）
		SyncAccess(orgDb, org.OrgId, org.HospitalId)
		//导管感染记录表(T_HD_CI)
		SynListHdCi(orgDb, org.OrgId, org.HospitalId)
		//导管感染转归记录表(T_HD_CI_OUTCOME)
		SynLisHdCiOutCome(orgDb, org.OrgId, org.HospitalId)
		// UpdatePatient(orgDb, org.OrgId, org.HospitalId)
		// 患者传染病检查记录表（T_HD_INFECTION
		SyncInfection(orgDb, org.OrgId, org.HospitalId)
		// 同步排班  t_hd_shift
		SyncShift(orgDb, org.OrgId, org.HospitalId)
		// 同步透析医嘱表（T_HD_DOCTORS_ADVICE）
		SyncDoctorAdvice(orgDb, org.OrgId, org.HospitalId)
		// 同步患者透析记录 t_hd_dialysis
		SyncDialysis(orgDb, org.OrgId, org.HospitalId)
		// 同步透中信息 t_hd_middle
		SyncMiddle(orgDb, org.OrgId, org.HospitalId)
		// 透析并发症记录表（T_HD_COMPLICATION）
		SyncComplication(orgDb, org.OrgId, org.HospitalId)
		// 透析床位表（T_HD_SICKBED）
		SyncSickbed(orgDb, org.OrgId, org.HospitalId)
		// 同步透析床位分区 t_hd_division
		SyncDivision(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检测结果表（T_HD_LIS_REPORT）
		SyncLisReport(orgDb, org.OrgId, org.HospitalId)
		// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
		SyncLisIndicators(orgDb, org.OrgId, org.HospitalId)
		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }
	return
}
func SyncToSmzyYxxxzx() {
	org := &sz.DataUploadConfig{
		OrgId:          9504,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳生命之源血液透析中心",
		HospitalId:     "MA5EU4PC0",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "sa",
		DbName:         "adapter_2019",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 机构人员字典表  t_hd_hospital
		SyncTBDICPractitioner(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report(orgDb, org.OrgId, org.HospitalId)
		SyncTB_Diagnosis_Detail(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

func SyncToSmzyt() {
	org := &sz.DataUploadConfig{
		OrgId:          9504,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳生命之源血液透析中心",
		HospitalId:     "MA5EU4PC0",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "1Q2W3e4r!@#$",
		DbUser:         "sa",
		DbName:         "adapter_2019",
	}

	// for _, org := range configs {
	// 第二步：跟进配置，创建数据库连接
	if len(org.DbHost) > 0 && len(org.DbUser) > 0 && len(org.DbPort) > 0 && len(org.DbPass) > 0 && len(org.DbName) > 0 {
		orgDb, err := service.CreateSqlServiceDB(org.DbHost, org.DbPort, org.DbUser, org.DbPass, org.DbName)
		if err != nil {
			utils.ErrorLog("创建数据库连接失败:%v", err)
			return
		}

		// 第三步：开始同步数据
		// 机构人员字典表  t_hd_hospital
		SyncTBDICPractitioner(orgDb, org.OrgId, org.HospitalId)
		// 药品目录字典表
		SyncTBDICMedicines(orgDb, org.OrgId, org.HospitalId)
		// 药品对照字典
		SyncTBDICYpdzzd(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmml(orgDb, org.OrgId, org.HospitalId)
		// 诊疗项目目录字典表
		SyncTBDICZlxmdzzd(orgDb, org.OrgId, org.HospitalId)
		// 机构床位  t_hd_wm
		SyncTMDICTBED(orgDb, org.OrgId, org.HospitalId)
		// 门诊患者信息表
		SyncTBMZPatientInformation(orgDb, org.OrgId, org.HospitalId)
		// 挂号表
		SyncTBHISMZReg(orgDb, org.OrgId, org.HospitalId)
		// 门诊就诊记录表
		SyncTB_YL_MZ_Medical_Record(orgDb, org.OrgId, org.HospitalId)
		// 门诊处方主表
		SyncTB_CIS_Prescription(orgDb, org.OrgId, org.HospitalId)
		// 18.	门诊处方明细表
		SyncTB_CIS_Prescription_Detail(orgDb, org.OrgId, org.HospitalId)
		// 19.	门诊收费表
		SyncTB_HIS_MZ_Charge(orgDb, org.OrgId, org.HospitalId)
		// 20.	门诊收费明细表
		SyncTB_HIS_MZ_Fee_Detail(orgDb, org.OrgId, org.HospitalId)
		// 业务量收入统计表
		SyncTB_STAT_YWL_Report(orgDb, org.OrgId, org.HospitalId)

		// 第四步：关闭数据库连接
		service.CloseDB(orgDb)
	}
	// }

	return
}

// 同步医院信息
func SyncHospital(rdb *gorm.DB, org_id int64, hospital_id string, inst_type int64, department_name string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	// 第二步：跟进上次同步时间找出这个时间段内增加的数据
	org, _ := service.FindOrgData(org_id, sync_time)
	if org.ID > 0 {
		hospital := &sz.TempHdHospital{
			HospitalId:     hospital_id,
			InstType:       strconv.FormatInt(inst_type, 10),
			DepartmentName: department_name,
			AuthorizedBeds: int64(len(org.DeviceNumber)),
			CreateTime:     time.Now(),
			UpdateTime:     time.Now(),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}
		err := service.CreateOrgRecord(rdb, hospital)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       1,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		}
	}
}

// 同步水处理器
func SyncWMS(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 22)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步水处理机
	waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	var wms []*sz.TempHdWm
	for _, item := range waterMachine {
		wm := &sz.TempHdWm{
			HospitalId:     hospital_id,
			EquipmentId:    strconv.FormatInt(item.ID, 10),
			EquipmentBrand: item.ManufactureFactory,
			EnableTime:     time.Unix(item.StartDate, 0),
			EquipmentType:  "21",
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     time.Unix(item.Mtime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}

		wms = append(wms, wm)
	}

	if len(wms) > 0 {
		err := service.BatchCreateWMsRecord(wms, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       22,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}

}

// 同步员工
func SyncStaff(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 21)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	roles, _ := service.FindOrgRolesData(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	var staffs []*sz.TempHdStaff
	for _, role := range roles {
		var title int
		switch role.UserType {
		case 2:
			title = 1
			break
		case 3:
			title = 2
			break
		}

		staff := &sz.TempHdStaff{
			HospitalId:    hospital_id,
			StaffId:       strconv.FormatInt(role.AdminUserId, 10),
			StaffName:     role.UserName,
			Position:      int64(title),
			PermanentType: 1,
			CreateTime:    time.Unix(role.Ctime, 0),
			UpdateTime:    time.Unix(role.Mtime, 0),
			Sjscsj:        time.Now(),
			Xgbz:          0,
		}
		staffs = append(staffs, staff)

	}
	if len(staffs) > 0 {
		err := service.BatchCreateStaffRecord(staffs, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       21,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步分区
func SyncLayout(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2001)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步分区信息
	zones, _ := service.FindOrgDeviceZone(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	var layouts []*sz.TempHdLayout
	for _, zone := range zones {
		layout := &sz.TempHdLayout{
			HospitalId:    hospital_id,
			PartitionName: zone.Name,
			CreateTime:    time.Unix(zone.CreateTime, 0),
			Sjscsj:        time.Now(),
			Xgbz:          "0",
		}
		layouts = append(layouts, layout)
	}
	if len(layouts) > 0 {
		err := service.BatchCreateLayoutRecord(layouts, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2001,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func UpdatePatient(rdb *gorm.DB, org_id int64, hospital_id string) {
	patients, _ := service.FindSyncPatientAllData(rdb)
	for _, patient := range patients {
		IdNo := patient.IdNo
		fmt.Println(patient)
		patientInfo, _ := service.FindPatientInfoByIdno(IdNo)
		fmt.Println(patientInfo)
		if patientInfo.ID > 0 {
			patient.Ylyl1 = patientInfo.HomeAddress
			service.UpdateSyncPatient(patientInfo.ID, patient.Ylyl1, rdb)
		}
	}
}

// 同步血透患者基本信息表（T_HD_PATIENT）
func SyncPatientByID(rdb *gorm.DB, org_id int64, hospital_id string, patient_id int64) {
	// 第一步：根据机构id获取上次同步时间
	// syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 15)
	// var sync_time int64
	// if syncLastInfo.ID > 0 {
	// 	sync_time = syncLastInfo.SyncTime
	// } else {
	// 	sync_time = 0
	// }

	//同步员工信息
	patient, _ := service.FindOrgPatientInfoById(patient_id)
	hdpatients, _ := service.FindSyncPatient(patient_id, rdb)
	if len(hdpatients) > 0 {
		return
	}
	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	var hdPatients []*sz.TempHdPatient
	idcard_year, _ := strconv.Atoi(Substr(patient.IdCardNo, 6, 4)) // 年
	idcard_mo, _ := strconv.Atoi(Substr(patient.IdCardNo, 10, 2))  // 月

	idcard_day, _ := strconv.Atoi(Substr(patient.IdCardNo, 12, 2)) // 日

	date := strconv.Itoa(idcard_year)
	if idcard_mo < 10 {
		date = date + "-0" + strconv.Itoa(idcard_mo)
	} else {
		date = date + "-" + strconv.Itoa(idcard_mo)
	}

	if idcard_day < 10 {
		date = date + "-0" + strconv.Itoa(idcard_day)
	} else {
		date = date + "-" + strconv.Itoa(idcard_day)
	}

	local, _ := time.LoadLocation("Local")
	birthday, _ := time.ParseInLocation("2006-01-02", date, local)
	fmt.Println(birthday)

	var isCKD int

	value := strings.Index(patient.Diagnose, "慢性肾脏病")
	value2 := strings.Index(patient.Diagnose, "CKD")
	value3 := strings.Index(patient.Diagnose, "慢性肾衰竭")

	if value != -1 || value2 != -1 || value3 != -1 {
		isCKD = 1
	} else {
		isCKD = 0
	}

	p := &sz.TempHdPatient{
		HospitalId:        hospital_id,
		PatientNk:         patient.ID,
		CardNo:            "000000000000000000",
		CardType:          1,
		IdNo:              patient.IdCardNo,
		IdType:            "01",
		PatientName:       patient.Name,
		Gender:            strconv.FormatInt(patient.Gender, 10),
		BornDate:          birthday,
		DiagnosisSummary:  patient.Diagnose,
		IsCrf:             strconv.Itoa(isCKD),
		DialysisStartTime: time.Unix(patient.FirstDialysisDate, 0),
		LocalStartTime:    time.Unix(patient.HospitalFirstDialysisDate, 0),
		OutpatientNo:      patient.DialysisNo,
		HospitalizedNo:    "_",
		CreateTime:        time.Unix(patient.CreatedTime, 0),
		UpdateTime:        time.Unix(patient.UpdatedTime, 0),
		Sjscsj:            time.Now(),
		Ylyl1:             patient.HomeAddress,
		Xgbz:              0,
	}

	if patient.FirstDialysisDate != 0 {
		p.DialysisStartTime = time.Unix(patient.FirstDialysisDate, 0)
	}
	if patient.HospitalFirstDialysisDate != 0 {
		p.LocalStartTime = time.Unix(patient.HospitalFirstDialysisDate, 0)
	}

	hdPatients = append(hdPatients, p)
	service.BatchCreatePatinet(hdPatients, rdb)
}

// 同步血透患者基本信息表（T_HD_PATIENT）
func SyncPatient(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 15)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	patients, _ := service.FindOrgPatientData(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	var hdPatients []*sz.TempHdPatient
	for _, patient := range patients {

		idcard_year, _ := strconv.Atoi(Substr(patient.IdCardNo, 6, 4)) // 年
		idcard_mo, _ := strconv.Atoi(Substr(patient.IdCardNo, 10, 2))  // 月

		idcard_day, _ := strconv.Atoi(Substr(patient.IdCardNo, 12, 2)) // 日

		date := strconv.Itoa(idcard_year)
		if idcard_mo < 10 {
			date = date + "-0" + strconv.Itoa(idcard_mo)
		} else {
			date = date + "-" + strconv.Itoa(idcard_mo)
		}

		if idcard_day < 10 {
			date = date + "-0" + strconv.Itoa(idcard_day)
		} else {
			date = date + "-" + strconv.Itoa(idcard_day)
		}

		local, _ := time.LoadLocation("Local")
		birthday, _ := time.ParseInLocation("2006-01-02", date, local)
		fmt.Println(birthday)

		var isCKD int

		value := strings.Index(patient.Diagnose, "慢性肾脏病")
		value2 := strings.Index(patient.Diagnose, "CKD")
		value3 := strings.Index(patient.Diagnose, "慢性肾衰竭")

		if value != -1 || value2 != -1 || value3 != -1 {
			isCKD = 1
		} else {
			isCKD = 0
		}

		p := &sz.TempHdPatient{
			HospitalId:        hospital_id,
			PatientNk:         patient.ID,
			CardNo:            "000000000000000000",
			CardType:          1,
			IdNo:              patient.IdCardNo,
			IdType:            "01",
			PatientName:       patient.Name,
			Gender:            strconv.FormatInt(patient.Gender, 10),
			BornDate:          birthday,
			DiagnosisSummary:  patient.Diagnose,
			IsCrf:             strconv.Itoa(isCKD),
			DialysisStartTime: time.Unix(patient.FirstDialysisDate, 0),
			LocalStartTime:    time.Unix(patient.HospitalFirstDialysisDate, 0),
			OutpatientNo:      patient.DialysisNo,
			HospitalizedNo:    "_",
			CreateTime:        time.Unix(patient.CreatedTime, 0),
			UpdateTime:        time.Unix(patient.UpdatedTime, 0),
			Sjscsj:            time.Now(),
			Ylyl1:             patient.HomeAddress,
			Xgbz:              0,
		}

		if patient.FirstDialysisDate != 0 {
			p.DialysisStartTime = time.Unix(patient.FirstDialysisDate, 0)
		}
		if patient.HospitalFirstDialysisDate != 0 {
			p.LocalStartTime = time.Unix(patient.HospitalFirstDialysisDate, 0)
		}

		hdPatients = append(hdPatients, p)
	}

	if len(hdPatients) > 0 {
		err := service.BatchCreatePatinet(hdPatients, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       15,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

func Substr(str string, start, length int) string {
	rs := []rune(str)
	rl := len(rs)
	end := 0
	if start < 0 {
		start = rl - 1 + start
	}
	end = start + length
	if start > end {
		start, end = end, start
	}
	if start < 0 {
		start = 0
	}
	if start > rl {
		start = rl
	}
	if end < 0 {
		end = 0
	}
	if end > rl {
		end = rl
	}
	return string(rs[start:end])

}

// 同步排班
func SyncShift(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 19)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	var hdShift []*sz.TempHdShift
	schs, _ := service.FindOrgScheduleData(org_id, sync_time, time.Now().Unix())

	for _, sch := range schs {
		shift := &sz.TempHdShift{
			PsId:           strconv.FormatInt(sch.ID, 10),
			HospitalId:     hospital_id,
			PatientNk:      strconv.FormatInt(sch.PatientId, 10),
			ScheduleDate:   time.Unix(sch.ScheduleDate, 0),
			ShiftType:      strconv.FormatInt(sch.ScheduleType, 10),
			SickbedNo:      sch.DeviceNumber.ID,
			ScheduleStatus: "1",
			CreateTime:     time.Unix(sch.CreatedTime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}

		hdShift = append(hdShift, shift)
	}

	if len(hdShift) > 0 {
		err := service.BatchCreateSchedual(hdShift, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       19,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}

}

// 同步处方
func SyncPs(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 17)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	var hdPrescription []*sz.TempHdPs
	prescriptions, _ := service.FindOrgDialysisPrescriptionData(org_id, sync_time, time.Now().Unix())
	for _, item := range prescriptions {

		ps := &sz.TempHdPs{
			PrescribeId:   strconv.FormatInt(item.ID, 10),
			HospitalId:    hospital_id,
			PatientNk:     strconv.FormatInt(item.PatientId, 10),
			Sjscsj:        time.Now(),
			Xgbz:          0,
			PrescribeTime: time.Unix(item.RecordDate, 0),
			CreateTime:    time.Unix(item.CreatedTime, 0),
		}

		switch item.ModeId {
		case 1:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "HD"
			ps.RrtType = 1

			break
		case 2:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "HDF"
			ps.RrtType = 3
			break
		case 4:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "HP"
			ps.RrtType = 5
			break
		case 5:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "HF"
			ps.RrtType = 2
			break
		case 7:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "IUF"
			ps.RrtType = 6
			break
		default:
			ps.DialysisFrequency = 5
			ps.FrequencyUnit = 2
			ps.RrtTypeName = "HD"
			ps.RrtType = 1
			break
		}

		hdPrescription = append(hdPrescription, ps)
	}
	if len(hdPrescription) > 0 {
		var err error
		for _, hdps := range hdPrescription {
			err = service.BatchCreatePsOther(hdps, rdb)
		}

		// err := service.BatchCreatePs(hdPrescription, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       17,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}

}

// 同步处方药物
func SyncPsMedicine(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 18)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	var tempPsmedicine []*sz.TempHdPsMedicine
	prescriptions, _ := service.FindOrgDialysisPrescriptionData(org_id, sync_time, time.Now().Unix())
	for _, item := range prescriptions {
		psm := &sz.TempHdPsMedicine{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			MedicineTypeId: "5",
			MedicineId:     "1",
			CreateTime:     time.Unix(item.CreatedTime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}
		tempPsmedicine = append(tempPsmedicine, psm)
	}

	if len(tempPsmedicine) > 0 {
		err := service.BatchCreatePsm(tempPsmedicine, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       18,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

// 同步患者退出信息表（T_HD_PATIENT_QUIT）
func SyncPatientOutByID(rdb *gorm.DB, org_id int64, hospital_id string, patient_id int64) {
	// 第一步：根据机构id获取上次同步时间
	// syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 16)
	// var sync_time int64
	// if syncLastInfo.ID > 0 {
	// 	sync_time = syncLastInfo.SyncTime
	// } else {
	// 	sync_time = 0
	// }

	var hdPatientOuts []*sz.TempHdPatientOut
	patient, _ := service.FindOrgPatientOutDataByID(patient_id)
	orgPatient, _ := service.FindOrgPatientInfoById(patient_id)
	if orgPatient.UserOrgId != org_id {
		return
	}

	hdpatients, _ := service.FindSyncPatientOut(patient_id, rdb)
	if len(hdpatients) > 0 {
		return
	}

	p := &sz.TempHdPatientOut{
		Sn:           strconv.FormatInt(patient.ID, 10),
		HospitalId:   hospital_id,
		PatientNk:    strconv.FormatInt(patient.PatientId, 10),
		SequelaeDate: time.Unix(patient.LapsetoTime, 0),
		CreateTime:   time.Unix(patient.CreatedTime, 0),
		Sjscsj:       time.Now(),
		Xgbz:         "0",
	}
	if patient.LapsetoType == 2 {
		p.SequelaeType = "2"
		p.DeathReason = "0"
		p.ExtReason = "13"
	} else {
		p.SequelaeType = "1"
		p.DeathReason = "99"
		p.ExtReason = "0"
	}
	hdPatientOuts = append(hdPatientOuts, p)
	service.BatchCreatePatientOut(hdPatientOuts, rdb)

}

// 同步患者退出信息表（T_HD_PATIENT_QUIT）
func SyncPatientOut(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 16)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	var hdPatientOuts []*sz.TempHdPatientOut
	patients, _ := service.FindOrgPatientOutDataTwo(sync_time, time.Now().Unix())
	//
	for _, patient := range patients {
		orgPatient, _ := service.FindOrgPatientInfoById(patient.PatientId)
		if orgPatient.UserOrgId != org_id {
			continue
		} else {
			p := &sz.TempHdPatientOut{
				Sn:           strconv.FormatInt(patient.ID, 10),
				HospitalId:   hospital_id,
				PatientNk:    strconv.FormatInt(patient.PatientId, 10),
				SequelaeDate: time.Unix(patient.Ctime, 0),
				CreateTime:   time.Unix(patient.Ctime, 0),
				Sjscsj:       time.Now(),
				Xgbz:         "0",
			}
			switch patient.PatientSource {
			case 3:
				p.SequelaeType = "1"
				p.DeathReason = "99"
				p.ExtReason = "13"
				break
			case 4:
				p.SequelaeType = "2"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			case 5:
				p.SequelaeType = "3"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			case 6:
				p.SequelaeType = "4"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			case 7:
				p.SequelaeType = "5"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			case 8:
				p.SequelaeType = "6"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			case 9:
				p.SequelaeType = "7"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			default:
				p.SequelaeType = "2"
				p.DeathReason = "0"
				p.ExtReason = "13"
				break
			}
			hdPatientOuts = append(hdPatientOuts, p)
		}
	}

	if len(hdPatientOuts) > 0 {
		err := service.BatchCreatePatientOut(hdPatientOuts, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       16,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

// 同步处方信息
func SyncDoctorAdvice(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 6)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	var hdDoctorAdvices []*sz.TempHdDoctorsAdvice
	dialysisPrescriptions, _ := service.FindOrgDialysisPrescriptionData(org_id, sync_time, time.Now().Unix())

	for _, dp := range dialysisPrescriptions {
		if dp.DialysisOrder.ID > 0 {
			advice := &sz.TempHdDoctorsAdvice{
				MedicalOrderId:   strconv.FormatInt(dp.ID, 10),
				HospitalId:       hospital_id,
				DialysisId:       strconv.FormatInt(dp.DialysisOrder.ID, 10),
				OrderType:        "1",
				PatientNk:        strconv.FormatInt(dp.PatientId, 10),
				DialysisDuration: dp.DialysisDurationHour*60 + dp.DialysisDurationMinute,
				BloodVol:         int64(math.Floor(dp.BloodFlowVolume + 0/5)),
				Anticoagulant:    dp.Anticoagulant,
				CreateTime:       time.Unix(dp.CreatedTime, 0),
				Sjscsj:           time.Now(),
				Xgbz:             0,
				DryWeight:        dp.AssessmentBeforeDislysis.DryWeight,
			}
			switch dp.ModeId {
			case 1:
				advice.RrtTypeName = "HD"
				advice.RrtType = 1
				break
			case 2:
				advice.RrtTypeName = "HDF"
				advice.RrtType = 3
				break
			case 4:
				advice.RrtTypeName = "HP"
				advice.RrtType = 5
				break
			case 5:
				advice.RrtTypeName = "HF"
				advice.RrtType = 2
				break
			case 7:
				advice.RrtTypeName = "IUF"
				advice.RrtType = 6
				break
			default:
				advice.RrtTypeName = "HD"
				advice.RrtType = 1
			}
			if advice.RrtType == 0 {
				continue
			}
			hdDoctorAdvices = append(hdDoctorAdvices, advice)
		}

	}

	if len(hdDoctorAdvices) > 0 {
		err := service.BatchCreateDoctorsAdvice(hdDoctorAdvices, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       6,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}

}

func SyncMiddle(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 36)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1662134400
	}

	var hdMiddle []*sz.TempHdMiddle
	monitors, _ := service.FindOrgMonitorRecordData(org_id, sync_time, time.Now().Unix())

	for _, item := range monitors {

		mid := &sz.TempHdMiddle{
			Sn:          item.ID,
			HospitalId:  hospital_id,
			DialysisId:  strconv.FormatInt(item.DialysisOrder.ID, 10),
			MonitorTime: time.Unix(item.OperateTime, 0),
			Sbp:         int64(math.Floor(item.SystolicBloodPressure + 0/5)),
			Dbp:         int64(math.Floor(item.DiastolicBloodPressure + 0/5)),
			PatientNk:   strconv.FormatInt(item.PatientId, 10),
			CreateTime:  time.Unix(item.CreatedTime, 0),
			Sjscsj:      time.Now(),
			Xgbz:        0,
		}
		if mid.Sbp > 999 {
			continue
		}

		if mid.Dbp > 999 {
			continue
		}

		hdMiddle = append(hdMiddle, mid)
	}

	if len(hdMiddle) > 0 {
		err := service.BatchCreateMonitor(hdMiddle, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       36,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}

}

// 同步设备
func SyncOtherMachine(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 13)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步设备
	waterMachine, _ := service.FindOrgOtherMachineData(org_id, sync_time, time.Now().Unix())
	var wms []*sz.TempHdOtherMachine
	for _, item := range waterMachine {
		wm := &sz.TempHdOtherMachine{
			HospitalId:     hospital_id,
			EquipmentId:    strconv.FormatInt(item.ID, 10),
			EquipmentBrand: item.ManufactureFactory,
			EnableTime:     time.Unix(item.BuyDate, 0),
			Status:         "1",
			EquipmentType:  "99",
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     time.Unix(item.Mtime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           "0",
		}
		switch item.MachineStatus {
		case 1:
			wm.Status = "1"
			break
		case 4:
			wm.Status = "3"
			break
		default:
			wm.Status = "1"
			break
		}

		wms = append(wms, wm)
	}

	if len(wms) > 0 {
		err := service.BatchCreateOtherMachineRecord(wms, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       13,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}

}

// 同步透析机消毒检测记录表（T_HD_DM_DISINFECT）
func SyncDmDisinfect(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2003)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步透析机消毒检测记录表
	deviceInformations, _ := service.FindOrgDeviceInformationData(org_id, sync_time, time.Now().Unix())
	var dfs []*sz.TempHdDmDisinfect
	for _, item := range deviceInformations {
		if item.VMDeviceAddmacher.DeviceType != 1 {
			continue
		} else {
			df := &sz.TempHdDmDisinfect{
				Sn:             strconv.FormatInt(item.ID, 10),
				HospitalId:     hospital_id,
				EquipmentId:    strconv.FormatInt(item.EquimentId, 10),
				SickbedNo:      strconv.FormatInt(item.BedNumber, 10),
				InspectionTime: time.Unix(item.Date, 0),
				IsQualified:    "1",
				CaseOrder:      "1",
				CreateTime:     time.Unix(item.Ctime, 0),
				Sjscsj:         time.Now(),
				Xgbz:           "0",
			}
			dfs = append(dfs, df)
		}
	}

	if len(dfs) > 0 {
		err := service.BatchCreateDmDisinfect(dfs, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2003,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}

}

// 水处理机消毒记录表（T_HD_WM_DISINFECT）
func SyncWmDisinfect(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2004)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步透析机消毒检测记录表
	deviceInformations, _ := service.FindOrgDeviceInformationData(org_id, sync_time, time.Now().Unix())
	var dfs []*sz.TempWdDmDisinfect
	for _, item := range deviceInformations {
		if item.VMDeviceAddmacher.DeviceType != 2 {
			continue
		} else {
			df := &sz.TempWdDmDisinfect{
				Sn:             strconv.FormatInt(item.ID, 10),
				HospitalId:     hospital_id,
				EquipmentId:    strconv.FormatInt(item.EquimentId, 10),
				InspectionTime: time.Unix(item.Date, 0),
				IsQualified:    "1",
				CaseOrder:      "1",
				CreateTime:     time.Unix(item.Ctime, 0),
				Sjscsj:         time.Now(),
				Xgbz:           "0",
			}
			dfs = append(dfs, df)
		}
	}

	if len(dfs) > 0 {
		err := service.BatchCreateWmDisinfect(dfs, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2004,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步维修
func SyncMachineRepair(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 11)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步设备
	hdMaintain, _ := service.FindOrgMachineRepairData(org_id, sync_time, time.Now().Unix())
	var maintain []*sz.TempHdMaintain
	for _, item := range hdMaintain {
		mt := &sz.TempHdMaintain{
			Sn:          strconv.FormatInt(item.ID, 10),
			HospitalId:  hospital_id,
			EquipmentId: strconv.FormatInt(item.VMDeviceAddmacher.ID, 10),
			RepairTime:  time.Unix(item.GuaranteeDate, 0),
			CreateTime:  time.Unix(item.Ctime, 0),
			Sjscsj:      time.Now(),
			Xgbz:        0,
		}
		switch item.VMDeviceAddmacher.DeviceType {
		case 1:
			mt.EquipmentType = "11"
			break
		case 2:
			mt.EquipmentType = "21"
			break
		case 3:
			mt.EquipmentType = "99"
			break
		}

		maintain = append(maintain, mt)
	}

	if len(maintain) > 0 {
		err := service.BatchCreateMainTain(maintain, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       11,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步设备消毒方法表（T_HD_DISINFECT_METHOD
func SyncDisinfectMethod(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2002)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步设备消毒方法表
	deviceplans, _ := service.FindOrgDevicePlan(org_id, sync_time, time.Now().Unix())
	var disinfects []*sz.TempHdDisinfectMethod
	for _, item := range deviceplans {
		disinfect := &sz.TempHdDisinfectMethod{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquipmentId:     strconv.FormatInt(item.VMDeviceAddmacher.ID, 10),
			DisinfectMethod: "1",
			Concentration:   "0_",
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Mtime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		switch item.VMDeviceAddmacher.DeviceType {
		case 1:
			disinfect.EquipmentType = "11"
			break
		case 2:
			disinfect.EquipmentType = "21"
			break
		case 3:
			disinfect.EquipmentType = "99"
			break
		}

		switch item.MachineDisinfectant {
		case 1:
			disinfect.Disinfector = "0.22%季铵盐"
			break
		case 2:
			disinfect.Disinfector = "500mg/l含氯消毒剂"
			break
		case 3:
			disinfect.Disinfector = "1000mg/l含氯消毒剂"
			break
		case 4:
			disinfect.Disinfector = "1500mg/l含氯消毒剂"
			break
		case 5:
			disinfect.Disinfector = "消毒湿巾"
			break
		default:
			disinfect.Disinfector = "0_"
			break
		}

		disinfects = append(disinfects, disinfect)
	}

	if len(disinfects) > 0 {
		err := service.BatchCreateDisinfectMethod(disinfects, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2002,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步 透析机信息表
func SyncDM_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 5)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步设备
	dm, _ := service.FindOrgMachineData(9504, sync_time, time.Now().Unix())
	var hdms []*sz.TempHdDm
	for _, item := range dm {
		hdm := &sz.TempHdDm{
			HospitalId:     hospital_id,
			EquipmentId:    strconv.FormatInt(item.ID, 10),
			SickbedNo:      strconv.FormatInt(item.DeviceNumber.ID, 10),
			SickbedType:    "0",
			EquipmentBrand: item.ManufactureFactory,
			EnableTime:     time.Unix(item.BuyDate, 0),
			EquipmentType:  "12",
			Bbp:            "1",
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     time.Unix(item.Mtime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           strconv.FormatInt(0, 10),
		}
		switch item.MachineStatus {
		case 1:
			hdm.Status = "1"
			break
		case 4:
			hdm.Status = "3"
			break
		}
		hdms = append(hdms, hdm)
	}

	if len(hdms) > 0 {
		err := service.BatchCreateHDMRecord(hdms, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       5,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncDM(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 5)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步设备
	dm, _ := service.FindOrgMachineData(org_id, sync_time, time.Now().Unix())
	var hdms []*sz.TempHdDm
	for _, item := range dm {
		hdm := &sz.TempHdDm{
			HospitalId:     hospital_id,
			EquipmentId:    strconv.FormatInt(item.ID, 10),
			SickbedNo:      strconv.FormatInt(item.DeviceNumber.ID, 10),
			SickbedType:    "0",
			EquipmentBrand: item.ManufactureFactory,
			EnableTime:     time.Unix(item.BuyDate, 0),
			EquipmentType:  "12",
			Bbp:            "1",
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     time.Unix(item.Mtime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           strconv.FormatInt(0, 10),
		}
		switch item.MachineStatus {
		case 1:
			hdm.Status = "1"
			break
		case 4:
			hdm.Status = "3"
			break
		}
		hdms = append(hdms, hdm)
	}

	if len(hdms) > 0 {
		err := service.BatchCreateHDMRecord(hdms, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       5,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步患者透析记录
func SyncDialysis(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	var tempDialysis []*sz.TempHdDialysis
	dialysisData, _ := service.FindOrgDialysisData(org_id, sync_time, time.Now().Unix())

	for _, item := range dialysisData {
		psm := &sz.TempHdDialysis{
			DialysisId:            strconv.FormatInt(item.ID, 10),
			HospitalId:            hospital_id,
			PatientNk:             strconv.FormatInt(item.PatientId, 10),
			PsId:                  strconv.FormatInt(item.Schedule.ID, 10),
			DialysisDate:          time.Unix(item.DialysisDate, 0),
			SickbedNo:             strconv.FormatInt(item.DeviceNumber.ID, 10),
			DivisionId:            strconv.FormatInt(item.Schedule.PartitionId, 10),
			EquipmentId:           strconv.FormatInt(item.DeviceNumber.ID, 10),
			MixDialysis:           "0",
			TotalTreatDuration:    item.AssessmentAfterDislysis.ActualTreatmentHour*60 + item.AssessmentAfterDislysis.ActualTreatmentMinute,
			IsHospitalization:     "0",
			IsEmergency:           "0",
			IsPerioperativePeriod: "0",
			BeforeSbp:             int64(item.AssessmentBeforeDislysis.SystolicBloodPressure),
			BeforeDbp:             int64(item.AssessmentBeforeDislysis.DiastolicBloodPressure),
			AfterSbp:              int64(item.AssessmentAfterDislysis.SystolicBloodPressure),
			AfterDbp:              int64(item.AssessmentAfterDislysis.DiastolicBloodPressure),
			BeforeWeight:          item.AssessmentBeforeDislysis.WeightBefore,
			AfterWeight:           item.AssessmentAfterDislysis.WeightAfter,
			Ktv:                   item.AssessmentAfterDislysis.Ktv,
			Urr:                   item.AssessmentAfterDislysis.Urr,
			ChargeDoctorId:        strconv.FormatInt(item.VMDialysisPrescription.PrescriptionDoctor, 10),
			ChargeNurseId:         strconv.FormatInt(item.StartNurse, 10),
			UpNurseId:             strconv.FormatInt(item.StartNurse, 10),
			DownNurseId:           strconv.FormatInt(item.FinishNurse, 10),
			CheckNurseId:          strconv.FormatInt(item.FinishNurse, 10),
			PunctureNurseId:       strconv.FormatInt(item.PunctureNurse, 10),
			StartTime:             time.Unix(item.StartTime, 0),
			EndTime:               time.Unix(item.EndTime, 0),
			CreateTime:            time.Unix(item.CreatedTime, 0),
			Sjscsj:                time.Now(),
			Xgbz:                  0,
		}

		if item.AssessmentAfterDislysis.ActualUltrafiltration < 10 {
			psm.ActualufMl = int64(item.AssessmentAfterDislysis.ActualUltrafiltration * 1000)
		} else {
			psm.ActualufMl = int64(item.AssessmentAfterDislysis.ActualUltrafiltration)
		}

		if item.VMDialysisPrescription.TargetUltrafiltration < 10 {
			psm.Ufv = int64(item.VMDialysisPrescription.TargetUltrafiltration * 1000)
		} else {
			psm.Ufv = int64(item.VMDialysisPrescription.TargetUltrafiltration)
		}

		if item.AssessmentAfterDislysis.ActualDisplacement < 10 {
			psm.TotalReplace = int64(item.AssessmentAfterDislysis.ActualDisplacement * 1000)
		} else {
			psm.TotalReplace = int64(item.AssessmentAfterDislysis.ActualDisplacement)
		}

		tempDialysis = append(tempDialysis, psm)
	}

	if len(tempDialysis) > 0 {
		err := service.BatchCreateDialysis(tempDialysis, rdb)

		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}

}

// 同步透析床位分区
func SyncDivision(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 55)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步透析床位分区
	dm, _ := service.FindOrgDeviceZoneRecordData(org_id, sync_time, time.Now().Unix())
	var hdms []*sz.TempHdDivision
	for _, item := range dm {
		hdm := &sz.TempHdDivision{
			DivisionId:   strconv.FormatInt(item.ID, 10),
			HospitalId:   hospital_id,
			DivisionName: item.Name,
			DivisionType: strconv.FormatInt(item.Type, 10),
			CreateTime:   time.Unix(item.CreateTime, 0),
			UpdateTime:   time.Unix(item.ModifyTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         strconv.FormatInt(0, 10),
		}

		hdms = append(hdms, hdm)
	}

	if len(hdms) > 0 {
		err := service.CreateHDDivision(hdms, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       55,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

// 患者通路信息表
func SyncAccess(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 56)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	//同步员工信息
	patientaccess, _ := service.FindOrgAccess(org_id, sync_time, time.Now().Unix())
	var accessList []*sz.TempHdAccess
	for _, item := range patientaccess {
		access := &sz.TempHdAccess{
			AccessId:       strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			PatientNk:      strconv.FormatInt(item.PatientId, 10),
			AccessType:     "1",
			AccessTypeName: "自体动静脉内瘘",
			AccessStatus:   "1",
			SetupDate:      time.Unix(item.StartTime, 0),
			FirstUseTime:   time.Unix(item.FirstStartTime, 0),
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     time.Unix(item.Mtime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}
		accessList = append(accessList, access)
	}

	if len(accessList) > 0 {
		err := service.CreateAccess(accessList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       56,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 透析床位表
func SyncSickbed(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 57)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步床位
	devices, _ := service.FindOrgDeviceNumber(org_id, sync_time, time.Now().Unix())
	var sickbedList []*sz.TempHdSickbed
	for _, device := range devices {
		sickbed := &sz.TempHdSickbed{
			SickbedNo:   device.ID,
			HospitalId:  hospital_id,
			DivisionId:  strconv.FormatInt(device.ZoneId, 10),
			SickbedCode: device.Number,
			SickbedType: "0",
			CreateTime:  time.Unix(device.Ctime, 0),
			UpdateTime:  time.Unix(device.Mtime, 0),
			Sjscsj:      time.Now(),
			Xgbz:        0,
		}
		sickbedList = append(sickbedList, sickbed)
	}

	if len(sickbedList) > 0 {
		err := service.CreateSickbed(sickbedList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       57,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 患者诊断信息表（T_HD_DIAGNOSIS）
func SyncDiagnosis(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 58)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1577808000
	}

	//同步患者
	prescriptions, _ := service.FindOrgDialysisPrescriptionData(org_id, sync_time, time.Now().Unix())

	var diagnosisList []*sz.TempHdDiagnosis
	for _, item := range prescriptions {
		diagnosis := &sz.TempHdDiagnosis{
			DiagnosisId:         strconv.FormatInt(item.ID, 10),
			HospitalId:          hospital_id,
			PatientNk:           strconv.FormatInt(item.PatientId, 10),
			DiagnosisTime:       time.Unix(item.CreatedTime, 0),
			DiagnosisType:       "10",
			DiagnosisTypeItem:   "1001",
			DiagnosisTypeDetail: "100113",
			CreateTime:          time.Unix(item.CreatedTime, 0),
			UpdateTime:          time.Unix(item.UpdatedTime, 0),
			Sjscsj:              time.Now(),
			Xgbz:                0,
		}
		diagnosisList = append(diagnosisList, diagnosis)
	}

	if len(diagnosisList) > 0 {
		err := service.CreateDiagnosis(diagnosisList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       58,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 患者传染病检查记录表（T_HD_INFECTION
func SyncInfection(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 59)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步患者
	patients, _ := service.FindOrgPatientDataOne(org_id)
	var infectionList []*sz.TempHdInfection
	for _, patient := range patients {
		//	查询有没有做传染病检查并返回检验检查时间
		if org_id == 9598 {
			// 龙岗二院
			inspections, _ := service.FindOrgInspectionGroupLgey(org_id, sync_time, time.Now().Unix(), patient.ID)
			if len(inspections) > 0 {
				for _, insp := range inspections {
					inspection_arr, _ := service.FindOrgInspectionGroupLgeyTwo(org_id, insp.InspectDate, patient.ID)
					if len(inspection_arr) > 0 {
						infection := &sz.TempHdInfection{
							Sn:         strconv.FormatInt(patient.ID, 10),
							HospitalId: hospital_id,
							PatientNk:  strconv.FormatInt(patient.ID, 10),
							Hbv:        9,
							Hcv:        9,
							Rpr:        9,
							Hiv:        9,
							Hbsag:      9,
							Hbsab:      9,
							Hbeag:      9,
							Hbeab:      9,
							Hbcab:      9,
							CheckDate:  time.Unix(insp.InspectDate, 0),
							DoctorId:   "599",
							CreateTime: time.Now(),
							Sjscsj:     time.Now(),
							Xgbz:       0,
						}

						for _, infectionDiseases := range inspection_arr {
							infection.Sn = strconv.FormatInt(infectionDiseases.ID, 10)
							// 乙肝
							if len(infectionDiseases.InspectValue) > 0 {
								if infectionDiseases.ItemId == 62 || infectionDiseases.ItemId == 18001056 || infectionDiseases.ItemId == 18001049 || infectionDiseases.ItemId == 18006001 || infectionDiseases.ItemId == 18131005 || infectionDiseases.ItemId == 18142001 || infectionDiseases.ItemId == 18169001 || infectionDiseases.ItemId == 18245006 || infectionDiseases.ItemId == 178 {
									infection.Hbv = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbv = 1
									}
								}
								// 丙肝
								if infectionDiseases.ItemId == 60 || infectionDiseases.ItemId == 18006002 || infectionDiseases.ItemId == 18130001 || infectionDiseases.ItemId == 18143001 || infectionDiseases.ItemId == 18178001 || infectionDiseases.ItemId == 18245001 || infectionDiseases.ItemId == 179 {
									infection.Hcv = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hcv = 1
									}
								}
								// 梅毒
								if infectionDiseases.ItemId == 112 || infectionDiseases.ItemId == 18001055 || infectionDiseases.ItemId == 18008002 || infectionDiseases.ItemId == 18044001 || infectionDiseases.ItemId == 18051001 || infectionDiseases.ItemId == 18051003 || infectionDiseases.ItemId == 18065001 || infectionDiseases.ItemId == 18065003 || infectionDiseases.ItemId == 18076001 || infectionDiseases.ItemId == 18076003 || infectionDiseases.ItemId == 18078001 || infectionDiseases.ItemId == 18078004 || infectionDiseases.ItemId == 18131007 || infectionDiseases.ItemId == 18141001 || infectionDiseases.ItemId == 18167001 || infectionDiseases.ItemId == 18175002 || infectionDiseases.ItemId == 18176001 || infectionDiseases.ItemId == 18176002 || infectionDiseases.ItemId == 18176004 || infectionDiseases.ItemId == 18230002 || infectionDiseases.ItemId == 18241002 || infectionDiseases.ItemId == 18246002 || infectionDiseases.ItemId == 18246003 || infectionDiseases.ItemId == 112 {
									infection.Rpr = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Rpr = 1
									}
								}
								// 艾滋病
								if infectionDiseases.ItemId == 111 || infectionDiseases.ItemId == 18008001 || infectionDiseases.ItemId == 18001054 || infectionDiseases.ItemId == 18131006 || infectionDiseases.ItemId == 18044002 || infectionDiseases.ItemId == 18051002 || infectionDiseases.ItemId == 18065002 || infectionDiseases.ItemId == 18076002 || infectionDiseases.ItemId == 18078003 || infectionDiseases.ItemId == 18114001 || infectionDiseases.ItemId == 18175001 || infectionDiseases.ItemId == 18176003 || infectionDiseases.ItemId == 18230001 || infectionDiseases.ItemId == 18241001 || infectionDiseases.ItemId == 18246001 || infectionDiseases.ItemId == 111 {
									infection.Rpr = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Rpr = 1
									}
								}
								// HBsAg 乙型肝炎表面抗原;
								if infectionDiseases.ItemId == 62 || infectionDiseases.ItemId == 18006001 || infectionDiseases.ItemId == 18131005 || infectionDiseases.ItemId == 18142001 || infectionDiseases.ItemId == 18169001 || infectionDiseases.ItemId == 18245006 || infectionDiseases.ItemId == 62 {
									infection.Hbsag = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbsag = 1
									}
								}
								// HBsAb  乙型肝炎表面抗体;
								if infectionDiseases.ItemId == 63 || infectionDiseases.ItemId == 18006006 || infectionDiseases.ItemId == 18131004 || infectionDiseases.ItemId == 18142005 || infectionDiseases.ItemId == 18169002 || infectionDiseases.ItemId == 18245005 || infectionDiseases.ItemId == 63 {
									infection.Hbsab = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbsab = 1
									}
								}
								// HBeAg 乙肝病毒e抗原;
								if infectionDiseases.ItemId == 64 || infectionDiseases.ItemId == 18006003 || infectionDiseases.ItemId == 18131003 || infectionDiseases.ItemId == 18142004 || infectionDiseases.ItemId == 18169003 || infectionDiseases.ItemId == 18245004 || infectionDiseases.ItemId == 64 {
									infection.Hbeag = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbeag = 1
									}
								}
								// HBeAb 乙型肝炎E抗体;
								if infectionDiseases.ItemId == 65 || infectionDiseases.ItemId == 18006004 || infectionDiseases.ItemId == 18131002 || infectionDiseases.ItemId == 18142003 || infectionDiseases.ItemId == 18169004 || infectionDiseases.ItemId == 18245003 || infectionDiseases.ItemId == 65 {
									infection.Hbeab = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbeab = 1
									}
								}
								// HBcAb  乙肝核心抗体;
								if infectionDiseases.ItemId == 66 || infectionDiseases.ItemId == 18006005 || infectionDiseases.ItemId == 18131001 || infectionDiseases.ItemId == 18142002 || infectionDiseases.ItemId == 18169005 || infectionDiseases.ItemId == 18245002 || infectionDiseases.ItemId == 66 {
									infection.Hbcab = 0
									if strings.Contains(infectionDiseases.InspectValue, "阳性") {
										infection.Hbcab = 1
									}
								}
							}
						}
						infectionList = append(infectionList, infection)
					}
				}
			}
		}

		if org_id == 10138 {
			// 深圳百霖
			inspections, _ := service.FindOrgInspectionGroupSzbl(org_id, sync_time, time.Now().Unix(), patient.ID)
			if len(inspections) > 0 {
				for _, insp := range inspections {
					inspection_arr, _ := service.FindOrgInspectionGroupSzblTwo(org_id, insp.InspectDate, patient.ID)
					if len(inspection_arr) > 0 {
						infection := &sz.TempHdInfection{
							Sn:         strconv.FormatInt(patient.ID, 10),
							HospitalId: hospital_id,
							PatientNk:  strconv.FormatInt(patient.ID, 10),
							Hbv:        9,
							Hcv:        9,
							Rpr:        9,
							Hiv:        9,
							Hbsag:      9,
							Hbsab:      9,
							Hbeag:      9,
							Hbeab:      9,
							Hbcab:      9,
							CheckDate:  time.Unix(insp.InspectDate, 0),
							DoctorId:   "2232",
							CreateTime: time.Now(),
							Sjscsj:     time.Now(),
							Xgbz:       0,
						}

						for _, infectionDiseases := range inspection_arr {
							infection.Sn = strconv.FormatInt(infectionDiseases.ID, 10)
							infection.CheckDate = time.Unix(infectionDiseases.InspectDate, 0)
							// 乙肝
							if infectionDiseases.ItemId == 101380001 || infectionDiseases.ItemId == 101387010 {
								infection.Hbv = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbv = 1
								}
							}
							// 丙肝
							if infectionDiseases.ItemId == 101380006 || infectionDiseases.ItemId == 101387004 {
								infection.Hcv = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hcv = 1
								}
							}
							// 梅毒
							if infectionDiseases.ItemId == 101380009 || infectionDiseases.ItemId == 101387001 {
								infection.Rpr = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Rpr = 1
								}
							}
							// 艾滋病
							if infectionDiseases.ItemId == 101380010 || infectionDiseases.ItemId == 101387005 {
								infection.Rpr = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Rpr = 1
								}
							}
							// HBsAg 乙型肝炎表面抗原;
							if infectionDiseases.ItemId == 101380001 || infectionDiseases.ItemId == 101387010 {
								infection.Hbsag = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbsag = 1
								}
							}
							// HBsAb  乙型肝炎表面抗体;
							if infectionDiseases.ItemId == 101380002 || infectionDiseases.ItemId == 101387009 {
								infection.Hbsab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbsab = 1
								}
							}
							// HBeAg 乙肝病毒e抗原;
							if infectionDiseases.ItemId == 101380003 || infectionDiseases.ItemId == 101387008 {
								infection.Hbeag = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbeag = 1
								}
							}
							// HBeAb 乙型肝炎E抗体;
							if infectionDiseases.ItemId == 101380004 || infectionDiseases.ItemId == 101387007 {
								infection.Hbeab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbeab = 1
								}
							}
							// HBcAb  乙肝核心抗体;
							if infectionDiseases.ItemId == 101380005 || infectionDiseases.ItemId == 101387006 {
								infection.Hbcab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbcab = 1
								}
							}
						}
						infectionList = append(infectionList, infection)
					}
				}
			}
		}

		if org_id == 10278 {
			// 深圳百霖贝尔
			inspections, _ := service.FindOrgInspectionGroupSzblbr(org_id, sync_time, time.Now().Unix(), patient.ID)
			if len(inspections) > 0 {
				for _, insp := range inspections {
					inspection_arr, _ := service.FindOrgInspectionGroupSzblbrTwo(org_id, insp.InspectDate, patient.ID)
					if len(inspection_arr) > 0 {
						infection := &sz.TempHdInfection{
							Sn:         strconv.FormatInt(patient.ID, 10),
							HospitalId: hospital_id,
							PatientNk:  strconv.FormatInt(patient.ID, 10),
							Hbv:        9,
							Hcv:        9,
							Rpr:        9,
							Hiv:        9,
							Hbsag:      9,
							Hbsab:      9,
							Hbeag:      9,
							Hbeab:      9,
							Hbcab:      9,
							CheckDate:  time.Unix(insp.InspectDate, 0),
							DoctorId:   "751",
							CreateTime: time.Now(),
							Sjscsj:     time.Now(),
							Xgbz:       0,
						}

						for _, infectionDiseases := range inspection_arr {
							infection.Sn = strconv.FormatInt(infectionDiseases.ID, 10)
							infection.CheckDate = time.Unix(infectionDiseases.InspectDate, 0)
							// 乙肝
							if infectionDiseases.ItemId == 101380302 || infectionDiseases.ItemId == 101385607 {
								infection.Hbv = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbv = 1
								}
							}
							// 丙肝
							if infectionDiseases.ItemId == 101380307 || infectionDiseases.ItemId == 101385609 {
								infection.Hcv = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hcv = 1
								}
							}
							// 梅毒
							if infectionDiseases.ItemId == 101380009 || infectionDiseases.ItemId == 101385601 {
								infection.Rpr = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Rpr = 1
								}
							}
							// 艾滋病
							if infectionDiseases.ItemId == 101380301 || infectionDiseases.ItemId == 101380301 {
								infection.Rpr = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Rpr = 1
								}
							}
							// HBsAg 乙型肝炎表面抗原;
							if infectionDiseases.ItemId == 101380302 || infectionDiseases.ItemId == 101385607 {
								infection.Hbsag = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbsag = 1
								}
							}
							// HBsAb  乙型肝炎表面抗体;
							if infectionDiseases.ItemId == 101380303 || infectionDiseases.ItemId == 101385606 {
								infection.Hbsab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbsab = 1
								}
							}
							// HBeAg 乙肝病毒e抗原;
							if infectionDiseases.ItemId == 101380304 || infectionDiseases.ItemId == 101385605 {
								infection.Hbeag = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbeag = 1
								}
							}
							// HBeAb 乙型肝炎E抗体;
							if infectionDiseases.ItemId == 101380305 || infectionDiseases.ItemId == 101385604 {
								infection.Hbeab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbeab = 1
								}
							}
							// HBcAb  乙肝核心抗体;
							if infectionDiseases.ItemId == 101380306 || infectionDiseases.ItemId == 101385603 {
								infection.Hbcab = 0
								if strings.Contains(infectionDiseases.InspectValue, "阳性") {
									infection.Hbcab = 1
								}
							}
						}
						infectionList = append(infectionList, infection)
					}
				}
			}
		}

		if org_id == 9504 {
			inspections, _ := service.FindOrgInspectionGroupLgey(org_id, sync_time, time.Now().Unix(), patient.ID)
			if len(inspections) > 0 {
				for _, insp := range inspections {
					inspection_arr, _ := service.FindOrgInspectionGroupTwo(org_id, insp.InspectDate, patient.ID)
					if len(inspection_arr) > 0 {
						infection := &sz.TempHdInfection{
							Sn:         strconv.FormatInt(patient.ID, 10),
							HospitalId: hospital_id,
							PatientNk:  strconv.FormatInt(patient.ID, 10),
							Hbv:        9,
							Hcv:        9,
							Rpr:        9,
							Hiv:        9,
							Hbsag:      9,
							Hbsab:      9,
							Hbeag:      9,
							Hbeab:      9,
							Hbcab:      9,
							CheckDate:  time.Unix(patient.CreatedTime, 0),
							DoctorId:   strconv.FormatInt(patient.RegistrarsId, 10),
							CreateTime: time.Now(),
							Sjscsj:     time.Now(),
							Xgbz:       0,
						}

						for _, infectionDiseases := range inspection_arr {
							infection.Sn = strconv.FormatInt(infectionDiseases.ID, 10)
							if infectionDiseases.ItemId == 60 {
								infection.Hcv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hcv = 1
								}
							}
							if infectionDiseases.ItemId == 62 {
								infection.Hbsag = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbsag = 1
								}
							}

							if infectionDiseases.ItemId == 63 {
								infection.Hbsab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbsab = 1
								}
							}

							if infectionDiseases.ItemId == 64 {
								infection.Hbeag = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbeag = 1
								}
							}

							if infectionDiseases.ItemId == 65 {
								infection.Hbeab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbeab = 1
								}
							}

							if infectionDiseases.ItemId == 66 {
								infection.Hbcab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbcab = 1
								}
							}

							if infectionDiseases.ItemId == 111 {
								infection.Hiv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hiv = 1
								}
							}

							if infectionDiseases.ItemId == 112 {
								infection.Rpr = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Rpr = 1
								}
							}

							if infectionDiseases.ItemId == 178 {
								infection.Hbv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbv = 1
								}
							}

							if infectionDiseases.ItemId == 179 {
								infection.Hcv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hcv = 1
								}
							}

						}
						infectionList = append(infectionList, infection)
					}
				}
			}
		}

		if org_id == 10580 {
			inspections, _ := service.FindOrgInspectionGroupOne(org_id, sync_time, time.Now().Unix(), patient.ID)
			if len(inspections) > 0 {
				for _, insp := range inspections {
					inspection_arr, _ := service.FindOrgInspectionGroupTwo(org_id, insp.InspectDate, patient.ID)
					if len(inspection_arr) > 0 {
						infection := &sz.TempHdInfection{
							Sn:         strconv.FormatInt(patient.ID, 10),
							HospitalId: hospital_id,
							PatientNk:  strconv.FormatInt(patient.ID, 10),
							Hbv:        9,
							Hcv:        9,
							Rpr:        9,
							Hiv:        9,
							Hbsag:      9,
							Hbsab:      9,
							Hbeag:      9,
							Hbeab:      9,
							Hbcab:      9,
							CheckDate:  time.Unix(patient.CreatedTime, 0),
							DoctorId:   strconv.FormatInt(patient.RegistrarsId, 10),
							CreateTime: time.Now(),
							Sjscsj:     time.Now(),
							Xgbz:       0,
						}

						for _, infectionDiseases := range inspection_arr {
							infection.Sn = strconv.FormatInt(infectionDiseases.ID, 10)
							if infectionDiseases.ItemId == 60 {
								infection.Hcv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hcv = 1
								}
							}
							if infectionDiseases.ItemId == 62 {
								infection.Hbsag = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbsag = 1
								}
							}

							if infectionDiseases.ItemId == 63 {
								infection.Hbsab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbsab = 1
								}
							}

							if infectionDiseases.ItemId == 64 {
								infection.Hbeag = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbeag = 1
								}
							}

							if infectionDiseases.ItemId == 65 {
								infection.Hbeab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbeab = 1
								}
							}

							if infectionDiseases.ItemId == 66 {
								infection.Hbcab = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbcab = 1
								}
							}

							if infectionDiseases.ItemId == 111 {
								infection.Hiv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hiv = 1
								}
							}

							if infectionDiseases.ItemId == 112 {
								infection.Rpr = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Rpr = 1
								}
							}

							if infectionDiseases.ItemId == 178 {
								infection.Hbv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hbv = 1
								}
							}

							if infectionDiseases.ItemId == 179 {
								infection.Hcv = 0
								if infectionDiseases.InspectValue == "阳性" {
									infection.Hcv = 1
								}
							}

						}
						infectionList = append(infectionList, infection)
					}
				}
			}
		}

	}

	if len(infectionList) > 0 {
		err := service.CreateInfection(infectionList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       59,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 透析并发症记录表（T_HD_COMPLICATION）
func SyncComplication(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 60)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1662134400
	}

	//同步监测记录
	var complicationList []*sz.TempHdComplication
	monitors, _ := service.FindOrgMonitorRecordByLike(org_id, "%肌肉痉挛%", sync_time, time.Now().Unix())
	for _, monitor := range monitors {
		complication := &sz.TempHdComplication{
			Sn:           strconv.FormatInt(monitor.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(monitor.PatientId, 10),
			DialysisId:   monitor.DialysisOrderId,
			MonitorId:    monitor.ID,
			NeopathyTime: 1,
			NeopathyType: "3",
			NeopathyDesc: monitor.Symptom,
			CreateTime:   time.Unix(monitor.CreatedTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		complicationList = append(complicationList, complication)
	}

	monitorones, _ := service.FindOrgMonitorRecordByLike(org_id, "%胸痛%", sync_time, time.Now().Unix())
	for _, monitor := range monitorones {
		complicationone := &sz.TempHdComplication{
			Sn:           strconv.FormatInt(monitor.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(monitor.PatientId, 10),
			DialysisId:   monitor.DialysisOrderId,
			MonitorId:    monitor.ID,
			NeopathyTime: 1,
			NeopathyType: "6",
			NeopathyDesc: monitor.Symptom,
			CreateTime:   time.Unix(monitor.CreatedTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		complicationList = append(complicationList, complicationone)
	}

	monitortwos, _ := service.FindOrgMonitorRecordByLike(org_id, "%恶心%", sync_time, time.Now().Unix())
	for _, monitor := range monitortwos {
		complicationtwo := &sz.TempHdComplication{
			Sn:           strconv.FormatInt(monitor.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(monitor.PatientId, 10),
			DialysisId:   monitor.DialysisOrderId,
			MonitorId:    monitor.ID,
			NeopathyTime: 1,
			NeopathyType: "7",
			NeopathyDesc: monitor.Symptom,
			CreateTime:   time.Unix(monitor.CreatedTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		complicationList = append(complicationList, complicationtwo)
	}

	monitorfours, _ := service.FindOrgMonitorRecordByLike(org_id, "%头痛%", sync_time, time.Now().Unix())
	for _, monitor := range monitorfours {
		complicationfour := &sz.TempHdComplication{
			Sn:           strconv.FormatInt(monitor.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(monitor.PatientId, 10),
			DialysisId:   monitor.DialysisOrderId,
			MonitorId:    monitor.ID,
			NeopathyTime: 1,
			NeopathyType: "11",
			NeopathyDesc: monitor.Symptom,
			CreateTime:   time.Unix(monitor.CreatedTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		complicationList = append(complicationList, complicationfour)
	}

	monitorthrees, _ := service.FindOrgMonitorRecordByLike(org_id, "%发热%", sync_time, time.Now().Unix())
	for _, monitor := range monitorthrees {
		complicationthree := &sz.TempHdComplication{
			Sn:           strconv.FormatInt(monitor.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(monitor.PatientId, 10),
			DialysisId:   monitor.DialysisOrderId,
			MonitorId:    monitor.ID,
			NeopathyTime: 1,
			NeopathyType: "15",
			NeopathyDesc: monitor.Symptom,
			CreateTime:   time.Unix(monitor.CreatedTime, 0),
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		complicationList = append(complicationList, complicationthree)
	}

	if len(complicationList) > 0 {
		err := service.CreateComplication(complicationList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       60,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncLisReportBc(rdb *gorm.DB, org_id int64, hospital_id string) {
	var sync_time int64
	sync_time = 1704038400
	inspections, _ := service.FindOrgInspection(org_id, sync_time, time.Now().Unix())
	var lisReportList []*sz.TempHdLisReport
	tempFlag := 0
	for _, inspection := range inspections {
		tempFlag = 0
		LabSno := strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10)
		// 判断该检查是否已经同步过
		hdLisReportInfo, _ := service.FindLisReportByLAB(rdb, LabSno)
		if len(hdLisReportInfo) > 0 {
			tempFlag = 0
		} else {
			tempFlag = 1
		}
		if tempFlag == 1 {
			lisReport := &sz.TempHdLisReport{
				LabSno:          strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10),
				HospitalId:      hospital_id,
				PatientNk:       strconv.FormatInt(inspection.PatientId, 10),
				ReportDate:      time.Unix(inspection.InspectDate, 0),
				CheckDate:       "1",
				JzNo:            inspection.Patients.AdmissionNumber,
				MzFlag:          "1",
				ZyNo:            "-",
				MzNo:            inspection.Patients.AdmissionNumber,
				DepartmentCode:  "1001",
				DepartmentName:  "血透中心",
				CardNo:          inspection.Patients.IdCardNo,
				CardType:        "9",
				PatientName:     inspection.Patients.Name,
				DepCode:         "A03.05",
				DepName:         "血透中心",
				InspectedType:   "1",
				ReportCategry:   inspection.ProjectName,
				ApplicationName: inspection.ProjectName,
				ApplicationType: strconv.FormatInt(inspection.ProjectId, 10),
				CheckName:       inspection.ProjectName,
				CheckItemName:   inspection.ProjectName,
				CheckItemCode:   strconv.FormatInt(inspection.ProjectId, 10),
				RecordCcount:    0,
				CheckResult:     "完成",
				DiagnoseName:    "-",
				CreateTime:      time.Unix(inspection.CreatedTime, 0),
				Sjscsj:          time.Now(),
				Xgbz:            0,
			}
			lisReportList = append(lisReportList, lisReport)
		} else {
			continue
		}
	}
	if len(lisReportList) > 0 {
		err := service.CreateLisReport(lisReportList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       61,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 血透患者检测结果表（T_HD_LIS_REPORT）
func SyncLisReport(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 61)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1672502400
	}

	//同步监测记录
	inspections, _ := service.FindOrgInspection(org_id, sync_time, time.Now().Unix())
	var lisReportList []*sz.TempHdLisReport
	tempFlag := 1
	for _, inspection := range inspections {
		tempFlag = 1
		// for _, tempReport := range lisReportList {
		// 	// fmt.Println("2")
		// 	if tempReport.ReportDate == time.Unix(inspection.InspectDate, 0) && tempReport.ApplicationType == strconv.FormatInt(inspection.ProjectId, 10) && tempReport.PatientNk == strconv.FormatInt(inspection.PatientId, 10) {
		// 		tempFlag = 0
		// 		break
		// 	} else {
		// 		continue
		// 	}
		// }
		if tempFlag == 1 {
			lisReport := &sz.TempHdLisReport{
				LabSno:          strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10),
				HospitalId:      hospital_id,
				PatientNk:       strconv.FormatInt(inspection.PatientId, 10),
				ReportDate:      time.Unix(inspection.InspectDate, 0),
				CheckDate:       "1",
				JzNo:            inspection.Patients.AdmissionNumber,
				MzFlag:          "1",
				ZyNo:            "-",
				MzNo:            inspection.Patients.AdmissionNumber,
				DepartmentCode:  "1001",
				DepartmentName:  "血透中心",
				CardNo:          inspection.Patients.IdCardNo,
				CardType:        "9",
				PatientName:     inspection.Patients.Name,
				DepCode:         "A03.05",
				DepName:         "血透中心",
				InspectedType:   "1",
				ReportCategry:   inspection.ProjectName,
				ApplicationName: inspection.ProjectName,
				ApplicationType: strconv.FormatInt(inspection.ProjectId, 10),
				CheckName:       inspection.ProjectName,
				CheckItemName:   inspection.ProjectName,
				CheckItemCode:   strconv.FormatInt(inspection.ProjectId, 10),
				RecordCcount:    0,
				CheckResult:     "完成",
				DiagnoseName:    "-",
				CreateTime:      time.Unix(inspection.CreatedTime, 0),
				Sjscsj:          time.Now(),
				Xgbz:            0,
			}
			lisReportList = append(lisReportList, lisReport)
		} else {
			continue
		}
	}

	if len(lisReportList) > 0 {
		err := service.CreateLisReport(lisReportList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       61,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncLisIndicatorsBcUpdate(rdb *gorm.DB, org_id int64, hospital_id string) {
	var sync_time int64
	sync_time = 1704038400

	//同步监测记录
	inspections, _ := service.FindOrgInspectionThree(org_id, sync_time, time.Now().Unix(), "101380701")
	for _, inspection := range inspections {
		LabSno := strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10)
		// 判断该检查是否已经同步过
		service.FindLisINDICATORSByNoUpdate(rdb, LabSno, strconv.FormatInt(inspection.ID, 10), inspection.InspectValue, inspection.XtInspectionReference.Unit, time.Now())

		//if len(hdLisReportInfo.InspectedResultNo) > 0 {
		//	utils.InfoLog("1111111%v:", hdLisReportInfo)
		//	if len(hdLisReportInfo.InspectedResultNo) > 0 {
		//		hdLisReportInfo.InspectedResultDesc = inspection.InspectValue
		//		hdLisReportInfo.InspectedResultValue = inspection.InspectValue
		//		hdLisReportInfo.InspectedResultUnit = inspection.XtInspectionReference.Unit
		//		hdLisReportInfo.UnitType = inspection.XtInspectionReference.Unit
		//		hdLisReportInfo.CreateTime = time.Now()
		//
		//		rdb.Save(&hdLisReportInfo)
		//	}
		//}
	}
}

func SyncLisIndicatorsBc(rdb *gorm.DB, org_id int64, hospital_id string) {
	var sync_time int64
	sync_time = 1704038400

	//同步监测记录
	inspections, _ := service.FindOrgInspectionTwo(org_id, sync_time, time.Now().Unix())
	var lisIndicatorsList []*sz.TempHdLisIndicators
	tempFlag := 0
	for _, inspection := range inspections {
		tempFlag = 0
		LabSno := strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10)
		// 判断该检查是否已经同步过
		hdLisReportInfo, _ := service.FindLisINDICATORSByNo(rdb, LabSno, strconv.FormatInt(inspection.ID, 10))
		if len(hdLisReportInfo) > 0 {
			tempFlag = 0
		} else {
			tempFlag = 1
		}
		if tempFlag == 1 {
			lisIndicators := &sz.TempHdLisIndicators{
				InspectedResultNo:    strconv.FormatInt(inspection.ID, 10),
				HospitalId:           hospital_id,
				LabSno:               strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10),
				ReportDate:           time.Unix(inspection.InspectDate, 0),
				CheckDate:            time.Unix(inspection.InspectDate, 0),
				InspectedIndicate:    inspection.ProjectName,
				InspectedItemEnName:  strconv.FormatInt(inspection.ItemId, 10),
				InspectedItemCnName:  inspection.ItemName,
				InspectedResultDesc:  inspection.InspectValue,
				InspectedResultValue: inspection.InspectValue,
				InspectedResultUnit:  inspection.XtInspectionReference.Unit,
				RefRange:             "-",
				UnitType:             inspection.XtInspectionReference.Unit,
				InspectedResult:      5,
				CreateTime:           time.Unix(inspection.CreatedTime, 0),
				Sjscsj:               time.Now(),
				Xgbz:                 0,
			}
			if len(inspection.XtInspectionReference.Unit) == 0 {
				lisIndicators.InspectedResultUnit = "-"
				lisIndicators.UnitType = "-"
			}

			temp1, _ := strconv.ParseFloat(inspection.InspectValue, 32)

			if inspection.ItemId == 101380701 && inspection.OrgId == 10138 {
				lisIndicators.InspectedResultValue = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
				lisIndicators.InspectedResultDesc = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
				lisIndicators.InspectedResultUnit = "pg/mL"
			}

			if inspection.ItemId == 101380601 && inspection.OrgId == 10278 {
				lisIndicators.InspectedResultValue = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
				lisIndicators.InspectedResultDesc = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
				lisIndicators.InspectedResultUnit = "pg/mL"
			}

			if inspection.XtInspectionReference.RangeType == 1 {
				lisIndicators.RefRange = inspection.XtInspectionReference.RangeMin + "-" + inspection.XtInspectionReference.RangeMax
			} else {
				if len(inspection.XtInspectionReference.RangeOptions) == 0 {
					lisIndicators.RefRange = "-"
				} else {
					lisIndicators.RefRange = inspection.XtInspectionReference.RangeOptions
				}
			}
			lisIndicatorsList = append(lisIndicatorsList, lisIndicators)
		}
	}

	if len(lisIndicatorsList) > 0 {
		err := service.CreateLisIndicators(lisIndicatorsList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       62,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 血透患者检验结果指标表（T_HD_LIS_INDICATORS）
func SyncLisIndicators(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 62)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1672502400
	}

	//同步监测记录
	inspections, _ := service.FindOrgInspectionTwo(org_id, sync_time, time.Now().Unix())
	var lisIndicatorsList []*sz.TempHdLisIndicators

	for _, inspection := range inspections {
		lisIndicators := &sz.TempHdLisIndicators{
			InspectedResultNo:    strconv.FormatInt(inspection.ID, 10),
			HospitalId:           hospital_id,
			LabSno:               strconv.FormatInt(inspection.InspectDate, 10) + strconv.FormatInt(inspection.ProjectId, 10) + strconv.FormatInt(inspection.PatientId, 10),
			ReportDate:           time.Unix(inspection.InspectDate, 0),
			CheckDate:            time.Unix(inspection.InspectDate, 0),
			InspectedIndicate:    inspection.ProjectName,
			InspectedItemEnName:  strconv.FormatInt(inspection.ItemId, 10),
			InspectedItemCnName:  inspection.ItemName,
			InspectedResultDesc:  inspection.InspectValue,
			InspectedResultValue: inspection.InspectValue,
			InspectedResultUnit:  inspection.XtInspectionReference.Unit,
			RefRange:             "-",
			UnitType:             inspection.XtInspectionReference.Unit,
			InspectedResult:      5,
			CreateTime:           time.Unix(inspection.CreatedTime, 0),
			Sjscsj:               time.Now(),
			Xgbz:                 0,
		}
		if len(inspection.XtInspectionReference.Unit) == 0 {
			lisIndicators.InspectedResultUnit = "-"
			lisIndicators.UnitType = "-"
		}

		temp1, _ := strconv.ParseFloat(inspection.InspectValue, 32)

		if inspection.ItemId == 101380701 && inspection.OrgId == 10138 {
			lisIndicators.InspectedResultValue = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
			lisIndicators.InspectedResultDesc = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
			lisIndicators.InspectedResultUnit = "pg/mL"
		}

		if inspection.ItemId == 101380601 && inspection.OrgId == 10278 {
			lisIndicators.InspectedResultValue = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
			lisIndicators.InspectedResultDesc = strconv.FormatFloat(temp1*9.43, 'f', 1, 32)
			lisIndicators.InspectedResultUnit = "pg/mL"
		}

		if inspection.XtInspectionReference.RangeType == 1 {
			lisIndicators.RefRange = inspection.XtInspectionReference.RangeMin + "-" + inspection.XtInspectionReference.RangeMax
		} else {
			if len(inspection.XtInspectionReference.RangeOptions) == 0 {
				lisIndicators.RefRange = "-"
			} else {
				lisIndicators.RefRange = inspection.XtInspectionReference.RangeOptions
			}
		}
		lisIndicatorsList = append(lisIndicatorsList, lisIndicators)
	}

	if len(lisIndicatorsList) > 0 {
		err := service.CreateLisIndicators(lisIndicatorsList, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       62,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 同步透析机透析液细菌培养检测记录表（T_HD_DM_DIALYSATE_BC）
func SyncLisCulture(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 63)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步细菌培养数据
	dialysate, _ := service.FindOrgCulture(org_id, sync_time, time.Now().Unix())

	var lisHdLisCulture []*sz.TempHdLisCulture
	for _, item := range dialysate {
		lisDialysate := &sz.TempHdLisCulture{
			Sn:                      strconv.FormatInt(item.ID, 10),
			HospitalId:              hospital_id,
			EquitmentId:             strconv.FormatInt(item.EquitmentId, 10),
			InspectionTime:          time.Unix(item.SpelingDate, 0),
			IsQualified:             strconv.FormatInt(item.Modifications, 10),
			InspectedValue:          item.DetectionResult + "CFU/mL",
			IsSubstitutionQualified: strconv.FormatInt(item.Modifications, 10),
			CaseOrder:               item.Sort,
			CreateTime:              time.Unix(item.Ctime, 0),
			Sjscsj:                  time.Now(),
			Xgbz:                    "0",
		}
		lisHdLisCulture = append(lisHdLisCulture, lisDialysate)
	}

	if len(lisHdLisCulture) > 0 {
		err := service.CreateLisCulture(lisHdLisCulture, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       63,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 透析机透析液内毒素检测记录表（T_HD_DM_DIALYSATE_EN）
func SyncDialysate(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 64)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//同步透析机透析液内毒素检测记录表
	dialysate, _ := service.FindOrgDialysate(org_id, sync_time, time.Now().Unix())
	var lisHdLisDialysate []*sz.TempHdLisDialysate
	for _, item := range dialysate {
		lisDialysate := &sz.TempHdLisDialysate{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			EquitmentId:    strconv.FormatInt(item.EquitmentId, 10),
			InspectionTime: time.Unix(item.SamplingDate, 0),
			IsQualified:    strconv.FormatInt(item.Modifications, 10),
			InspectedValue: item.DetectionResultb + "EU/mL",
			CaseOrder:      item.Sort,
			CreateTime:     time.Unix(item.Ctime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}
		lisHdLisDialysate = append(lisHdLisDialysate, lisDialysate)
	}
	if len(lisHdLisDialysate) > 0 {
		err := service.CreateLisDialysate(lisHdLisDialysate, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       64,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncLisBodyDetection(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 65)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//同步物表消毒记录表
	detection, _ := service.FindOrgBodyDetection(org_id, sync_time, time.Now().Unix())

	var lisHdLisBodyDisinfect []*sz.TempHdLisBodyDisinfect
	for _, item := range detection {
		disinfect := &sz.TempHdLisBodyDisinfect{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			IsQualified:    strconv.FormatInt(item.CheckOut, 10),
			InspectedValue: item.DetectionResult,
			InspectionTime: time.Unix(item.CreatedTime, 0),
			CaseOrder:      item.Sort,
			CreateTime:     time.Unix(item.Ctime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           "0",
		}
		lisHdLisBodyDisinfect = append(lisHdLisBodyDisinfect, disinfect)
	}
	if len(lisHdLisBodyDisinfect) > 0 {
		err := service.CreateBodyDisinfect(lisHdLisBodyDisinfect, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       65,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncLisWaterFc(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 66)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水游离氯检测表
	waterfc, _ := service.FindOrgWaterFc(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterFc []*sz.TempHdLisWaterFc
	for _, item := range waterfc {
		disinfect := &sz.TempHdLisWaterFc{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		switch item.Specimenb {
		case 1:
			disinfect.WaterType = "3"
			break
		case 2:
			disinfect.WaterType = "2"
			break
		case 3:
			disinfect.WaterType = "2"
			break
		case 4:
			disinfect.WaterType = "1"
			break
		case 5:
			disinfect.WaterType = "1"
			break
		}

		lisHdLisWaterFc = append(lisHdLisWaterFc, disinfect)
	}
	if len(lisHdLisWaterFc) > 0 {
		err := service.CreateWaterFc(lisHdLisWaterFc, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       66,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 透析用水电解质检测表（T_HD_WATER_EL）
func SyncLisWaterEl(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2008)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水游离氯检测表
	waterfc, _ := service.FindOrgWaterEl(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterFc []*sz.TempHdLisWaterEl
	for _, item := range waterfc {
		disinfect := &sz.TempHdLisWaterEl{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			WaterType:       "3",
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			InspectedValue:  item.Remakes,
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}

		lisHdLisWaterFc = append(lisHdLisWaterFc, disinfect)
	}
	if len(lisHdLisWaterFc) > 0 {
		err := service.CreateWaterEl(lisHdLisWaterFc, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2008,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 透析用水电解质检测表（T_HD_WATER_EL）
func SyncLisWaterTe(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 2009)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水游离氯检测表
	waterfc, _ := service.FindOrgWaterEl(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterFc []*sz.TempHdLisWaterTe
	for _, item := range waterfc {
		disinfect := &sz.TempHdLisWaterTe{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			WaterType:       "3",
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}

		lisHdLisWaterFc = append(lisHdLisWaterFc, disinfect)
	}
	if len(lisHdLisWaterFc) > 0 {
		err := service.CreateWaterTe(lisHdLisWaterFc, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       2009,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SynLisWaterNc(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 67)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水游离氯检测表
	waternc, _ := service.FindOrgWaterNc(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterNc []*sz.TempHdLisWaterNc
	for _, item := range waternc {
		disinfect := &sz.TempHdLisWaterNc{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            "0",
		}
		switch item.Specimenb {
		case 1:
			disinfect.WaterType = "3"
			break
		case 2:
			disinfect.WaterType = "2"
			break
		case 3:
			disinfect.WaterType = "2"
			break
		case 4:
			disinfect.WaterType = "1"
			break
		case 5:
			disinfect.WaterType = "1"
			break
		}
		lisHdLisWaterNc = append(lisHdLisWaterNc, disinfect)
	}
	if len(lisHdLisWaterNc) > 0 {
		err := service.CreateWaterNc(lisHdLisWaterNc, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       67,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SynLisWaterPh(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 68)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水PH值检测表
	waternc, _ := service.FindOrgWaterPh(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterPh []*sz.TempHdLisWaterPh
	for _, item := range waternc {
		disinfect := &sz.TempHdLisWaterPh{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            "0",
		}
		switch item.Specimenb {
		case 1:
			disinfect.WaterType = "3"
			break
		case 2:
			disinfect.WaterType = "2"
			break
		case 3:
			disinfect.WaterType = "2"
			break
		case 4:
			disinfect.WaterType = "1"
			break
		case 5:
			disinfect.WaterType = "1"
			break
		}
		lisHdLisWaterPh = append(lisHdLisWaterPh, disinfect)
	}
	if len(lisHdLisWaterPh) > 0 {
		err := service.CreateWaterPh(lisHdLisWaterPh, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       68,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SynListHadWater(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 69)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//透析用水PH值检测表
	waterwh, _ := service.FindOrgWaterWh(org_id, sync_time, time.Now().Unix())
	var lisHdLisWaterWh []*sz.TempHdLisWaterWh
	for _, item := range waterwh {
		disinfect := &sz.TempHdLisWaterWh{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.PassExamination, 10),
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       item.Sort,
			CreateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            "0",
		}
		switch item.Specimenb {
		case 1:
			disinfect.WaterType = "3"
			break
		case 2:
			disinfect.WaterType = "2"
			break
		case 3:
			disinfect.WaterType = "2"
			break
		case 4:
			disinfect.WaterType = "1"
			break
		case 5:
			disinfect.WaterType = "1"
			break
		}
		lisHdLisWaterWh = append(lisHdLisWaterWh, disinfect)
	}
	if len(lisHdLisWaterWh) > 0 {
		err := service.CreateWaterWh(lisHdLisWaterWh, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       69,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

func SynListHdCi(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 70)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//导管感染记录表
	hdci, _ := service.FindOrgHdCi(org_id, sync_time, time.Now().Unix())
	var temphdci []*sz.TempHdCi
	for _, item := range hdci {

		ci := &sz.TempHdCi{
			InfectSn:      strconv.FormatInt(item.ID, 10),
			HospitalId:    hospital_id,
			PatientNk:     strconv.FormatInt(item.PatientId, 10),
			AccessId:      strconv.FormatInt(item.ID, 10),
			CiType:        strconv.FormatInt(item.SequelaeType, 10),
			BloodCulture:  strconv.FormatInt(item.BloodCultupe, 10),
			InfectionDate: time.Unix(item.StartTime, 0),
			CreateTime:    time.Unix(item.Ctime, 0),
			Xgbz:          0,
			Sjscsj:        time.Now(),
		}

		temphdci = append(temphdci, ci)
	}
	if len(temphdci) > 0 {
		err := service.CreateHdCi(temphdci, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       70,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

func SynLisHdCiOutCome(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 71)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//导管感染记录表
	hdcioutcome, _ := service.FindOrgHdCiOutCome(org_id, sync_time, time.Now().Unix())
	var temphdcioutcome []*sz.TempHdCiOutCome
	for _, item := range hdcioutcome {

		outcome := &sz.TempHdCiOutCome{
			Sn:         strconv.FormatInt(item.ID, 10),
			HospitalId: hospital_id,
			InfectSn:   strconv.FormatInt(item.ID, 10),
			PatientNk:  strconv.FormatInt(item.PatientId, 10),

			SequelaeType: strconv.FormatInt(item.CiType, 10),
			Sjscsj:       time.Now(),
			Xgbz:         0,

			CreateTime: time.Unix(item.Ctime, 0),
			UpdateTime: time.Unix(item.Mtime, 0),
			Ylyl1:      "",
			Ylyl2:      "",
		}
		if outcome.SequelaeType == "0" {
			outcome.SequelaeType = "9"
		}

		temphdcioutcome = append(temphdcioutcome, outcome)
	}
	if len(temphdcioutcome) > 0 {
		err := service.CreateHdCiOutCome(temphdcioutcome, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       71,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

func SyncLisAirDetection(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 72)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//同步透析室空气消毒记录表
	detection, _ := service.FindOrgArialDetection(org_id, sync_time, time.Now().Unix())
	var lisHdLisAirDisinfect []*sz.TempHdLisAirDisinfect
	for _, item := range detection {
		disinfect := &sz.TempHdLisAirDisinfect{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			IsQualified:    strconv.FormatInt(item.CheckOut, 10),
			InspectedValue: item.DetectionResult,
			InspectionTime: time.Unix(item.CreatedTime, 0),
			CaseOrder:      item.Sort,
			CreateTime:     time.Unix(item.Ctime, 0),
			Sjscsj:         time.Now(),
			Xgbz:           "0",
		}
		lisHdLisAirDisinfect = append(lisHdLisAirDisinfect, disinfect)
	}
	if len(lisHdLisAirDisinfect) > 0 {
		err := service.CreateAirDisinfect(lisHdLisAirDisinfect, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       72,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

func SyncLisWaterBc(rdb *gorm.DB, org_id int64, hospital_id string) {

	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 73)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//同步细菌培养数据
	dialysate, _ := service.FindOrgCulture(org_id, sync_time, time.Now().Unix())

	var lisHdLisWaterBc []*sz.TempHdLisWaterBc
	for _, item := range dialysate {
		waterbc := &sz.TempHdLisWaterBc{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SpelingDate, 0),
			IsQualified:     strconv.FormatInt(item.Modifications, 10),
			InspectedValue:  item.DetectionResult,
			CaseOrder:       item.Sort,
			Sjscsj:          time.Now(),
			Xgbz:            "0",
			CreateTime:      time.Unix(item.Ctime, 0),
		}
		switch item.Specimen {
		case 1:
			waterbc.WaterType = "3"
			break
		case 2:
			waterbc.WaterType = "2"
			break
		case 3:
			waterbc.WaterType = "2"
			break
		case 4:
			waterbc.WaterType = "1"
			break
		case 5:
			waterbc.WaterType = "1"
			break
		}

		lisHdLisWaterBc = append(lisHdLisWaterBc, waterbc)
	}
	if len(lisHdLisWaterBc) > 0 {
		err := service.CreateLisWaterBc(lisHdLisWaterBc, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       73,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理
		}
	}
}

func SyncLisWaterEn(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 74)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}
	//同步细菌培养数据
	dialysate, _ := service.FindOrgDialysate(org_id, sync_time, time.Now().Unix())
	fmt.Println("dia", dialysate)
	var lisHdLisWaterEn []*sz.TempHdLisWaterEn
	for _, item := range dialysate {
		wateren := &sz.TempHdLisWaterEn{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			EquitmentId:     strconv.FormatInt(item.EquitmentId, 10),
			InspectionOrgId: "1",
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     strconv.FormatInt(item.Modifications, 10),
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       item.Sort,
			Sjscsj:          time.Now(),
			Xgbz:            0,
			CreateTime:      time.Unix(item.Ctime, 0),
		}

		switch item.Specimenb {
		case 1:
			wateren.WaterType = "3"
			break
		case 2:
			wateren.WaterType = "2"
			break
		case 3:
			wateren.WaterType = "2"
			break
		case 4:
			wateren.WaterType = "1"
			break
		case 5:
			wateren.WaterType = "1"
			break
		}

		lisHdLisWaterEn = append(lisHdLisWaterEn, wateren)
	}
	if len(lisHdLisWaterEn) > 0 {
		err := service.CreateLisWaterEn(lisHdLisWaterEn, rdb)
		if err == nil {
			// 第三步：同步成功后，添加同步记录
			upload := &sz.DataUpload{
				SyncType:       74,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			err := service.CreateUploadRecord(upload)
			if err != nil {
				utils.ErrorLog("%v", err)
			}
		} else {
			//错误处理

		}
	}
}

// 机构人员字典表
func SyncTBDICPractitioner(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1001)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	roles, _ := service.FindOrgRolesData(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, role := range roles {
		var zwdm, zhiw, zcdm, zhic, lb string
		switch role.UserType {
		case 2:
			zwdm = "234"
			zhiw = "医师"
			zcdm = "420"
			zhic = "中级"
			lb = "11"
			break
		case 3:
			zwdm = "255"
			zhiw = "护士"
			zcdm = "420"
			zhic = "中级"
			lb = "21"
			break
		}

		staff := &sz.TBDICPractitioner{
			GH:       strconv.FormatInt(role.AdminUserId, 10),
			YLJGDM:   hospital_id,
			ZCM:      role.UserName,
			XM:       role.UserName,
			XBBM:     "2",
			SSKS:     "1001",
			SZYWKSMC: "血透中心",
			ZWDM:     zwdm,
			ZHIW:     zhiw,
			ZCDM:     zcdm,
			ZHIC:     zhic,
			NNRYLDQK: "9",
			BZQK:     "2",
			LB:       lb,
			YWSCSJ:   time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTBDICPractitioner(staff, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1001,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 机构人员字典表
func SyncTBDICPractitioner_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1001)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	roles, _ := service.FindOrgRolesData(9504, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, role := range roles {
		var zwdm, zhiw, zcdm, zhic, lb string
		switch role.UserType {
		case 2:
			zwdm = "234"
			zhiw = "医师"
			zcdm = "420"
			zhic = "中级"
			lb = "11"
			break
		case 3:
			zwdm = "255"
			zhiw = "护士"
			zcdm = "420"
			zhic = "中级"
			lb = "21"
			break
		}

		staff := &sz.TBDICPractitioner{
			GH:       strconv.FormatInt(role.AdminUserId, 10),
			YLJGDM:   hospital_id,
			ZCM:      role.UserName,
			XM:       role.UserName,
			XBBM:     "2",
			SSKS:     "1001",
			SZYWKSMC: "血透中心",
			ZWDM:     zwdm,
			ZHIW:     zhiw,
			ZCDM:     zcdm,
			ZHIC:     zhic,
			NNRYLDQK: "9",
			BZQK:     "2",
			LB:       lb,
			YWSCSJ:   time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTBDICPractitioner(staff, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1001,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 药品目录字典表
func SyncTBDICMedicines(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1081)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	drugs, _ := service.FindDrugList(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, drug := range drugs {
		medicines := &sz.TBDICMedicines{
			YLJGDM: hospital_id,
			YYZBDM: strconv.FormatInt(drug.ID, 10),
			YPMC:   drug.DrugName,
			TYMC:   drug.DrugName,
			YPGG:   drug.DrugSpec,
			YNJXDA: "1",
			YNJXMC: drug.DrugName,
			SYBZ:   strconv.FormatInt(drug.Status, 10),
			TSBZ:   "0",
			KSSBZ:  "0",
			YPPZWH: drug.Number,
			YPLX:   "1",
			YNZJBZ: "0",
			GJYBZ:  "0",
			SJYBZ:  "0",
			SHJYBZ: "0",
			QJYBZ:  "0",
			YWSCSJ: time.Now(),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTBDICMedicines(medicines, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1081,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}
func SyncTBDICMedicines_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1081)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	drugs, _ := service.FindDrugList(9504, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, drug := range drugs {
		medicines := &sz.TBDICMedicines{
			YLJGDM: hospital_id,
			YYZBDM: strconv.FormatInt(drug.ID, 10),
			YPMC:   drug.DrugName,
			TYMC:   drug.DrugName,
			YPGG:   drug.DrugSpec,
			YNJXDA: "1",
			YNJXMC: drug.DrugName,
			SYBZ:   strconv.FormatInt(drug.Status, 10),
			TSBZ:   "0",
			KSSBZ:  "0",
			YPPZWH: drug.Number,
			YPLX:   "1",
			YNZJBZ: "0",
			GJYBZ:  "0",
			SJYBZ:  "0",
			SHJYBZ: "0",
			QJYBZ:  "0",
			YWSCSJ: time.Now(),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTBDICMedicines(medicines, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1081,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 药品目录字典表
func SyncTBDICYpdzzd(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1083)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	drugs, _ := service.FindDrugList(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, drug := range drugs {
		ypdzzd := &sz.TBDICYpdzzd{
			YLJGDM:     hospital_id,
			YNYPDM:     strconv.FormatInt(drug.ID, 10),
			YPMC:       drug.DrugName,
			YPLX:       "1",
			YPSPWYBSDM: drug.MedicalInsuranceNumber,
			YPSPWYBSMC: drug.DrugName,
			SJSHCSJ:    time.Now(),
			SJSCSJ:     time.Now(),
			XGBZ:       0,
		}
		service.BatchCreateTBDICYpdzzd(ypdzzd, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1083,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTBDICYpdzzd_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1083)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	drugs, _ := service.FindDrugList(9504, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, drug := range drugs {
		ypdzzd := &sz.TBDICYpdzzd{
			YLJGDM:     hospital_id,
			YNYPDM:     strconv.FormatInt(drug.ID, 10),
			YPMC:       drug.DrugName,
			YPLX:       "1",
			YPSPWYBSDM: drug.MedicalInsuranceNumber,
			YPSPWYBSMC: drug.DrugName,
			SJSHCSJ:    time.Now(),
			SJSCSJ:     time.Now(),
			XGBZ:       0,
		}
		service.BatchCreateTBDICYpdzzd(ypdzzd, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1083,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 诊疗项目目录字典表
func SyncTBDICZlxmml(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1082)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	projects, _ := service.FindProjectList(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, project := range projects {
		zlxmml := &sz.TBDICZlxmml{
			YLJGDM: hospital_id,
			YYZBDM: strconv.FormatInt(project.ID, 10),
			XMMC:   project.ProjectName,
			SFDW:   "元",
			SFDJ:   strconv.FormatFloat(project.Price, 'f', 1, 32),
			SYBZ:   strconv.FormatInt(project.Status, 10),
			YWSCSJ: time.Now(),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTBDICZlxmml(zlxmml, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1082,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTBDICZlxmml_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1082)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	projects, _ := service.FindProjectList(9504, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, project := range projects {
		zlxmml := &sz.TBDICZlxmml{
			YLJGDM: hospital_id,
			YYZBDM: strconv.FormatInt(project.ID, 10),
			XMMC:   project.ProjectName,
			SFDW:   "元",
			SFDJ:   strconv.FormatFloat(project.Price, 'f', 1, 32),
			SYBZ:   strconv.FormatInt(project.Status, 10),
			YWSCSJ: time.Now(),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTBDICZlxmml(zlxmml, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1082,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 诊疗项目目录字典表
func SyncTBDICZlxmdzzd(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1086)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	projects, _ := service.FindProjectList(org_id, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, project := range projects {
		zlxmdzzd := &sz.TBDICZlxmdzzd{
			YLJGDM:   hospital_id,
			YNZLXMDM: strconv.FormatInt(project.ID, 10),
			YNZLXMMC: project.ProjectName,
			WJSFDM:   project.MedicalCode,
			WJSFMC:   project.ProjectName,
			SJSHCSJ:  time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTBDICZlxmdzzd(zlxmdzzd, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1086,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}
func SyncTBDICZlxmdzzd_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1086)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	projects, _ := service.FindProjectList(9504, sync_time, time.Now().Unix())

	//waterMachine, _ := service.FindOrgWaterMachineData(org_id, sync_time, time.Now().Unix())
	// var staffs []*sz.TBDICPractitioner
	for _, project := range projects {
		zlxmdzzd := &sz.TBDICZlxmdzzd{
			YLJGDM:   hospital_id,
			YNZLXMDM: strconv.FormatInt(project.ID, 10),
			YNZLXMMC: project.ProjectName,
			WJSFDM:   project.MedicalCode,
			WJSFMC:   project.ProjectName,
			SJSHCSJ:  time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTBDICZlxmdzzd(zlxmdzzd, rdb)
	}

	// 第三步：同步成功后，添加同步记录
	upload := &sz.DataUpload{
		SyncType:       1086,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTMDICTBED(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1002)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步透析床位分区
	dm, _ := service.FindOrgDeviceNumber(org_id, sync_time, time.Now().Unix())
	// var hdms []*sz.TM_DICT_BED
	for _, item := range dm {
		hdm := &sz.TM_DICT_BED{
			YLJGDM:   hospital_id,
			CWBM:     strconv.FormatInt(item.ID, 10),
			CH:       item.Number,
			SSKSDM:   "1001",
			SSKSMC:   "血透中心",
			CWLX:     "1",
			CWZT:     "0",
			DYZLXMDJ: "0",
			ZYH:      "",
			YWSCSJ:   time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTMDICTBED(hdm, rdb)

	}
	upload := &sz.DataUpload{
		SyncType:       1002,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTMDICTBED_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1002)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步透析床位分区
	dm, _ := service.FindOrgDeviceNumber(9504, sync_time, time.Now().Unix())
	// var hdms []*sz.TM_DICT_BED
	for _, item := range dm {
		hdm := &sz.TM_DICT_BED{
			YLJGDM:   hospital_id,
			CWBM:     strconv.FormatInt(item.ID, 10),
			CH:       item.Number,
			SSKSDM:   "1001",
			SSKSMC:   "血透中心",
			CWLX:     "1",
			CWZT:     "0",
			DYZLXMDJ: "0",
			ZYH:      "",
			YWSCSJ:   time.Now(),
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTMDICTBED(hdm, rdb)

	}
	upload := &sz.DataUpload{
		SyncType:       1002,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 14.	门诊患者信息表
func SyncTBMZPatientInformation(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1003)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	patients, _ := service.FindOrgPatientData(org_id, sync_time, time.Now().Unix())

	for _, patient := range patients {
		var xbmc string
		if patient.Gender == 1 {
			xbmc = "男"
		} else {
			xbmc = "女"
		}

		tm := time.Unix(patient.Birthday, 0)
		ghrq := tm.Format("20060102")

		p := &sz.TB_MZ_Patient_Information{
			KH:     patient.DialysisNo,
			KLX:    "3",
			YLJGDM: hospital_id,
			FKDQ:   "440300",
			ZJHM:   patient.IdCardNo,
			ZJLXDM: "01",
			ZJLXMC: "身份证",
			XM:     patient.Name,
			CSRQ:   ghrq,
			MZDM:   "1",
			MZMC:   "汉族",
			GJDM:   "156",
			GJMC:   "中国",
			SJHM:   patient.Phone,
			XBDM:   strconv.FormatInt(patient.Gender, 10),
			XBMC:   xbmc,
			HZLXDM: "1",
			HZLXMC: "本市",
			YWSCSJ: time.Unix(patient.CreatedTime, 0),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTB_MZ_Patient_Information(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1003,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTBMZPatientInformation_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1003)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 0
	}

	//同步员工信息
	patients, _ := service.FindOrgPatientData(9504, sync_time, time.Now().Unix())

	for _, patient := range patients {
		var xbmc string
		if patient.Gender == 1 {
			xbmc = "男"
		} else {
			xbmc = "女"
		}

		tm := time.Unix(patient.Birthday, 0)
		ghrq := tm.Format("20060102")

		p := &sz.TB_MZ_Patient_Information{
			KH:     patient.DialysisNo,
			KLX:    "3",
			YLJGDM: hospital_id,
			FKDQ:   "440300",
			ZJHM:   patient.IdCardNo,
			ZJLXDM: "01",
			ZJLXMC: "身份证",
			XM:     patient.Name,
			CSRQ:   ghrq,
			MZDM:   "1",
			MZMC:   "汉族",
			GJDM:   "156",
			GJMC:   "中国",
			SJHM:   patient.Phone,
			XBDM:   strconv.FormatInt(patient.Gender, 10),
			XBMC:   xbmc,
			HZLXDM: "1",
			HZLXMC: "本市",
			YWSCSJ: time.Unix(patient.CreatedTime, 0),
			SJSCSJ: time.Now(),
			XGBZ:   0,
		}
		service.BatchCreateTB_MZ_Patient_Information(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1003,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 15.	挂号表
func SyncTBHISMZReg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1004)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(org_id, sync_time, time.Now().Unix())

	for _, patient := range patients {
		tm := time.Unix(patient.Ctime, 0)
		ghrq := tm.Format("20060102")
		gthsj := tm.Format("2006-01-02 15:04:05")
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		p := &sz.TB_HIS_MZ_Reg{
			GHRQ:     ghrq,
			JZLSH:    strconv.FormatInt(patient.ID, 10),
			GTHBZ:    "1",
			YLJGDM:   hospital_id,
			STFBH:    strconv.FormatInt(patient.ID, 10),
			GTHSJ:    gthsj,
			GHHX:     strconv.FormatInt(patient.ID, 10),
			GHLB:     "04",
			GHMC:     "专科门诊",
			YLFYLYDM: "01",
			YLBXLBDM: "01",
			YBZHBZ:   "0000000000000000",
			SSJYBZ:   "1",
			KSBM:     "1001",
			KSMC:     "血透中心",
			YSBM:     "2232",
			YSXM:     "张犇",
			TXBZ:     "0",
			WDBZ:     "1",
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			SFYY:     "0",
			GHRCBS:   "0",
			GHFY:     patient.RegisterCost,
			JMGHF:    patient.RegisterCost,
			ZJF:      patient.TreatmentCost,
			JMZJF:    patient.TreatmentCost,
			QTF:      "0",
			CZYBM:    "1001",
			CZYXM:    "Phony",
			GHFXM:    "003110000060000-311000006",
			ZJFXM:    "003110000060000-311000006",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTB_HIS_MZ_Reg(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1004,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTBHISMZReg_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1004)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(9504, sync_time, time.Now().Unix())

	for _, patient := range patients {
		tm := time.Unix(patient.Ctime, 0)
		ghrq := tm.Format("20060102")
		gthsj := tm.Format("2006-01-02 15:04:05")
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		p := &sz.TB_HIS_MZ_Reg{
			GHRQ:     ghrq,
			JZLSH:    strconv.FormatInt(patient.ID, 10),
			GTHBZ:    "1",
			YLJGDM:   hospital_id,
			STFBH:    strconv.FormatInt(patient.ID, 10),
			GTHSJ:    gthsj,
			GHHX:     strconv.FormatInt(patient.ID, 10),
			GHLB:     "04",
			GHMC:     "专科门诊",
			YLFYLYDM: "01",
			YLBXLBDM: "01",
			YBZHBZ:   "0000000000000000",
			SSJYBZ:   "1",
			KSBM:     "1001",
			KSMC:     "血透中心",
			YSBM:     "2232",
			YSXM:     "张犇",
			TXBZ:     "0",
			WDBZ:     "1",
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			SFYY:     "0",
			GHRCBS:   "0",
			GHFXM:    "003110000060000-311000006",
			ZJFXM:    "003110000060000-311000006",
			GHFY:     patient.RegisterCost,
			JMGHF:    patient.RegisterCost,
			ZJF:      patient.TreatmentCost,
			JMZJF:    patient.TreatmentCost,
			QTF:      "0",
			CZYBM:    "1001",
			CZYXM:    "Phony",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTB_HIS_MZ_Reg(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1004,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTB_STAT_YWL_Report(rdb *gorm.DB, org_id int64, hospital_id string) {
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1068)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	syncDate := time.Unix(sync_time, 0).Format("20060102")
	tempDate := time.Now().Format("20060102")
	sync_time_date := time.Unix(sync_time, 0).Format("2006-01-02")
	loc, _ := time.LoadLocation("Local")
	timeLayout := "2006-01-02"

	sync_times, _ := time.ParseInLocation(timeLayout+" 15:04:05", sync_time_date+" 00:00:00", loc)
	sync_time_dd := sync_times.Unix()

	for {
		if syncDate < tempDate {
			// 获取门诊人数
			patientCnt, _ := service.FindOrgHisPatientCnt(org_id, sync_time_dd)
			// 门急诊药品费用
			amtOne, _ := service.FindOrgHisPatientCntTwo(org_id, sync_time_dd)
			fmt.Println(amtOne)
			// 门急诊医疗费用
			amtTwo, _ := service.FindOrgHisPatientCntTwo(org_id, sync_time_dd)

			p := &sz.TB_STAT_YWL_Report{
				YLJGDM:    hospital_id,
				KSBM:      "1001",
				YWSJ:      syncDate,
				MZRC:      patientCnt,
				JZRC:      0,
				TJRC:      0,
				RYRC:      0,
				CYRC:      0,
				CGRC:      0,
				RGBLS:     0,
				ZYRS:      0,
				SYCWS:     37,
				BZCWS:     37,
				SJSYCWS:   37,
				KCS:       0,
				KFTSCS:    0,
				JTBCS:     0,
				SSLS:      0,
				MJZYLFY:   amtOne.Sumamt,
				ZYYLFY:    0,
				MJZYPFY:   amtTwo.Sumamt,
				ZYYPFY:    0,
				MJZYBYLFY: amtOne.Amt,
				ZYYBYLFY:  0,
				MJZYBYPFY: amtTwo.Amt,
				ZYYBYPFY:  0,
				ZYSJFSYS:  0,
				CYYLSR:    0,
				CYYPSR:    0,
				CYYBYLSR:  0,
				CYYBYPSR:  0,
				SJSCSJ:    time.Now(),
				XGBZ:      0,
			}
			service.BatchCreateTB_STAT_YWL_Report(p, rdb)

			sync_time = sync_time + 86400
			syncDate = time.Unix(sync_time, 0).Format("20060102")
		} else {
			upload := &sz.DataUpload{
				SyncType:       1068,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			service.CreateUploadRecord(upload)
			break
		}
	}
}

func SyncTB_STAT_YWL_Report_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1068)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	syncDate := time.Unix(sync_time, 0).Format("20060102")
	tempDate := time.Now().Format("20060102")
	sync_time_date := time.Unix(sync_time, 0).Format("2006-01-02")
	loc, _ := time.LoadLocation("Local")
	timeLayout := "2006-01-02"

	sync_times, _ := time.ParseInLocation(timeLayout+" 15:04:05", sync_time_date+" 00:00:00", loc)
	sync_time_dd := sync_times.Unix()

	for {
		if syncDate < tempDate {
			// 获取门诊人数
			patientCnt, _ := service.FindOrgHisPatientCnt(9504, sync_time_dd)
			// 门急诊药品费用
			amtOne, _ := service.FindOrgHisPatientCntTwo(9504, sync_time_dd)
			fmt.Println(amtOne)
			// 门急诊医疗费用
			amtTwo, _ := service.FindOrgHisPatientCntTwo(9504, sync_time_dd)

			p := &sz.TB_STAT_YWL_Report{
				YLJGDM:    hospital_id,
				KSBM:      "1001",
				YWSJ:      syncDate,
				MZRC:      patientCnt,
				JZRC:      0,
				TJRC:      0,
				RYRC:      0,
				CYRC:      0,
				CGRC:      0,
				RGBLS:     0,
				ZYRS:      0,
				SYCWS:     37,
				BZCWS:     37,
				SJSYCWS:   37,
				KCS:       0,
				KFTSCS:    0,
				JTBCS:     0,
				SSLS:      0,
				MJZYLFY:   amtOne.Sumamt,
				ZYYLFY:    0,
				MJZYPFY:   amtTwo.Sumamt,
				ZYYPFY:    0,
				MJZYBYLFY: amtOne.Amt,
				ZYYBYLFY:  0,
				MJZYBYPFY: amtTwo.Amt,
				ZYYBYPFY:  0,
				ZYSJFSYS:  0,
				CYYLSR:    0,
				CYYPSR:    0,
				CYYBYLSR:  0,
				CYYBYPSR:  0,
				SJSCSJ:    time.Now(),
				XGBZ:      0,
			}
			service.BatchCreateTB_STAT_YWL_Report(p, rdb)

			sync_time = sync_time + 86400
			syncDate = time.Unix(sync_time, 0).Format("20060102")
		} else {
			upload := &sz.DataUpload{
				SyncType:       1068,
				OrgId:          org_id,
				SyncTime:       time.Now().Unix(),
				SyncResultType: 1,
				CreateTime:     time.Now().Unix(),
				UpdateTime:     time.Now().Unix(),
			}
			service.CreateUploadRecord(upload)
			break
		}
	}
}

// 14.	诊断明细表
func SyncTB_YL_MZ_Medical_Record(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1005)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(org_id, sync_time, time.Now().Unix())

	for _, patient := range patients {
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.RecordDate, 0)
		ghrq := tm.Format("2006-01-02")
		p := &sz.TB_YL_MZ_Medical_Record{
			YLJGDM:      hospital_id,
			JZLSH:       strconv.FormatInt(patient.ID, 10),
			KH:          patientInfo.DialysisNo,
			KLX:         "3",
			MJZH:        strconv.FormatInt(patient.ID, 10),
			HZXM:        patient.Name,
			JZLX:        "04",
			CZBZ:        "2",
			SFTH:        "0",
			YLBXLBDM:    "01",
			YLFKFSDM:    "01",
			TXBZ:        "0",
			YBZHBZ:      "0000000000000000",
			WDBZ:        "1",
			SFSYZYZLJS:  "0",
			ZYZLJSLB:    "其他",
			SFSYZYZHLJS: "0",
			JZKSBM:      "1001",
			JZKSMC:      "血透中心",
			JZKSRQ:      ghrq,
			ZZYSGH:      "1001",
			ZZYSXM:      "Phony",
			BMLX:        "01",
			JZZDBM:      "N18.500",
			JZZDSM:      "慢性肾脏病5期",
			JZZTDM:      "3",
			JZZTMC:      "结束就诊",
			ZS:          "慢性肾功能不全",
			ZZMS:        "慢性肾脏病5期,需血液透析",
			JZJSSJ:      ghrq,
			YWSCSJ:      time.Now(),
			SJSCSJ:      time.Now(),
			XGBZ:        0,
		}
		service.BatchCreateTB_YL_MZ_Medical_Record(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1005,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 14.	16.	门诊就诊记录表
func SyncTB_Diagnosis_Detail(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1105)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(org_id, sync_time, time.Now().Unix())

	for _, patient := range patients {
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.RecordDate, 0)
		ghrq := tm.Format("2006-01-02")
		p := &sz.TB_Diagnosis_Detail{
			ZYZDLSH: strconv.FormatInt(patient.ID, 10),
			YLJGDM:  hospital_id,
			JZLSH:   strconv.FormatInt(patient.ID, 10),
			MZZYBZ:  "1",
			KH:      patientInfo.DialysisNo,
			KLX:     "3",
			ZDLXQF:  "3",
			ZDLB:    "02",
			ZDSJ:    ghrq,
			ZDBM:    "N18.500",
			BMLX:    "02",
			CYZDBZ:  "1",
			YZDBZ:   "2",
			CRBBZ:   "0",
			RYBQ:    "4",
			JLRQSJ:  time.Now(),
			SJSCSJ:  time.Now(),
			XGBZ:    0,
		}
		service.BatchCreateTB_Diagnosis_Detail(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1105,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTB_Diagnosis_Detail_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1105)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(9504, sync_time, time.Now().Unix())

	for _, patient := range patients {
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.RecordDate, 0)
		ghrq := tm.Format("2006-01-02")
		p := &sz.TB_Diagnosis_Detail{
			ZYZDLSH: strconv.FormatInt(patient.ID, 10),
			YLJGDM:  hospital_id,
			JZLSH:   strconv.FormatInt(patient.ID, 10),
			MZZYBZ:  "1",
			KH:      patientInfo.DialysisNo,
			KLX:     "3",
			ZDLXQF:  "3",
			ZDLB:    "02",
			ZDSJ:    ghrq,
			ZDBM:    "N18.500",
			BMLX:    "02",
			CYZDBZ:  "1",
			YZDBZ:   "2",
			CRBBZ:   "0",
			RYBQ:    "4",
			JLRQSJ:  time.Now(),
			SJSCSJ:  time.Now(),
			XGBZ:    0,
		}
		service.BatchCreateTB_Diagnosis_Detail(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1105,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTB_YL_MZ_Medical_Record_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1005)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPatient(9504, sync_time, time.Now().Unix())

	for _, patient := range patients {
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.RecordDate, 0)
		ghrq := tm.Format("2006-01-02")
		p := &sz.TB_YL_MZ_Medical_Record{
			YLJGDM:      hospital_id,
			JZLSH:       strconv.FormatInt(patient.ID, 10),
			KH:          patientInfo.DialysisNo,
			KLX:         "3",
			MJZH:        strconv.FormatInt(patient.ID, 10),
			HZXM:        patient.Name,
			NLS:         (time.Now().Unix() - patient.Birthday) / 31536000,
			JZLX:        "04",
			CZBZ:        "2",
			SFTH:        "0",
			YLBXLBDM:    "01",
			YLFKFSDM:    "01",
			TXBZ:        "0",
			YBZHBZ:      "0000000000000000",
			WDBZ:        "1",
			SFSYZYZLJS:  "0",
			ZYZLJSLB:    "其他",
			SFSYZYZHLJS: "0",
			JZKSBM:      "1001",
			JZKSMC:      "血透中心",
			JZKSRQ:      ghrq,
			ZZYSGH:      "1001",
			ZZYSXM:      "Phony",
			BMLX:        "01",
			JZZDBM:      "N18.500",
			JZZDSM:      "慢性肾脏病5期",
			JZZTDM:      "3",
			JZZTMC:      "结束就诊",
			ZS:          "慢性肾功能不全",
			ZZMS:        "慢性肾脏病5期,需血液透析",
			JZJSSJ:      ghrq,
			YWSCSJ:      time.Now(),
			SJSCSJ:      time.Now(),
			XGBZ:        0,
		}
		service.BatchCreateTB_YL_MZ_Medical_Record(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1005,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 17.	门诊处方主表
func SyncTB_CIS_Prescription(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1006)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPrescriptionInfo(org_id, sync_time, time.Now().Unix())
	for _, patient := range patients {
		patient_info, _ := service.FindOrgHisPatientInfo(org_id, patient.RecordDate, patient.PatientId)
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		adviceinfo, _ := service.FindOrgHisDoctorAdviceInfoByPid(org_id, patient.ID)
		if patient_info.ID > 0 {
			var cfypje float64
			for _, advice := range adviceinfo {
				cfypje = cfypje + advice.PrescribingNumber*advice.Price
			}
			tm := time.Unix(patient.Ctime, 0)
			ghrq := tm.Format("2006-01-02")
			p := &sz.TB_CIS_Prescription{
				CYH:      strconv.FormatInt(patient.ID, 10),
				YLJGDM:   hospital_id,
				JZLSH:    strconv.FormatInt(patient_info.ID, 10),
				KH:       patientInfo.DialysisNo,
				KLX:      "3",
				CFLX:     "1",
				YPLX:     "3",
				ZYYPCFLB: "9",
				CFJS:     "0",
				JZKSDM:   "1001",
				JZKSMC:   "血透中心",
				KFYS:     "1001",
				KFYSXM:   "Phony",
				KFRQ:     ghrq,
				CFLRSJ:   ghrq,
				SGCFBZ:   "0",
				CFYPJE:   cfypje,
				XYZDDM:   "N18.500",
				XYZDMC:   "慢性肾脏病5期",
				SJSCSJ:   time.Now(),
				XGBZ:     0,
			}
			service.BatchCreateTB_CIS_Prescription(p, rdb)
		}
	}

	upload := &sz.DataUpload{
		SyncType:       1006,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

func SyncTB_CIS_Prescription_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1006)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisPrescriptionInfo(9504, sync_time, time.Now().Unix())
	for _, patient := range patients {
		patient_info, _ := service.FindOrgHisPatientInfo(9504, patient.RecordDate, patient.PatientId)
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		adviceinfo, _ := service.FindOrgHisDoctorAdviceInfoByPid(9504, patient.ID)
		if patient_info.ID > 0 {
			var cfypje float64
			for _, advice := range adviceinfo {
				cfypje = cfypje + advice.PrescribingNumber*advice.Price
			}
			tm := time.Unix(patient.Ctime, 0)
			ghrq := tm.Format("2006-01-02")
			p := &sz.TB_CIS_Prescription{
				CYH:      strconv.FormatInt(patient.ID, 10),
				YLJGDM:   hospital_id,
				JZLSH:    strconv.FormatInt(patient_info.ID, 10),
				KH:       patientInfo.DialysisNo,
				KLX:      "3",
				CFLX:     "1",
				YPLX:     "3",
				ZYYPCFLB: "9",
				CFJS:     "0",
				JZKSDM:   "1001",
				JZKSMC:   "血透中心",
				KFYS:     "1001",
				KFYSXM:   "Phony",
				KFRQ:     ghrq,
				CFLRSJ:   ghrq,
				SGCFBZ:   "0",
				CFYPJE:   cfypje,
				TFBZ:     "2",
				XYZDDM:   "N18.500",
				XYZDMC:   "慢性肾脏病5期",
				SJSCSJ:   time.Now(),
				XGBZ:     0,
			}
			service.BatchCreateTB_CIS_Prescription(p, rdb)
		}
	}

	upload := &sz.DataUpload{
		SyncType:       1006,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 门诊处方明细表
func SyncTB_CIS_Prescription_Detail(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1007)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisDoctorAdviceInfo(org_id, sync_time, time.Now().Unix())
	for _, patient := range patients {
		prescription, _ := service.FindOrgHisPrescriptionById(patient.PrescriptionId)
		prescription_info, _ := service.FindOrgHisPrescriptionInfoByNumber(org_id, prescription.PrescriptionNumber)
		patient_info, _ := service.FindOrgHisPatientInfo(org_id, prescription_info.RecordDate, prescription_info.PatientId)
		basedrug, _ := service.FindBaseDrugLibById(patient.DrugId)
		if patient_info.ID > 0 {
			var yf, ypyf string
			if len(patient.DeliveryWay) == 0 || patient.DeliveryWay == "口服" {
				yf = "1"
				ypyf = "口服"
			} else {
				yf = "4"
				ypyf = "注射用药"
			}

			p := &sz.TB_CIS_Prescription_Detail{
				CYH:       strconv.FormatInt(prescription.ID, 10),
				CFMXH:     prescription.PrescriptionNumber,
				YLJGDM:    hospital_id,
				JZLSH:     strconv.FormatInt(patient_info.ID, 10),
				XMBM:      strconv.FormatInt(patient.DrugId, 10),
				XMBMYB:    patient.MedListCodg,
				XMMC:      patient.AdviceName,
				XMSL:      patient.PrescribingNumber,
				XMDW:      patient.PrescribingNumberUnit,
				XMDJ:      patient.Price,
				XMJE:      patient.Price * patient.PrescribingNumber,
				XMLB:      "01",
				YWFLDM:    "1",
				SFJJ:      "0",
				SFPS:      "0",
				YPGG:      basedrug.DrugSpec,
				SCPH:      basedrug.SocialSecurityDirectoryCode,
				YXQZ:      "2023-09-01",
				SYPCDM:    "QD",
				SYPC:      "每天一次",
				JL:        patient.SingleDose,
				DW:        patient.SingleDoseUnit,
				MCSL:      patient.SingleDose,
				MCDW:      patient.SingleDoseUnit,
				YF:        yf,
				YPYF:      ypyf,
				YYTS:      patient.Day,
				YWSYZJL:   patient.PrescribingNumber,
				YWSYZJLDW: patient.PrescribingNumberUnit,

				SJSCSJ: time.Now(),
				XGBZ:   0,
			}
			service.BatchCreateTB_CIS_Prescription_Detail(p, rdb)
		}
	}

	upload := &sz.DataUpload{
		SyncType:       1007,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}
func SyncTB_CIS_Prescription_Detail_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1007)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisDoctorAdviceInfo(9504, sync_time, time.Now().Unix())
	for _, patient := range patients {
		prescription, _ := service.FindOrgHisPrescriptionById(patient.PrescriptionId)
		prescription_info, _ := service.FindOrgHisPrescriptionInfoByNumber(9504, prescription.PrescriptionNumber)
		patient_info, _ := service.FindOrgHisPatientInfo(9504, prescription_info.RecordDate, prescription_info.PatientId)
		basedrug, _ := service.FindBaseDrugLibById(patient.DrugId)
		if patient_info.ID > 0 {
			var yf, ypyf string
			if len(patient.DeliveryWay) == 0 || patient.DeliveryWay == "口服" {
				yf = "1"
				ypyf = "口服"
			} else {
				yf = "4"
				ypyf = "注射用药"
			}
			if len(patient.MedListCodg) == 0 {
				patient.MedListCodg = "ZZZZZZZZZZZZZZZ"
			}

			p := &sz.TB_CIS_Prescription_Detail{
				CYH:       strconv.FormatInt(prescription.ID, 10),
				CFMXH:     prescription.PrescriptionNumber,
				YLJGDM:    hospital_id,
				JZLSH:     strconv.FormatInt(patient_info.ID, 10),
				XMBM:      strconv.FormatInt(patient.DrugId, 10),
				XMBMYB:    patient.MedListCodg,
				XMMC:      patient.AdviceName,
				XMSL:      patient.PrescribingNumber,
				XMDW:      patient.PrescribingNumberUnit,
				XMDJ:      patient.Price,
				XMJE:      patient.Price * patient.PrescribingNumber,
				XMLB:      "01",
				YWFLDM:    "1",
				SFJJ:      "0",
				SFPS:      "0",
				YPGG:      basedrug.DrugSpec,
				SCPH:      basedrug.SocialSecurityDirectoryCode,
				YXQZ:      "2026-09-01",
				SYPCDM:    "QD",
				SYPC:      "每天一次",
				JL:        patient.SingleDose,
				DW:        patient.SingleDoseUnit,
				MCSL:      patient.SingleDose,
				MCDW:      patient.SingleDoseUnit,
				YF:        yf,
				YPYF:      ypyf,
				YYTS:      patient.Day,
				YWSYZJL:   patient.PrescribingNumber,
				YWSYZJLDW: patient.PrescribingNumberUnit,

				SJSCSJ: time.Now(),
				XGBZ:   0,
			}

			service.BatchCreateTB_CIS_Prescription_Detail(p, rdb)
		}
	}

	upload := &sz.DataUpload{
		SyncType:       1007,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 门诊处方明细表
func SyncTB_HIS_MZ_Charge(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1008)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisOrder(org_id, sync_time, time.Now().Unix())
	for _, patient := range patients {
		orderInfos, _ := service.GetHisOrderInfoByNumber(patient.Number)
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		var bedCostTotal float64 = 0                        //床位总费
		var operationCostTotal float64 = 0                  //手术费
		var otherCostTotal float64 = 0                      //其他费用
		var materialCostTotal float64 = 0                   //材料费
		var westernMedicineCostTotal float64 = 0            //西药费
		var chineseTraditionalMedicineCostTotal float64 = 0 //中成药
		var checkCostTotal float64 = 0                      //检查费
		var laboratoryCostTotal float64 = 0                 //化验费
		var treatCostTotal float64 = 0                      //治疗费用

		decimal.DivisionPrecision = 2

		for _, item := range orderInfos {
			if item.MedChrgitmType == "01" { //床位费
				bedCostTotal, _ = decimal.NewFromFloat(bedCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "03" { //检查费
				checkCostTotal, _ = decimal.NewFromFloat(checkCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "04" { //化验费
				laboratoryCostTotal, _ = decimal.NewFromFloat(laboratoryCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "05" { //治疗费
				treatCostTotal, _ = decimal.NewFromFloat(treatCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "06" { //手术费
				operationCostTotal, _ = decimal.NewFromFloat(operationCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "08" { //材料费
				materialCostTotal, _ = decimal.NewFromFloat(materialCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "09" { //西药费
				westernMedicineCostTotal, _ = decimal.NewFromFloat(westernMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "11" { //中成费
				chineseTraditionalMedicineCostTotal, _ = decimal.NewFromFloat(chineseTraditionalMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "14" { //其他费
				otherCostTotal, _ = decimal.NewFromFloat(otherCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}
		}

		tm := time.Unix(patient.SettleAccountsDate, 0)
		ghrq := tm.Format("20060102")
		p := &sz.TB_HIS_MZ_Charge{
			STFRQ:    ghrq,
			STFBH:    patient.Number,
			STFBZ:    "1",
			YLJGDM:   hospital_id,
			GHBM:     strconv.FormatInt(patient.HisPatientId, 10),
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			FPH:      "/",
			YLFKFSDM: "01",
			YLBXLBDM: "01",
			YBZHBZ:   "0000000000000000",
			SSJYBZ:   "1",
			ZLLX:     "04",
			WDBZ:     "1",
			STFSJ:    ghrq,
			STFZE:    patient.MedfeeSumamt,
			SSJE:     patient.MedfeeSumamt,
			YHJE:     0,
			ZFJE:     patient.PsnPartAmt,
			YBJZ:     0,
			YBJJ:     patient.FundPaySumamt,
			YBZE:     patient.InscpScpAmt,
			YBZF:     patient.AcctPay,
			YBFWWZF:  patient.OverlmtSelfPay,
			TXFYE:    "0",
			TXYF:     "0",
			GHF:      "0",
			ZLF:      "0",
			ZHF:      treatCostTotal,
			JCF:      checkCostTotal,
			SSF:      operationCostTotal,
			WSCLF:    operationCostTotal,
			CWF:      bedCostTotal,
			HLF:      "0",
			YSFWF:    "0",
			YBZLF:    "0",
			HYF:      laboratoryCostTotal,
			TSF:      "0",
			SPF:      "0",
			XYF:      westernMedicineCostTotal,
			ZCYF:     chineseTraditionalMedicineCostTotal,
			ZYZJF:    "0",
			ZCAF:     "0",
			QTF:      otherCostTotal,
			CFZS:     "1",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}

		service.BatchCreateTB_HIS_MZ_Charge(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1008,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}
func SyncTB_HIS_MZ_Charge_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1008)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisOrder(9504, sync_time, time.Now().Unix())
	for _, patient := range patients {
		orderInfos, _ := service.GetHisOrderInfoByNumber(patient.Number)
		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		var bedCostTotal float64 = 0                        //床位总费
		var operationCostTotal float64 = 0                  //手术费
		var otherCostTotal float64 = 0                      //其他费用
		var materialCostTotal float64 = 0                   //材料费
		var westernMedicineCostTotal float64 = 0            //西药费
		var chineseTraditionalMedicineCostTotal float64 = 0 //中成药
		var checkCostTotal float64 = 0                      //检查费
		var laboratoryCostTotal float64 = 0                 //化验费
		var treatCostTotal float64 = 0                      //治疗费用

		decimal.DivisionPrecision = 2

		for _, item := range orderInfos {
			if item.MedChrgitmType == "01" { //床位费
				bedCostTotal, _ = decimal.NewFromFloat(bedCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "03" { //检查费
				checkCostTotal, _ = decimal.NewFromFloat(checkCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "04" { //化验费
				laboratoryCostTotal, _ = decimal.NewFromFloat(laboratoryCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "05" { //治疗费
				treatCostTotal, _ = decimal.NewFromFloat(treatCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "06" { //手术费
				operationCostTotal, _ = decimal.NewFromFloat(operationCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "08" { //材料费
				materialCostTotal, _ = decimal.NewFromFloat(materialCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "09" { //西药费
				westernMedicineCostTotal, _ = decimal.NewFromFloat(westernMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "11" { //中成费
				chineseTraditionalMedicineCostTotal, _ = decimal.NewFromFloat(chineseTraditionalMedicineCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}

			if item.MedChrgitmType == "14" { //其他费
				otherCostTotal, _ = decimal.NewFromFloat(otherCostTotal).Add(decimal.NewFromFloat(item.DetItemFeeSumamt)).Float64()
			}
		}

		tm := time.Unix(patient.SettleAccountsDate, 0)
		ghrq := tm.Format("20060102")
		p := &sz.TB_HIS_MZ_Charge{
			STFRQ:    ghrq,
			STFBH:    patient.Number,
			STFBZ:    "1",
			YLJGDM:   hospital_id,
			GHBM:     strconv.FormatInt(patient.HisPatientId, 10),
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			FPH:      "/",
			YLFKFSDM: "01",
			YLBXLBDM: "01",
			YBZHBZ:   "0000000000000000",
			SSJYBZ:   "1",
			ZLLX:     "04",
			WDBZ:     "1",
			STFSJ:    ghrq,
			STFZE:    patient.MedfeeSumamt,
			SSJE:     patient.MedfeeSumamt,
			YHJE:     0,
			ZFJE:     patient.PsnPartAmt,
			YBJZ:     0,
			YBJJ:     patient.FundPaySumamt,
			YBZE:     patient.InscpScpAmt,
			YBZF:     patient.AcctPay,
			YBFWWZF:  patient.OverlmtSelfPay,
			TXFYE:    "0",
			TXYF:     "0",
			GHF:      "0",
			ZLF:      "0",
			ZHF:      treatCostTotal,
			JCF:      checkCostTotal,
			SSF:      operationCostTotal,
			WSCLF:    operationCostTotal,
			CWF:      bedCostTotal,
			HLF:      "0",
			YSFWF:    "0",
			YBZLF:    "0",
			HYF:      laboratoryCostTotal,
			TSF:      "0",
			SPF:      "0",
			XYF:      westernMedicineCostTotal,
			ZCYF:     chineseTraditionalMedicineCostTotal,
			ZYZJF:    "0",
			ZCAF:     "0",
			QTF:      otherCostTotal,
			CFZS:     "1",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}

		service.BatchCreateTB_HIS_MZ_Charge(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1008,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}

// 20.	门诊收费明细表
func SyncTB_HIS_MZ_Fee_Detail(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1009)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisOrderInfo(org_id, sync_time, time.Now().Unix())
	for _, patient := range patients {
		// order,_ := service.GetHisOrderByNumber(patient.OrderNumber)
		var MedListCodg, AdviceName, SingleDoseUnit, MXXMBM string
		if patient.AdviceId > 0 {
			advice, _ := service.GetHisDoctorAdviceInfo(patient.AdviceId)
			MedListCodg = advice.MedListCodg
			AdviceName = advice.AdviceName
			SingleDoseUnit = advice.SingleDoseUnit
			MXXMBM = strconv.FormatInt(advice.DrugId, 10)
		} else {
			advice, _ := service.GetHisPrescriptionProjectInfo(patient.ProjectId)
			MedListCodg = advice.MedListCodg
			if advice.ID > 0 {
				if advice.Type == 2 {
					project, _ := service.GetHisProjectInfo(advice.ProjectId)
					AdviceName = project.ProjectName
					SingleDoseUnit = project.Unit
					MXXMBM = strconv.FormatInt(project.ID, 10)
				} else {
					project, _ := service.GetGoodInfo(advice.ProjectId)
					AdviceName = project.GoodName
					SingleDoseUnit = project.PackingUnit
					MXXMBM = strconv.FormatInt(project.ID, 10)
				}
			}
		}

		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.Ctime, 0)
		ghrq := tm.Format("20060102")
		var mxfylb string
		mxfylb = "99"
		if patient.MedChrgitmType == "01" { //床位费
			mxfylb = "18"
		}

		if patient.MedChrgitmType == "03" { //检查费
			mxfylb = "06"
		}

		if patient.MedChrgitmType == "04" { //化验费
			mxfylb = "07"
		}

		if patient.MedChrgitmType == "05" { //治疗费
			mxfylb = "03"
		}

		if patient.MedChrgitmType == "06" { //手术费
			mxfylb = "04"
		}

		if patient.MedChrgitmType == "08" { //材料费
			mxfylb = "05"
		}

		if patient.MedChrgitmType == "09" { //西药费
			mxfylb = "12"
		}

		if patient.MedChrgitmType == "11" { //中成费
			mxfylb = "13"
		}

		if patient.MedChrgitmType == "14" { //其他费
			mxfylb = "99"
		}
		p := &sz.TB_HIS_MZ_Fee_Detail{
			SFMXID:   strconv.FormatInt(patient.ID, 10),
			TFBZ:     "1",
			YLJGDM:   hospital_id,
			JZLSH:    strconv.FormatInt(patient.HisPatientId, 10),
			STFBH:    patient.OrderNumber,
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			ZLLX:     "04",
			YLFKFSDM: "01",
			FPH:      "/",
			STFSJ:    ghrq,
			MXFYLB:   mxfylb,
			MXXMBM:   MXXMBM,
			MXXMBMYB: MedListCodg,
			MXXMMC:   AdviceName,
			MXXMDW:   SingleDoseUnit,
			MXXMDJ:   patient.Pric,
			MXXMSL:   patient.Cnt,
			MXXMJE:   patient.DetItemFeeSumamt,
			KDKSBM:   "1001",
			KDKSMC:   "血透中心",
			KDRGH:    "1001",
			KDRXM:    "Phony",
			ZXKSBM:   "1001",
			ZXKSMC:   "血透中心",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTB_HIS_MZ_Fee_Detail(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1009,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}
func SyncTB_HIS_MZ_Fee_Detail_pg(rdb *gorm.DB, org_id int64, hospital_id string) {
	// 第一步：根据机构id获取上次同步时间
	syncLastInfo, _ := service.GetSyncTimeByOrgId(org_id, 1009)
	var sync_time int64
	if syncLastInfo.ID > 0 {
		sync_time = syncLastInfo.SyncTime
	} else {
		sync_time = 1714492800
	}

	//同步员工信息
	patients, _ := service.FindOrgHisOrderInfo(9504, sync_time, time.Now().Unix())
	for _, patient := range patients {
		// order,_ := service.GetHisOrderByNumber(patient.OrderNumber)
		var MedListCodg, AdviceName, SingleDoseUnit, MXXMBM string
		if patient.AdviceId > 0 {
			advice, _ := service.GetHisDoctorAdviceInfo(patient.AdviceId)
			MedListCodg = advice.MedListCodg
			AdviceName = advice.AdviceName
			SingleDoseUnit = advice.SingleDoseUnit
			MXXMBM = strconv.FormatInt(advice.DrugId, 10)
		} else {
			advice, _ := service.GetHisPrescriptionProjectInfo(patient.ProjectId)
			MedListCodg = advice.MedListCodg
			if advice.ID > 0 {
				if advice.Type == 2 {
					project, _ := service.GetHisProjectInfo(advice.ProjectId)
					AdviceName = project.ProjectName
					SingleDoseUnit = project.Unit
					MXXMBM = strconv.FormatInt(project.ID, 10)
				} else {
					project, _ := service.GetGoodInfo(advice.ProjectId)
					AdviceName = project.GoodName
					SingleDoseUnit = project.PackingUnit
					MXXMBM = strconv.FormatInt(project.ID, 10)
				}
			}
		}

		patientInfo, _ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.Ctime, 0)
		ghrq := tm.Format("20060102")
		var mxfylb string
		mxfylb = "99"
		if patient.MedChrgitmType == "01" { //床位费
			mxfylb = "18"
		}

		if patient.MedChrgitmType == "03" { //检查费
			mxfylb = "06"
		}

		if patient.MedChrgitmType == "04" { //化验费
			mxfylb = "07"
		}

		if patient.MedChrgitmType == "05" { //治疗费
			mxfylb = "03"
		}

		if patient.MedChrgitmType == "06" { //手术费
			mxfylb = "04"
		}

		if patient.MedChrgitmType == "08" { //材料费
			mxfylb = "05"
		}

		if patient.MedChrgitmType == "09" { //西药费
			mxfylb = "12"
		}

		if patient.MedChrgitmType == "11" { //中成费
			mxfylb = "13"
		}

		if patient.MedChrgitmType == "14" { //其他费
			mxfylb = "99"
		}
		p := &sz.TB_HIS_MZ_Fee_Detail{
			SFMXID:   strconv.FormatInt(patient.ID, 10),
			TFBZ:     "1",
			YLJGDM:   hospital_id,
			JZLSH:    strconv.FormatInt(patient.HisPatientId, 10),
			STFBH:    patient.OrderNumber,
			KH:       patientInfo.DialysisNo,
			KLX:      "3",
			ZLLX:     "04",
			YLFKFSDM: "01",
			FPH:      "/",
			STFSJ:    ghrq,
			MXFYLB:   mxfylb,
			MXXMBM:   MXXMBM,
			MXXMBMYB: MedListCodg,
			MXXMMC:   AdviceName,
			MXXMDW:   SingleDoseUnit,
			MXXMDJ:   patient.Pric,
			MXXMSL:   patient.Cnt,
			MXXMJE:   patient.DetItemFeeSumamt,
			KDKSBM:   "1001",
			KDKSMC:   "血透中心",
			KDRGH:    "1001",
			KDRXM:    "Phony",
			ZXKSBM:   "1001",
			ZXKSMC:   "血透中心",
			SJSCSJ:   time.Now(),
			XGBZ:     0,
		}
		service.BatchCreateTB_HIS_MZ_Fee_Detail(p, rdb)

	}

	upload := &sz.DataUpload{
		SyncType:       1009,
		OrgId:          org_id,
		SyncTime:       time.Now().Unix(),
		SyncResultType: 1,
		CreateTime:     time.Now().Unix(),
		UpdateTime:     time.Now().Unix(),
	}
	service.CreateUploadRecord(upload)
}