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"
	"math"
	"strconv"
	"strings"
	"time"
)

var createUploadDataCronJob *cron.Cron

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

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

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

//
func BeginAutoJob() {

	createUploadDataCronJob.Start()
}

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:         "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)

		// 透析机透析液细菌培养检测记录表(t_hd_dm_dialysate_bc)
		//SyncLisCulture(orgDb,org.OrgId,org.HospitalId)
		//透析机透析液内毒素检测记录表(T_HD_DM_DIALYSATE_BC)
		//SyncDialysate(orgDb,org.OrgId,org.HospitalId)

		//物表消毒记录表(T_HD_SURFACE_DISINFECT)
		//SyncLisBodyDetection(orgDb,org.OrgId,org.HospitalId)
		// 第四步：关闭数据库连接

		//透析用水游离氯检测表(T_HD_WATER_FC)
		//SyncLisWaterFc(orgDb,org.OrgId,org.HospitalId)

		//透析用水有毒化学物检测表(T_HD_WATER_NC)
		//SynLisWaterNc(orgDb,org.OrgId,org.HospitalId)

		//透析用水PH值检测表(T_HD_WATER_PH)
		//SynLisWaterPh(orgDb,org.OrgId,org.HospitalId)

		//透析用水水硬度检测表(T_HD_WATER_WH)
		//SynListHadWater(orgDb,org.OrgId,org.HospitalId)

		//导管感染记录表(T_HD_CI)
		//SynListHdCi(orgDb,org.OrgId,org.HospitalId)

		//导管感染转归记录表(T_HD_CI_OUTCOME)
		// SynLisHdCiOutCome(orgDb,org.OrgId,org.HospitalId)

		//透析室空气消毒记录表(T_HD_AIR_DISINFECT)
		//SyncLisAirDetection(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)

		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:         "localhost",
		DbPort:         "1433",
		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 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,
			EquipmentModel: strconv.FormatInt(item.UnitType, 10),
			EnableTime:     time.Unix(item.StartDate, 0),
			DiscardedTime:  time.Unix(item.RubbishDate, 0),
			EquipmentType:  item.DeviceType,
			CreateTime:     time.Now(),
			UpdateTime:     time.Now(),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}

		wms = append(wms, wm)
	}

	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{
			ID:            role.AdminUserId,
			HospitalId:    hospital_id,
			StaffId:       strconv.FormatInt(role.ID, 10),
			StaffName:     role.UserName,
			Position:      int64(title),
			PermanentType: 1,
			CreateTime:    time.Now(),
			UpdateTime:    time.Now(),
			Sjscsj:        time.Now(),
			Xgbz:          0,
		}
		staffs = append(staffs, staff)

	}

	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 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:    patient.AdmissionNumber,
			CreateTime:        time.Now(),
			UpdateTime:        time.Now(),
			Sjscsj:            time.Now(),
			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)
	}

	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 = 0
	}

	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.Now(),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}

		hdShift = append(hdShift, shift)
	}
	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 = 0
	}

	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)
	}
	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 = 0
	}

	var tempPsmedicine []*sz.TempHdPsMedicine
	prescriptions, _ := service.FindOrgDoctorAdviceTemplateData(org_id, sync_time, time.Now().Unix())

	for _, item := range prescriptions {

		psm := &sz.TempHdPsMedicine{
			Sn:             item.ID,
			HospitalId:     hospital_id,
			MedicineTypeId: "2",
			MedicineId:     strconv.FormatInt(item.ID, 10),
			CreateTime:     time.Now(),
			Sjscsj:         time.Now(),
			Xgbz:           0,
		}
		tempPsmedicine = append(tempPsmedicine, psm)
	}

	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 {
		//错误处理

	}
}

// 同步转院信息
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.FindOrgPatientOutData(org_id, sync_time, time.Now().Unix())
	//
	for _, patient := range patients {

		p := &sz.TempHdPatientOut{
			Sn:           strconv.FormatInt(patient.PatientLapseto.ID, 10),
			HospitalId:   hospital_id,
			PatientNk:    strconv.FormatInt(patient.ID, 10),
			SequelaeDate: time.Unix(patient.PatientLapseto.LapsetoTime, 0),
			SequelaeType: "99",
			CreateTime:   time.Unix(patient.PatientLapseto.CreatedTime, 0),
			DeathReason:  "99",
			ExtReason:    "99",
			Sjscsj:       time.Now(),
			Xgbz:         0,
		}
		hdPatientOuts = append(hdPatientOuts, p)
	}

	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 = 0
	}

	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.Now(),
				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)
		}

	}

	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 = 0
	}

	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.Now(),
			Sjscsj:      time.Now(),
			Xgbz:        0,
		}
		if mid.Sbp > 999 {
			continue
		}

		if mid.Dbp > 999 {
			continue
		}

		hdMiddle = append(hdMiddle, mid)
	}

	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,
			EquipmentModel: strconv.FormatInt(item.UnitType, 10),
			EnableTime:     time.Unix(item.BuyDate, 0),
			Status:         1,
			EquipmentType:  11,
			CreateTime:     time.Now(),
			UpdateTime:     time.Now(),
			Sjscsj:         time.Now(),
			Xgbz:           strconv.FormatInt(0, 10),
		}
		switch item.MachineStatus {
		case 1:
			wm.Status = 1
			break
		case 4:
			wm.Status = 3
			break
		}

		wms = append(wms, wm)
	}

	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 {
		//错误处理

	}

}

