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"
	"github.com/shopspring/decimal"
	"math"
	"strconv"
	"strings"
	"time"
)

var createUploadDataCronJob *cron.Cron

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

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

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

//
func BeginAutoJob() {

	createUploadDataCronJob.Start()
}

func SyncToSzbl() {
	org := &sz.DataUploadConfig{
		OrgId:          10138,
		ProvinceId:     19,
		CityId:         291,
		DepartmentName: "深圳市百霖血液透析中心",
		HospitalId:     "MA5DB4KB6 ",
		InstType:       1,
		DbHost:         "127.0.0.1",
		DbPort:         "1433",
		DbPass:         "adapter",
		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)
		// 机构床位  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)
	
		// 第四步：关闭数据库连接
		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_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 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.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:  "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.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_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.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 = "-"
		}

		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:     strconv.FormatInt(item.EquitmentId,10),
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		if disinfect.WaterType == 0 {
			disinfect.WaterType = 1
		}

		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:     strconv.FormatInt(item.EquitmentId,10),
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		if disinfect.WaterType == 0 {
			disinfect.WaterType = 1
		}
		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:     strconv.FormatInt(item.EquitmentId,10),
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		if disinfect.WaterType == 0 {
			disinfect.WaterType = 1
		}
		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:     strconv.FormatInt(item.EquitmentId,10),
			WaterType:       item.Specimenb,
			CaseOrder:       parseInt,
			CreateTime:      time.Unix(item.Ctime, 0),
			UpdateTime:      time.Unix(item.Ctime, 0),
			Sjscsj:          time.Now(),
			Xgbz:            0,
		}
		if disinfect.WaterType == 0 {
			disinfect.WaterType = 1
		}
		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(),
		}
		if ci.CiType == 0 {
			ci.CiType = 1
		}

		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:      "",
		}
		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 {
		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:     strconv.FormatInt(item.EquitmentId,10),
			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),
		}
		if waterbc.WaterType == 0 {
			waterbc.WaterType = 3
		}

		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:     strconv.FormatInt(item.EquitmentId,10),
			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),
		}
		if wateren.WaterType == 0 {
			wateren.WaterType = 3
		}

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

// 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)
}

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

	//同步员工信息
	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: 		"0",
			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",
			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)
}

// 14.	16.	门诊就诊记录表
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 = 0
	}

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

	for _, patient := range patients {
		patientInfo,_ := service.FindOrgPatientInfoById(patient.PatientId)
		tm := time.Unix(patient.Ctime,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",
			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 = 0
	}

	//同步员工信息
	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,
				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 = 0
	}

	//同步员工信息
	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_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 = 0
	}

	//同步员工信息
	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)
}

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

	//同步员工信息
	patients, _ := service.FindOrgHisOrderInfo(org_id, sync_time, time.Now().Unix())
	for _, patient := range patients {
		// order,_ := service.GetHisOrderByNumber(patient.OrderNumber)
		advice,_ := service.GetHisDoctorAdviceInfo(patient.AdviceId)
		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:		strconv.FormatInt(advice.DrugId,10),
			MXXMBMYB:	advice.MedListCodg,
			MXXMMC: 	advice.AdviceName,
			MXXMDW:		advice.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)
}