// 同步维修
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{
			HospitalId:  hospital_id,
			EquipmentId: strconv.FormatInt(item.VMDeviceAddmacher.ID, 10),
			RepairTime:  time.Unix(item.GuaranteeDate, 0),
			CreateTime:  time.Now(),
			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)
	}

	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 {
		//错误处理

	}

}

// 同步设备
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,
			EquipmentModel: strconv.FormatInt(item.UnitType, 10),
			EnableTime:     time.Unix(item.BuyDate, 0),
			// EquipmentType:	"11",
			Bbp:        "0",
			CreateTime: time.Now(),
			UpdateTime: time.Now(),
			Sjscsj:     time.Now(),
			Xgbz:       strconv.FormatInt(0, 10),
		}

		switch item.MachineStatus {
		case 1:
			hdm.Status = "1"
			break
		case 4:
			hdm.Status = "3"
			break
		}

		switch item.DeviceType {
		case 1:
			hdm.EquipmentType = "11"
			break
		case 3:
			hdm.EquipmentType = "99"
			break
		}

		hdms = append(hdms, hdm)
	}

	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 = 0
	}

	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:             item.DeviceNumber.Number,
			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,
			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)
	}

	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.Now(),
			UpdateTime:   time.Now(),
			Sjscsj:       time.Now(),
			Xgbz:         strconv.FormatInt(0, 10),
		}

		hdms = append(hdms, hdm)
	}

	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 = 0
	}

	//同步员工信息
	patients, _ := service.FindOrgPatientData(org_id, sync_time, time.Now().Unix())
	var accessList []*sz.TempHdAccess
	for _, patient := range patients {
		before, _ := service.FindAssessmentBeforeDislysis(org_id, patient.ID)
		if before.ID > 0 {
			access := &sz.TempHdAccess{
				AccessId:       before.ID,
				HospitalId:     hospital_id,
				PatientNk:      strconv.FormatInt(before.PatientId, 10),
				AccessType:     1,
				AccessTypeName: "自体动静脉内瘘",
				AccessStatus:   1,
				SetupDate:      time.Unix(patient.FirstDialysisDate, 0),
				FirstUseTime:   time.Unix(patient.FirstDialysisDate, 0),
				CreateTime:     time.Now(),
				UpdateTime:     time.Now(),
				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.Now(),
			UpdateTime:  time.Now(),
			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 = 0
	}

	//同步患者
	patients, _ := service.FindOrgPatientData(org_id, sync_time, time.Now().Unix())
	var diagnosisList []*sz.TempHdDiagnosis
	for _, patient := range patients {
		diagnosis := &sz.TempHdDiagnosis{
			DiagnosisId:         patient.ID,
			HospitalId:          hospital_id,
			PatientNk:           strconv.FormatInt(patient.ID, 10),
			DiagnosisTime:       time.Unix(patient.CreatedTime, 0),
			DiagnosisType:       "10",
			DiagnosisTypeItem:   "1001",
			DiagnosisTypeDetail: "100113",
			CreateTime:          time.Now(),
			UpdateTime:          time.Now(),
			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 {
		//	查询有没有做传染病检查并返回检验检查时间
		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:        0,
						Hcv:        0,
						Rpr:        0,
						Hiv:        0,
						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 {
						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 = 0
	}

	//同步监测记录
	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 {
			//错误处理

		}
	}
}

// 血透患者检测结果表（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 = 0
	}

	//同步监测记录
	inspections, _ := service.FindOrgInspection(org_id, sync_time, time.Now().Unix())
	var lisReportList []*sz.TempHdLisReport
	tempFlag := 1
	for _, inspection := range inspections {
		tempFlag = 1
		fmt.Println("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
			}
		}
		fmt.Println("3")
		if tempFlag == 1 {
			lisReport := &sz.TempHdLisReport{
				LabSno:          strconv.FormatInt(inspection.InspectType, 10) + strconv.FormatInt(inspection.ProjectId, 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:  "10035",
				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.ItemName,
				CheckItemCode:   strconv.FormatInt(inspection.ItemId, 10),
				RecordCcount:    0,
				CheckResult:     inspection.InspectValue,
				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_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 = 0
	}

	//同步监测记录
	inspections, _ := service.FindOrgInspectionReference(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.InspectType, 10) + strconv.FormatInt(inspection.ProjectId, 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 = "-"
		}

		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 {
			//错误处理

		}
	}
}

//细菌培养检测记录表

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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		lisDialysate := &sz.TempHdLisCulture{
			Sn:                      strconv.FormatInt(item.ID, 10),
			HospitalId:              hospital_id,
			EquitmentId:             item.EquitmentId,
			InspectionTime:          time.Unix(item.SpelingDate, 0),
			IsQualified:             item.Modifications,
			IsSubstitutionQualified: item.Modifications,
			CaseOrder:               parseInt,
			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 {
			//错误处理

		}
	}

}

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())
	fmt.Println("dia", dialysate)
	var lisHdLisDialysate []*sz.TempHdLisDialysate
	for _, item := range dialysate {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		lisDialysate := &sz.TempHdLisDialysate{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			EquitmentId:    item.EquitmentId,
			InspectionTime: time.Unix(item.SamplingDate, 0),
			IsQualified:    item.Modifications,
			InspectedValue: 0,
			CaseOrder:      parseInt,
			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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisBodyDisinfect{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			InspectionTime: time.Unix(item.CreatedTime, 0),
			IsQualified:    item.CheckOut,
			InspectedValue: item.DetectionResult,
			CaseOrder:      parseInt,
			CreateTime:     time.Unix(item.Ctime, 0),
			UpdateTime:     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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisWaterFc{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     item.PassExamination,
			InspectionOrgId: item.DetectionUnit,
			InspectedValue:  item.DetectionResultb,
			EquitmentId:     item.Bed,
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		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 {
			//错误处理

		}
	}
}

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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisWaterNc{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     item.PassExamination,
			InspectionOrgId: item.DetectionUnit,
			InspectedValue:  item.DetectionResultb,
			EquitmentId:     item.Bed,
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisWaterPh{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     item.PassExamination,
			InspectionOrgId: item.DetectionUnit,
			InspectedValue:  item.DetectionResultb,
			EquitmentId:     item.Bed,
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisWaterWh{
			Sn:              strconv.FormatInt(item.ID, 10),
			HospitalId:      hospital_id,
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     item.PassExamination,
			InspectionOrgId: item.DetectionUnit,
			InspectedValue:  item.DetectionResultb,
			EquitmentId:     item.Bed,
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		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:      item.BloodAccessPartOperaId,
			CiType:        item.CiType,
			BloodCulture:  item.BloodCultupe,
			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),
			InfectSn:     strconv.FormatInt(item.ID, 10),
			PatientNk:    strconv.FormatInt(item.PatientId, 10),
			HospitalId:   hospital_id,
			SequelaeType: item.SequelaeType,
			Sjscsj:       time.Now(),
			Xgbz:         0,

			CreateTime: time.Unix(item.Ctime, 0),
			UpdateTime: time.Unix(item.Mtime, 0),
			Ylyl1:      "",
			Ylyl2:      "",
		}

		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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		disinfect := &sz.TempHdLisAirDisinfect{
			Sn:             strconv.FormatInt(item.ID, 10),
			HospitalId:     hospital_id,
			InspectionTime: time.Unix(item.CreatedTime, 0),
			IsQualified:    item.CheckOut,
			InspectedValue: item.DetectionResult,
			CaseOrder:      parseInt,
			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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		waterbc := &sz.TempHdLisWaterBc{
			HospitalId:      hospital_id,
			Sn:              strconv.FormatInt(item.ID, 10),
			EquitmentId:     item.Bed,
			WaterType:       item.Specimen,
			InspectionOrgId: item.DetectionUnit,
			InspectionTime:  time.Unix(item.SpelingDate, 0),
			IsQualified:     item.Modifications,
			InspectedValue:  item.DetectionResult,
			CaseOrder:       parseInt,
			Sjscsj:          time.Now(),
			Xgbz:            0,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Mtime, 0),
		}

		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 {
		parseInt, _ := strconv.ParseInt(item.Sort, 10, 64)
		wateren := &sz.TempHdLisWaterEn{
			HospitalId:      hospital_id,
			Sn:              strconv.FormatInt(item.ID, 10),
			EquitmentId:     item.Bed,
			WaterType:       item.Specimenb,
			InspectionOrgId: item.DetectionUnit,
			InspectionTime:  time.Unix(item.SamplingDate, 0),
			IsQualified:     item.Modifications,
			InspectedValue:  item.DetectionResultb,
			CaseOrder:       parseInt,
			Sjscsj:          time.Now(),
			Xgbz:            0,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Mtime, 0),
		}

		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 {
			//错误处理

		}
	}
}
