XT_New/service/manage_service.go

package service

import (
	"XT_New/models"
	"fmt"
	"github.com/jinzhu/gorm"
	"strings"
	"time"
)

func GetEquitmentName(unit_type string, orgid int64) (*models.DeviceEquimentname, error) {
	var equimentname models.DeviceEquimentname
	var err error
	err = UserReadDB().Model(&equimentname).Where("equitment_name = ? and user_org_id = ? and status = 1", unit_type, orgid).Find(&equimentname).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &equimentname, nil
}

func CreateEquimentName(equimentname models.DeviceEquimentname) error {

	//err := XTWriteDB().Create(&equimentname).Error
	//return err
	err := writeUserDb.Create(&equimentname).Error
	return err
}

func GetEquitmentByBedID(bedid int64, orgid int64) (models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Model(&addmacher).Where("bed_id = ? and user_org_id = ? and status = 1", bedid, orgid).First(&addmacher).Error
	return addmacher, err
}

func CreateMacher(machers *models.DeviceAddmacher) error {

	//err := writeDb.Create(&machers).Error
	//xt := writeDb.Begin()
	//  //fmt.Println("hhhhhhhh",xt)
	//  //err := xt.Model(&models.DeviceAddmacher{}).Create(machers).Error
	//  //fmt.Println("err",err)
	//  //if err !=nil{
	//	// xt.Rollback()
	//  //}
	//  //xt.Commit()
	//  //return err
	err := writeUserDb.Create(&machers).Error
	return err
}

func UpdateMachine(id int64, orgid int64, addmacher *models.DeviceAddmacher) error {

	err := writeUserDb.Model(&addmacher).Where("id = ? AND user_org_id = ? AND status = ?", id, orgid, 1).Updates(map[string]interface{}{"serial_number": addmacher.SerialNumber, "device_type": addmacher.DeviceType, "bed_number": addmacher.BedNumber, "device_name": addmacher.DeviceName, "manufacture_factory": addmacher.ManufactureFactory, "service_manufacturer": addmacher.ServiceManufacturer, "unit_type": addmacher.UnitType, "use_section": addmacher.UseSection, "section_number": addmacher.SectionNumber, "buy_date": addmacher.BuyDate, "install_date": addmacher.InstallDate, "start_date": addmacher.StartDate, "maintenace_engineer": addmacher.MaintenaceEngineer, "telephone": addmacher.Telephone, "guarantee_date": addmacher.GuaranteeDate, "machine_status": addmacher.MachineStatus, "user_total": addmacher.UserTotal, "remarks": addmacher.Remarks, "rubbish_date": addmacher.RubbishDate, "rubbish_reason": addmacher.RubbishReason, "user_year": addmacher.UserYear, "work_time": addmacher.WorkTime, "bed_id": addmacher.BedId, "disinfection_mode": addmacher.DisinfectionMode, "revers_mode": addmacher.ReversMode, "mtime": time.Now().Unix()}).Error

	return err

}

func GetZoneName(zoneid int64, orgid int64) (models.DeviceZone, error) {
	zone := models.DeviceZone{}
	err := XTReadDB().Where("id = ? AND org_id = ?", zoneid, orgid).Find(&zone).Error
	return zone, err
}

func UpdateTreatMode(id int64, orgid int64, treatmodes []int64) (err error) {
	utx := XTWriteDB().Begin()
	err = utx.Model(models.DeviceTreatmentmode{}).Where("machine_id = ? AND user_org_id = ?", id, orgid).Updates(map[string]interface{}{"status": 2, "mtime": time.Now().Unix()}).Error
	fmt.Println("错误是什么", err)
	if err != nil {
		utx.Rollback()
		return
	}
	if len(treatmodes) > 0 {
		thisSQL := "INSERT INTO xt_device_treatmentmode(machine_id,treate_mode,status,ctime,user_org_id) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, treatmode := range treatmodes {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, id)
			insertData = append(insertData, treatmode)
			insertData = append(insertData, 1)
			insertData = append(insertData, time.Now().Unix())
			insertData = append(insertData, orgid)
		}
		thisSQL += strings.Join(insertParams, ",")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			return
		}
	}
	utx.Commit()
	return
}

func GetAllEquimentName(orgid int64) (equit []*models.DeviceEquimentname, err error) {

	err = readUserDb.Model(&equit).Where("user_org_id = ? AND status = ?", orgid, 1).Group("equitment_name").Find(&equit).Error

	return equit, err
}

func GetBed(equitid int64) (models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Where("id=? AND status = ?", equitid, 1).Find(&addmacher).Error
	return addmacher, err
}

func QueryPlan(orgid int64, devicetype int64, ids []int64, classids []int64, equitid int64) (*models.DevicePlan, error) {

	var pre models.DevicePlan
	var err error
	//for _, id := range ids {
	//	for _, classids := range classids {
	//		err = UserReadDB().Model(&pre).Where("user_org_id = ? AND device_type = ? AND time = ? AND classtime = ? AND equiment_id = ? AND status = 1", orgid, devicetype, id, classids, equitid).Find(&pre).Error
	//	}
	//}
	//if err == gorm.ErrRecordNotFound {
	//	return nil, err
	//}
	//if err != nil {
	//	return nil, err
	//}
	//return &pre, nil

	if len(ids) == 1 && len(classids) == 1 {
		err = UserWriteDB().Model(&models.DevicePlan{}).Where("user_org_id = ? and device_type = ? and  time = ? and classtime = ?  and status = 1 ", orgid, devicetype, ids[0], classids[0]).Find(&pre).Error
		if err == gorm.ErrRecordNotFound {
			return nil, err
		}
		if err != nil {
			return nil, err
		}
	} else {
		err = UserWriteDB().Model(models.DevicePlan{}).Where("time IN(?) and user_org_id = ? and device_type = ? AND classtime IN(?) and status = 1", ids, orgid, devicetype, classids).Find(&pre).Error
		if err == gorm.ErrRecordNotFound {
			return nil, err
		}
		if err != nil {
			return nil, err
		}
	}

	return &pre, nil
}

func AddPlan(orgid int64, deviceType int64, disinfecTime string, ids []int64, classids []int64, way int64, machinedisinfectant int64, disinfectantway int64, disinfectant int64, equimentid int64, bedid int64) (err error) {
	xt := UserWriteDB().Begin()
	if len(ids) > 0 {
		thisSQL := "INSERT INTO xt_device_plan(device_type,disinfec_time,time,classtime,way,machine_disinfectant,disinfectan_way,disinfectant,status,ctime,user_org_id,equiment_id,bed_id) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, id := range ids {
			for _, classids := range classids {
				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?)")
				insertData = append(insertData, deviceType)
				insertData = append(insertData, disinfecTime)
				insertData = append(insertData, id)
				insertData = append(insertData, classids)
				insertData = append(insertData, way)
				insertData = append(insertData, machinedisinfectant)
				insertData = append(insertData, disinfectantway)
				insertData = append(insertData, disinfectant)
				insertData = append(insertData, 1)
				insertData = append(insertData, time.Now().Unix())
				insertData = append(insertData, orgid)
				insertData = append(insertData, equimentid)
				insertData = append(insertData, bedid)
			}
		}
		thisSQL += strings.Join(insertParams, ",")
		err = xt.Exec(thisSQL, insertData...).Error
		if err != nil {
			xt.Rollback()
			return
		}
	}
	xt.Commit()
	return
}

func GetAllPlan(orgid int64) (plan []*models.DevicePlans, err error) {

	//db := readUserDb.Table("xt_device_plan as p").Where("p.status = 1")
	//	//table := readUserDb.Table("xt_device_addmacher as e")
	//	//fmt.Println("table", table)
	//	//if orgid > 0 {
	//	//	db = db.Where("p.user_org_id = ?", orgid)
	//	//}
	//	//err = db.Select("p.id,p.device_type,p.disinfec_time,p.time,p.classtime,p.way,p.machine_disinfectant,p.disinfectan_way,p.disinfectant,e.unit_type").Group("p.id").Joins("Left JOIN xt_device_addmacher as e On e.id = p.device_type").Order("e.unit_type asc,p.time").Scan(&plan).Error
	//	//return plan, err

	err = readUserDb.Raw("select DISTINCT p.id,p.device_type,p.disinfec_time,p.time,p.classtime,p.way,p.machine_disinfectant,p.disinfectan_way,p.disinfectant,p.equiment_id,p.bed_id,e.device_mode from xt_device_plan as p  left join xt_device_mode as e On e.id = p.device_type where p.user_org_id = ? and p.status = 1", orgid).Order("e.device_mode asc,p.time").Scan(&plan).Error
	return plan, err
}

func GetDeviceType(unitype string) (models.DeviceMode, error) {
	equimentname := models.DeviceMode{}
	err := UserReadDB().Where("id = ?", unitype).Find(&equimentname).Error
	return equimentname, err
}

func GetAllPlanDetail(id int64, orgid int64) (plan []*models.DevicePlans, err error) {
	//db := readUserDb.Table("xt_device_plan as p").Where("p.status = 1")
	//table := readUserDb.Table("xt_device_addmacher as e")
	//fmt.Println("table", table)
	//if orgid > 0 {
	//	db = db.Where("p.user_org_id = ?", orgid)
	//}
	//if id > 0 {
	//	db = db.Where("p.equiment_id = ?", id)
	//}
	//err = db.Select("p.id,p.device_type,p.disinfec_time,p.time,p.classtime,p.way,p.machine_disinfectant,p.disinfectan_way,p.disinfectant,e.unit_type").Group("p.id").Joins("Left JOIN xt_device_addmacher as e On e.id = p.equiment_id").Order("p.time asc").Scan(&plan).Error
	//return plan, err
	err = readUserDb.Raw("select DISTINCT p.id,p.device_type,p.disinfec_time,p.time,p.classtime,p.way,p.machine_disinfectant,p.disinfectan_way,p.disinfectant,p.equiment_id,p.bed_id,e.device_mode from xt_device_plan as p left join xt_device_mode as e On e.id = p.device_type where p.user_org_id = ? and p.device_type = ? and p.status = 1", orgid, id).Order("p.time asc,p.classtime asc").Scan(&plan).Error
	return plan, err
}

func DeletePlan(id int64) (err error) {

	err = UserWriteDB().Model(&models.DevicePlan{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return
}

func DeletePlans(orgid int64, ids []int64) (err error) {

	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DevicePlan{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DevicePlan{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return
}

func GetPlanDetailById(id int64, orgid int64) (models.DevicePlanss, error) {
	plans := models.DevicePlanss{}
	db := UserReadDB().Table("xt_device_plan as x").Where("x.status = 1")
	table := UserReadDB().Table("xt_device_addmacher as a").Where("a.status = 1")
	fmt.Println("table", table)
	if id > 0 {
		db = db.Where("x.id = ?", id)
	}
	if orgid > 0 {
		db = db.Where("x.user_org_id = ?", orgid)
	}
	err := db.Select("x.id,x.device_type,x.disinfec_time,x.time,x.classtime,x.way,x.machine_disinfectant,x.disinfectan_way,x.disinfectant,x.status,x.user_org_id,x.equiment_id,a.unit_type").Joins("Left Join xt_device_addmacher as a ON a.id = x.equiment_id").Scan(&plans).Error
	return plans, err
}

func UpdatePlanInfo(id int64, orgid int64, plan models.DevicePlan) error {

	err := writeUserDb.Model(&plan).Where("id = ? AND user_org_id = ?", id, orgid).Updates(map[string]interface{}{"device_type": plan.DeviceType, "disinfec_time": plan.DisinfecTime, "time": plan.Time, "classtime": plan.Classtime, "way": plan.Way, "machine_disinfectant": plan.MachineDisinfectant, "disinfectan_way": plan.MachineDisinfectant, "disinfectant": plan.Disinfectant, "mtime": time.Now().Unix()}).Error
	return err
}

func GetComprehensive(zone int64, number int64, devicetype int64, year int64, starttime int64, endtime int64, orgid int64) (macher []*models.DeviceAddmachers, err error) {
	db := readUserDb.Table("xt_device_addmacher as a").Where("a.status = 1")
	table := XTReadDB().Table("xt_device_zone as x")
	fmt.Println(table)
	if orgid > 0 {
		db = db.Where("a.user_org_id = ?", orgid)
	}
	if zone > 0 {
		db = db.Where("a.zone_id  = ?", zone)
	}
	if number > 0 {
		db = db.Where("a.bed_id = ?", number)
	}
	if devicetype > 0 {
		db = db.Where("a.device_type = ?", devicetype)
	}
	if year == 1 {
		db = db.Where("a.user_year >= 0 AND a.user_year <= 1")
	}
	if year == 2 {
		db = db.Where("a.user_year >=1 AND a.user_year <= 3")
	}
	if year == 3 {
		db = db.Where("a.user_year >=3 AND a.user_year <= 10")
	}
	if year == 4 {
		db = db.Where("a.user_year >=10")
	}

	if starttime > 0 {
		db = db.Where("a.ctime >= ?", starttime)
	}
	if endtime > 0 {
		db = db.Where("a.ctime <= ?", endtime)
	}
	err = db.Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.zone_id,a.bed_id,x.name,m.device_mode").Joins("Left JOIN sgj_xt.xt_device_zone as x On x.id = a.zone_id").Joins("Left JOIN xt_device_mode as m on m.id = a.unit_type").Scan(&macher).Error
	return macher, err
}

func GetBedId(id int64) (models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Where("id = ? AND status = 1", id).Find(&addmacher).Error
	return addmacher, err
}

func GetPatientInfo(bedid int64, nowtime int64, orgid int64) (schedules []*models.Schedules, err error) {

	db := XTReadDB().Table("xt_schedule as s").Where("s.status = 1")

	table := XTReadDB().Table("xt_patients as x")

	fmt.Println("table", table)
	if bedid > 0 {
		db = db.Where("s.bed_id = ?", bedid)
	}
	if nowtime > 0 {
		db = db.Where("s.schedule_date = ?", nowtime)
	}
	if orgid > 0 {
		db = db.Where("s.user_org_id = ?", orgid)
	}

	err = db.Select("s.id,s.user_org_id,s.partition_id,s.bed_id,s.patient_id,s.schedule_date,s.schedule_type,s.schedule_week,s.mode_id,x.name").Joins("Left Join xt_patients as x On x.id = s.patient_id").Scan(&schedules).Error
	return schedules, err

}

func GetPatient(bedid int64, orgid int64, classid int64, nowtime int64) (schedules models.Schedules, err error) {
	db := XTReadDB().Table("xt_schedule as s").Where("s.status = 1")
	table := XTReadDB().Table("xt_patients as x")
	fmt.Println("table", table)
	err = db.Select("s.id,s.user_org_id,s.partition_id,s.bed_id,s.patient_id,s.schedule_date,s.schedule_type,s.schedule_week,s.mode_id,x.name,x.is_infectious").Joins("Left Join xt_patients as x On x.id = s.patient_id").Where("s.bed_id = ? AND s.user_org_id = ? AND s.schedule_type = ? AND s.schedule_date = ?", bedid, orgid, classid, nowtime).Scan(&schedules).Error
	return schedules, err
}

func GetPartitionName(id int64) (models.DeviceZone, error) {
	zone := models.DeviceZone{}
	err := XTReadDB().Where("id = ? AND status = 1", id).Find(&zone).Error

	return zone, err
}

func GetPatientNumber(id int64) (models.DeviceNumber, error) {
	number := models.DeviceNumber{}
	err := XTReadDB().Where("id = ? AND status = 1", id).Find(&number).Error
	return number, err
}

func GetDialysisOrder(time int64, patientid int64, orgid int64) (models.DialysisOrder, error) {
	order := models.DialysisOrder{}
	err := XTReadDB().Where("dialysis_date = ? AND patient_id = ? AND user_org_id = ? ", time, patientid, orgid).Find(&order).Error
	return order, err
}

func GetDialysisWay(time int64, patientid int64, orgid int64) (models.DialysisPrescription, error) {
	prescription := models.DialysisPrescription{}
	err := XTReadDB().Where("record_date = ? AND patient_id = ? AND user_org_id = ?", time, patientid, orgid).Find(&prescription).Error
	return prescription, err
}

func GetDialysisTime(time int64, patientid int64, orgid int64) (models.AssessmentAfterDislysis, error) {
	dislysis := models.AssessmentAfterDislysis{}
	err := XTReadDB().Where("assessment_date = ? AND patient_id = ? AND user_org_id = ?", time, patientid, orgid).Find(&dislysis).Error
	return dislysis, err
}

func GetAllOrganization(orgid int64, appid int64) (approle []*models.App_Role, err error) {
	err = UserReadDB().Where("org_id = ? AND app_id = ? AND status = 1", orgid, appid).Find(&approle).Error
	return approle, err
}

func CreateUserInformation(information *models.DeviceInformation) error {

	err := writeUserDb.Create(&information).Error
	return err
}

func GetRegisterInfo(orgid int64, id int64, timenow int64) (models.DeviceInformations, error) {
	//information := models.DeviceInformations{}
	var information models.DeviceInformations
	db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_patients as p")
	fmt.Println("table", table)
	dbs := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Print("dbs", dbs)
	err = db.Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,p.name,r.user_name,r.admin_user_id").Joins("Left join sgj_xt.xt_patients as p On p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Where("x.user_org_id = ? AND x.equiment_id = ? AND x.date = ?", orgid, id, timenow).Scan(&information).Error
	return information, err
}

func GetSignName(id int64, orgid int64, appid int64) (models.App_Role, error) {
	role := models.App_Role{}
	err := UserReadDB().Model(&role).Where("admin_user_id = ? AND org_id = ? AND app_id = ?", id, orgid, appid).Find(&role).Error
	return role, err
}

func GetInformationData(limit int64, page int64, orgId int64) (information []*models.DeviceInformations, total int64, err error) {
	db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_patients as p")
	fmt.Println("table", table)
	dbs := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("dbs", dbs)
	offset := (page - 1) * limit
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	err = db.Group("x.id").Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,p.name,r.user_name").Count(&total).Joins("Left Join sgj_xt.xt_patients as p on p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Order("x.ctime desc").Offset(offset).Limit(limit).Scan(&information).Error
	if err != nil {

		return
	}
	return
}

func GetOrgName(orgid int64) (models.Org, error) {
	org := models.Org{}
	err := UserReadDB().Where("id= ? AND status = 1", orgid).Find(&org).Error
	return org, err
}

func CreateCulture(culture *models.DeviceCulture) error {

	err := writeUserDb.Create(&culture).Error
	return err
}

func CreateDialysate(dialysate *models.DeviceDialysate) error {

	err := writeUserDb.Create(&dialysate).Error
	return err
}

func CreateIon(ion *models.DeviceIon) error {

	err := writeUserDb.Create(&ion).Error
	return err
}

func GetAllCulture(orgId int64) (cultures []*models.DeviceCultures, err error) {

	db := UserReadDB().Table("xt_device_culture as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	err = db.Group("x.id").Select("x.id,x.speling_date,x.specimen,x.concentrate_noa,x.concentrate_nob,x.sampling_locationa,x.detection_unit,x.sampler,x.reporting_date,x.detection_result,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sampler").Scan(&cultures).Error
	return cultures, err
}

func GetAllDialysate(orgId int64) (dialysate []*models.DeviceDialysates, err error) {
	db := UserReadDB().Table("xt_device_dialysate as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	err = db.Group("x.id").Select("x.id,x.sampling_date,x.specimenb,x.concentrate_noc,x.concentrateb_nod,x.sampling_locationb,x.detection_unit,x.samplerb,x.reporting_dateb,x.detection_resultb,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.samplerb").Scan(&dialysate).Error

	return dialysate, err
}

func GetAllDeviceIon(orgId int64) (ions []*models.DeviceIons, err error) {
	db := UserReadDB().Table("xt_device_ion as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	err = db.Group("x.id").Select("x.id,x.sampling_date,x.samplerc,x.detection_unit,x.concentrate_nof,x.concentrate_nog,x.date_reportc,x.actual_na,x.actual_pna,x.actual_k,x.actual_ca,x.actual_ci,x.actual_hco,x.actual_mg,x.actual_ph,x.remakes,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.samplerc").Scan(&ions).Error
	return ions, err
}

func GetCultureById(id int64) (models.DeviceCulture, error) {
	culture := models.DeviceCulture{}
	err := UserReadDB().Model(&culture).Where("id=? AND status = 1", id).Find(&culture).Error
	return culture, err
}

func GetSampler(id int64) (models.App_Role, error) {
	role := models.App_Role{}
	err := UserReadDB().Model(&role).Where("id= ? AND status =1", id).Find(&role).Error
	return role, err
}

func UpdateCulture(id int64, orgid int64, culture *models.DeviceCulture) error {

	err := writeUserDb.Model(&culture).Where("id= ? AND user_org_id = ? AND status = ?", id, orgid, 1).Updates(map[string]interface{}{"speling_date": culture.SpelingDate, "specimen": culture.Specimen, "concentrate_noa": culture.ConcentrateNoa, "concentrate_nob": culture.ConcentrateNob, "sampling_locationa": culture.SamplingLocationa, "detection_unit": culture.DetectionUnit, "sampler": culture.Sampler, "reporting_date": culture.ReportingDate, "detection_result": culture.DetectionResult, "mtime": time.Now().Unix()}).Error
	return err
}

func DeleteCultrues(id int64) (err error) {

	err = UserWriteDB().Model(models.DeviceCulture{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return
}

func DeleteCultrue(orgid int64, ids []int64) (err error) {
	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DeviceCulture{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DeviceCulture{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return
}

func GetDialystate(id int64) (models.DeviceDialysate, error) {

	dialysate := models.DeviceDialysate{}
	err := readUserDb.Where("id= ? AND status = 1", id).Find(&dialysate).Error
	return dialysate, err
}

func Updatedialystate(id int64, orgid int64, dialysate *models.DeviceDialysate) error {

	err := writeUserDb.Model(&dialysate).Where("id=? AND user_org_id = ? AND status = 1", id, orgid).Updates(map[string]interface{}{"sampling_date": dialysate.SamplingDate, "specimenb": dialysate.Specimenb, "concentrate_noc": dialysate.ConcentrateNoc, "concentrateb_nod": dialysate.ConcentratebNod, "sampling_locationb": dialysate.SamplingLocationb, "detection_unit": dialysate.DetectionUnit, "samplerb": dialysate.Samplerb, "reporting_dateb": dialysate.ReportingDateb, "detection_resultb": dialysate.DetectionResultb, "mtime": time.Now().Unix()}).Error
	return err
}

func DeleteDialystates(id int64) (err error) {

	err = UserWriteDB().Model(&models.DeviceDialysate{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return

}

func DeleteDialystate(orgid int64, ids []int64) (err error) {
	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DeviceDialysate{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DeviceDialysate{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return
}

func GetIon(id int64) (models.DeviceIon, error) {

	ion := models.DeviceIon{}
	err := UserReadDB().Model(&ion).Where("id = ? AND status = 1", id).Find(&ion).Error
	return ion, err
}

func UpdateIon(id int64, orgid int64, ion *models.DeviceIon) error {

	err := writeUserDb.Model(&ion).Where("id = ? AND user_org_id = ? AND status = 1", id, orgid).Updates(map[string]interface{}{"sampling_date": ion.SamplingDate, "samplerc": ion.Samplerc, "detection_unit": ion.DetectionUnit, "concentrate_nof": ion.ConcentrateNof, "concentrate_nog": ion.ConcentrateNog, "date_reportc": ion.DateReportc, "actual_na": ion.ActualNa, "actual_pna": ion.ActualPna, "actual_k": ion.ActualK, "actual_ca": ion.ActualCa, "actual_ci": ion.ActualCi, "actual_hco": ion.ActualCi, "actual_mg": ion.ActualMg, "actual_ph": ion.ActualPh, "remakes": ion.Remakes, "mtime": time.Now().Unix()}).Error
	return err
}

func DeleteIons(id int64) (err error) {

	err = UserWriteDB().Model(&models.DeviceIon{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return
}

func DeleteIon(orgid int64, ids []int64) (err error) {
	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DeviceIon{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DeviceIon{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return
}

func GetCultureData(bedid int64, start int64, end int64, orgId int64) (cultures []*models.DeviceCultures, err error) {
	db := UserReadDB().Table("xt_device_culture as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if bedid > 0 {
		db = db.Where("x.bed_id = ?", bedid)
	}
	if start > 0 {
		db = db.Where("x.speling_date >= ?", start)
	}
	if end > 0 {
		db = db.Where("x.speling_date <= ?", end)
	}
	err = db.Group("x.id").Select("x.id,x.speling_date,x.specimen,x.concentrate_noa,x.concentrate_nob,x.sampling_locationa,x.detection_unit,x.sampler,x.reporting_date,x.detection_result,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sampler").Scan(&cultures).Error
	return cultures, err
}

func GetDialysateData(bedid int64, start int64, end int64, orgId int64) (dialysate []*models.DeviceDialysates, err error) {
	db := UserReadDB().Table("xt_device_dialysate as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if bedid > 0 {
		db = db.Where("x.bed_id = ?", bedid)
	}
	if start > 0 {
		db = db.Where("x.sampling_date >= ?", start)
	}
	if end > 0 {
		db = db.Where("x.sampling_date <= ?", end)
	}

	err = db.Group("x.id").Select("x.id,x.sampling_date,x.specimenb,x.concentrate_noc,x.concentrateb_nod,x.sampling_locationb,x.detection_unit,x.samplerb,x.reporting_dateb,x.detection_resultb,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.samplerb").Scan(&dialysate).Error

	return dialysate, err
}

func GetDeviceIonData(bedid int64, start int64, end int64, orgId int64) (ions []*models.DeviceIons, err error) {
	db := UserReadDB().Table("xt_device_ion as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("table", table)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if bedid > 0 {
		db = db.Where("x.bed_id = ?", bedid)
	}
	if start > 0 {
		db = db.Where("x.sampling_date >= ?", start)
	}
	if end > 0 {
		db = db.Where("x.sampling_date <= ?", end)
	}
	err = db.Group("x.id").Select("x.id,x.sampling_date,x.samplerc,x.detection_unit,x.concentrate_nof,x.concentrate_nog,x.date_reportc,x.actual_na,x.actual_pna,x.actual_k,x.actual_ca,x.actual_ci,x.actual_hco,x.actual_mg,x.actual_ph,x.remakes,x.bed_id,x.bed,r.user_name").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.samplerc").Scan(&ions).Error
	return ions, err
}

func CreateRepair(repair *models.DeviceRepair) error {

	err = writeUserDb.Create(&repair).Error
	return err
}

func GetAllRepair(orgid int64, limit int64, page int64) (repair []*models.DeviceRepairs, total int64, err error) {

	db := UserReadDB().Table("xt_device_repair as r").Where("r.status = ?", 1)
	table := XTReadDB().Table("xt_device_addmacher as x")
	offset := (page - 1) * limit
	fmt.Print("table", table)
	if orgid > 0 {
		db = db.Where("r.user_org_id = ?", orgid)
	}
	err = db.Count(&total).Select("r.id,r.guarantee_date,r.start_time,r.arrive_time,r.finish_time,r.total_distance,r.failure_stage,r.fault_description,r.cause_analysis,r.treatment_process,r.images,r.exclude,r.reason,r.ctime,r.mtime,r.status,r.user_org_id,r.bed_id,r.equitment_id,r.code_information,x.bed_number").Joins("Left join xt_device_addmacher as x on x.id = r.equitment_id").Offset(offset).Limit(limit).Scan(&repair).Error

	//	err = UserReadDB().Where("user_org_id = ? AND status = 1", orgid).Find(&repair).Error
	return repair, total, err
}

func EditRepair(id int64) (models.DeviceRepair, error) {
	repair := models.DeviceRepair{}
	err := UserReadDB().Where("id = ? AND status = 1", id).Find(&repair).Error
	return repair, err
}

func UpdateRepair(id int64, orgid int64, repair *models.DeviceRepair) error {

	err := writeUserDb.Model(&repair).Where("id=? AND user_org_id = ? AND status = 1", id, orgid).Updates(map[string]interface{}{"guarantee_date": repair.GuaranteeDate, "start_time": repair.StartTime, "arrive_time": repair.ArriveTime, "finish_time": repair.FinishTime, "total_distance": repair.TotalDistance, "failure_stage": repair.FailureStage, "fault_description": repair.FaultDescription, "cause_analysis": repair.CauseAnalysis, "treatment_process": repair.TreatmentProcess, "images": repair.Images, "exclude": repair.Exclude, "reason": repair.Reason, "code_information": repair.CodeInformation, "image_name": repair.ImageName, "mtime": time.Now().Unix()}).Error
	return err
}

func DeleteRepairs(id int64) (err error) {

	err = UserWriteDB().Model(models.DeviceRepair{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return
}

func DeleteRepair(orgid int64, ids []int64) (err error) {
	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DeviceRepair{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DeviceRepair{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return

}

func GetRepair(bedid int64, start int64, end int64, orgid int64) (repair []*models.DeviceRepairs, err error) {

	db := UserReadDB().Table("xt_device_repair as r").Where("r.status = 1")
	sb := UserReadDB().Table("xt_device_addmacher as x")
	fmt.Print("sb", sb)
	if orgid > 0 {
		db = db.Where("r.user_org_id = ?", orgid)
	}
	if bedid > 0 {
		db = db.Where("r.bed_id = ?", bedid)
	}

	if start > 0 {
		db = db.Where("r.guarantee_date >= ?", start)
	}
	if end > 0 {
		db = db.Where("r.guarantee_date <= ?", end)
	}
	//err = db.Model(&repair).Find(&repair).Error
	err = db.Select("r.id,r.guarantee_date,r.start_time,r.arrive_time,r.finish_time,r.total_distance,r.failure_stage,r.fault_description,r.cause_analysis,r.treatment_process,r.images,r.exclude,r.reason,r.ctime,r.mtime,r.status,r.user_org_id,r.bed_id,r.equitment_id,r.code_information,x.bed_number").Joins("Left join xt_device_addmacher as x on x.id = r.equitment_id").Scan(&repair).Error

	return repair, err
}

func GetUserInformation(id int64) (models.DeviceInformation, error) {
	information := models.DeviceInformation{}
	err := UserReadDB().Where("id = ? AND status = 1", id).Find(&information).Error
	return information, err
}

func GetPatientInfoMation(patieintid int64) (models.Patients, error) {
	patients := models.Patients{}
	err := XTReadDB().Where("id = ? AND status = 1", patieintid).Find(&patients).Error
	return patients, err
}

func DeleteUserLogin(id int64) (err error) {

	err = UserWriteDB().Model(&models.DeviceInformation{}).Where("id=?", id).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	return
}

func DeleteForm(orgid int64, ids []int64) (err error) {
	if len(ids) == 1 {
		err = UserWriteDB().Model(&models.DeviceInformation{}).Where("id=? and user_org_id = ?", ids[0], orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	} else {
		err = UserWriteDB().Model(models.DeviceInformation{}).Where("id IN(?) and user_org_id = ?", ids, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
	}

	return
}

func GetLastInformationdata(eid int64, startdate int64, orgid int64) (models.DeviceInformation, error) {
	information := models.DeviceInformation{}
	err := UserReadDB().Model(&information).Where("equiment_id = ? and date = ? and user_org_id = ? and status = 1", eid, startdate, orgid).Last(&information).Error
	return information, err
}

func UpdateAddMacherBedID(id int64, orgid int64, addmacher *models.DeviceAddmacher) error {

	err := UserWriteDB().Model(&addmacher).Where("id=? and user_org_id = ? and status =1", id, orgid).Update(map[string]interface{}{"bed_id": addmacher.BedId, "mtime": addmacher.Mtime}).Error
	return err
}

func UpdatedZoneID(bedid int64, orgid int64, number *models.DeviceNumber) error {

	err := XTWriteDB().Model(&number).Where("id=? and org_id = ?", bedid, orgid).Update(map[string]interface{}{"zone_id": number.ZoneID, "mtime": time.Now().Unix()}).Error
	return err
}

func UpadateForm(id int64, orgid int64, infor *models.DeviceInformation) error {

	err := UserWriteDB().Model(&infor).Where("id = ? AND user_org_id = ? AND status = 1", id, orgid).Updates(map[string]interface{}{"date": infor.Date, "class": infor.Class, "zone": infor.Zone, "bed_number": infor.BedNumber, "contagion": infor.Contagion, "dialysis_mode": infor.DialysisMode, "start_time": infor.StartTime, "end_time": infor.EndTime, "dialysis_hour": infor.DialysisHour, "hyperfiltratio": infor.Hyperfiltratio, "weight_loss": infor.WeightLoss, "warning_value": infor.WarningValue, "user_total": infor.UserTotal, "move": infor.Move, "failure_stage": infor.FailureStage, "fault_description": infor.FaultDescription, "code_information": infor.CodeInformation, "disinfect_type": infor.DisinfectType, "disinfectant_type": infor.DisinfectType, "disinfection": infor.Disinfection, "machine_run": infor.MachineRun, "fluid_path": infor.FluidPath, "disinfectant": infor.Disinfectant, "disinfection_status": infor.DisinfectionStatus, "disinfection_residue": infor.DisinfectionResidue, "long_time": infor.LongTime, "disinfec_startime": infor.DisinfecStartime, "disinfec_endtime": infor.DisinfecEndtime, "dialysis_checked": infor.DialysisChecked, "dialysis_name": infor.DialysisName, "norms": infor.Norms, "dialysis_concentration": infor.DialysisConcentration,
		"germ_checked": infor.GermChecked, "germ_name": infor.GermName, "germ_number": infor.GermNumber, "clean": infor.Clean, "sign_name": infor.SignName, "bed": infor.Bed, "patient_id": infor.PatientId, "mtime": time.Now().Unix()}).Error
	return err
}

func QueryInfo(zone int64, bed int64, start int64, end int64, orgId int64, limit int64, page int64) (infor []*models.DeviceInformations, total int64, err error) {
	db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_patients as p")
	fmt.Println("table", table)
	dbs := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("dbs", dbs)
	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	if zone > 0 {
		db = db.Where("x.zone = ?", zone)
	}
	if bed > 0 {
		db = db.Where("x.bed_number = ?", bed)
	}
	if start > 0 {
		db = db.Where("x.date >= ?", start)
	}
	if end > 0 {
		db = db.Where("x.date <= ?", end)
	}
	offset := (page - 1) * limit

	err = db.Group("x.id").Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,x.bed,p.name,r.user_name").Count(&total).Joins("Left Join sgj_xt.xt_patients as p on p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Order("x.ctime desc").Offset(offset).Limit(limit).Scan(&infor).Error
	if err != nil {

		return
	}
	return
}

func GetPatientID(bedid int64, orgId int64, nowtime int64) (dialysis []*models.DialysisOrder, err error) {

	err = XTReadDB().Model(&dialysis).Where("bed_id = ? AND user_org_id = ? AND dialysis_date = ?", bedid, orgId, nowtime).Find(&dialysis).Error

	return dialysis, err
}

//func GetAllEquitType(orgId int64) (addmacher []*models.DeviceAddmacher, err error) {
//
//	db := UserReadDB().Table("xt_device_addmacher as a").Where("a.status = 1")
//	if orgId > 0 {
//		db = db.Where("a.user_org_id = ?", orgId)
//	}
//	err = db.Group("a.unit_type").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.zone_id,a.bed_id").Where("a.device_type <> 2 AND a.device_type <> 3").Scan(&addmacher).Error
//	return addmacher, err
//}

func GetAllEquitType(orgid int64) (equiment []*models.DeviceEquimentname, err error) {

	//err = UserReadDB().Raw("select  equitment_name,id,user_org_id,equitment_id from xt_device_equimentname where user_org_id = ? GROUP BY equitment_name ",orgid).Scan(&equiment).Error
	//err = UserReadDB().Raw("SELECT e.id,e.equitment_name,e.user_org_id,e.equitment_id FROM xt_device_equimentname as e LEFT JOIN xt_device_addmacher as a ON a.id = e.equitment_id WHERE  a.status = 1 AND a.device_type <> 2  AND a.device_type <> 3  AND e.user_org_id = ? GROUP BY equitment_name", orgid).Scan(&equiment).Error
	//err = UserReadDB().Where("user_org_id = ? and status =1", orgid).Find(&equiment).Error
	err = UserReadDB().Raw("select  x.equitment_name,x.id,x.user_org_id,x.equitment_id,x.bed_id from xt_device_equimentname as x where x.user_org_id = ? and x.status = ? GROUP BY x.equitment_name", orgid, 1).Scan(&equiment).Error
	return equiment, err
}

func GetAllEquitName(orgid int64) (equiment []*models.DeviceEquimentname, err error) {
	err = UserReadDB().Raw("select id,equitment_name,status,ctime,mtime,user_org_id,equitment_id from xt_device_equimentname  as e Where EXISTS (select id from xt_device_addmacher as a where a.id = e.equitment_id and a.status = 1) AND e.user_org_id = ? AND e.status = 1 ", orgid).Scan(&equiment).Error
	return equiment, err
}

func GetUserForm(id int64, orgId int64, limit int64, page int64) (infor []*models.DeviceInformations, total int64, err error) {

	db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	table := XTReadDB().Table("xt_patients as p")
	fmt.Println("table", table)
	dbs := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println("dbs", dbs)
	offset := (page - 1) * limit

	if id > 0 {
		db = db.Where("x.equiment_id = ?", id)
	}

	if orgId > 0 {
		db = db.Where("x.user_org_id = ?", orgId)
	}
	err = db.Group("x.id").Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,x.bed,p.name,r.user_name").Count(&total).Joins("Left Join sgj_xt.xt_patients as p on p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Offset(offset).Limit(limit).Scan(&infor).Error
	if err != nil {

		return
	}
	return
}

func GetBedNumber(id int64, orgid int64) (models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Where("id= ? AND user_org_id = ?", id, orgid).Find(&addmacher).Error

	return addmacher, err
}

func GetNumbers(id int64, orgid int64) (models.DeviceNumber, error) {
	number := models.DeviceNumber{}
	err := XTReadDB().Where("id = ? AND org_id = ?", id, orgid).Find(&number).Error
	return number, err
}

func GetZoneForm(id int64) (models.DeviceAddmacher, error) {
	macher := models.DeviceAddmacher{}
	err := UserReadDB().Where("id=? AND status = 1", id).Find(&macher).Error
	return macher, err
}

func GetBedForm(id int64) (number []*models.DeviceNumber, err error) {

	err = XTReadDB().Where("zone_id = ? AND status = 1", id).Find(&number).Error
	return number, err
}

func GetTotalCount(orgid int64) (repair []*models.DeviceRepair, total int64, err error) {
	err = UserReadDB().Model(&repair).Where("user_org_id = ? and status = 1", orgid).Find(&repair).Count(&total).Error
	return repair, total, err
}

func GetTotalNumber(id int64, orgid int64) (total int64, err error) {
	var device models.DeviceInformation
	err = UserReadDB().Model(&device).Where("equiment_id = ? AND user_org_id = ? AND status = 1", id, orgid).Find(&device).Count(&total).Error
	return total, err
}

func GetTimeWarning(equitid int64, orgId int64) (models.DeviceInformation, error) {
	//fmt.Print("equitid是什么码字--------------------------------------------------------------------",equitid)
	information := models.DeviceInformation{}
	err = UserReadDB().Where(" user_org_id = ? AND status = 1 AND equiment_id = ?  AND (dialysis_checked = 1 or dialysis_checked = 0)", orgId, equitid).Last(&information).Error
	return information, err
}

func GetTimeLast(equitid int64, orgId int64) (models.DeviceInformation, error) {

	information := models.DeviceInformation{}
	err := UserReadDB().Model(&information).Where("equiment_id = ? AND user_org_id = ? AND status = 1 AND (germ_checked = 1 or germ_checked = 0)", equitid, orgId).Last(&information).Error
	return information, err
}

func GetTimeLastData(equitid int64, orgId int64) (models.DeviceInformation, error) {

	information := models.DeviceInformation{}
	err := UserReadDB().Model(&information).Where("equiment_id = ? AND user_org_id = ? AND status = 1 AND (clean = 1 or clean = 0)", equitid, orgId).Last(&information).Error
	return information, err
}

func GetAllpatient(orgid int64) (patients []*models.Patients, err error) {
	err = XTReadDB().Where("user_org_id = ?", orgid).Find(&patients).Error
	return patients, err
}

//func GetInformation(id int64, orgid int64) (*models.DeviceInformation, error) {
////	var information models.DeviceInformation
////	var err error
////	err = UserReadDB().Model(&information).Where("id = ? and user_org_id = ? and status = ?", id, orgid, 1).Find(&information).Error
////	fmt.Print("", err)
////	if err == gorm.ErrRecordNotFound {
////		return nil, err
////	}
////	if err != nil {
////		return nil, err
////	}
////	return &information, nil
////}

func GetInformation(eid int64, startdate int64, orgid int64) (*models.DeviceInformation, error) {
	var information models.DeviceInformation
	var err error
	err = UserReadDB().Model(&information).Where("equiment_id = ? and user_org_id = ? and status = ? and date = ? ", eid, orgid, 1, startdate).Find(&information).Error
	fmt.Print("", err)
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &information, nil
}

func ChangeBed(id int64, org int64) (number []*models.DeviceNumber, err error) {

	err = XTReadDB().Model(&number).Where("zone_id = ? AND status = 1 AND org_id = ? ", id, org).Find(&number).Error

	return number, err
}

func GetPatientDetail(id int64, orgid int64) (models.Patients, error) {
	patients := models.Patients{}
	err := XTReadDB().Where("id=? and user_org_id = ?", id, orgid).Find(&patients).Error
	return patients, err
}

func GetRemanderData(orgid int64) (remander models.DeviceRemander, err error) {

	err = UserReadDB().Model(&models.DeviceRemander{}).Where("user_org_id = ? and status = 1", orgid).Find(&remander).Error
	return
}

func CreateRemander(remander *models.DeviceRemander) (err error) {

	err = UserWriteDB().Create(&remander).Error
	return
}

func UpdateRemander(remander *models.DeviceRemander) (err error) {

	err = UserWriteDB().Save(&remander).Error
	return
}

func GetMode(mode string, orgid int64) (*models.DeviceMode, error) {
	var information models.DeviceMode
	var err error
	err = UserReadDB().Model(&information).Where("device_mode = ? and user_org_id = ? and status = ?", mode, orgid, 1).Find(&information).Error
	fmt.Print("", err)
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &information, nil
}

func SaveMode(mode *models.DeviceMode) (err error) {
	err = UserWriteDB().Save(&mode).Error
	return
}

func GetAllMode(orgid int64) (mode []*models.DeviceMode, err error) {
	err = UserReadDB().Where("user_org_id = ? and status = ?", orgid, 1).Find(&mode).Error
	return mode, err
}

func GetModeById(id int64) (models.DeviceMode, error) {
	mode := models.DeviceMode{}
	err := UserReadDB().Where("id = ?", id).Find(&mode).Error
	return mode, err
}

func UpdateMode(id int64, mode models.DeviceMode) error {

	err := UserWriteDB().Model(&mode).Where("id=?", id).Update(map[string]interface{}{"device_mode": mode.DeviceMode, "mtime": time.Now().Unix()}).Error
	return err
}

func QueryDeviceMode(id int64, orgid int64) (*models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	var err error
	err = UserReadDB().Model(&addmacher).Where("unit_type = ? and user_org_id = ?", id, orgid).Find(&addmacher).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &addmacher, nil
}

func DeleteMode(id int64) error {
	err := UserWriteDB().Model(models.DeviceMode{}).Where("id=?", id).Update(map[string]interface{}{"status": 0}).Error

	return err
}

func SelectChange(id int64, orgid int64) (number []*models.DeviceNumber, err error) {
	//err = XTReadDB().Where("zone_id = ? and org_id = ? and status = ?", id, orgid, 1).Find(&number).Error
	db := XTReadDB().Table("xt_device_number as x").Where("x.status = ?", 1)
	err = db.Select("org_id,number,group_id,zone_id as id").Where("zone_id = ? and org_id = ?", id, orgid).Find(&number).Error
	return number, err
}

func SelectBed(id int64, orgid int64) (models.DeviceNumber, error) {
	number := models.DeviceNumber{}
	err := XTReadDB().Where("id = ? and org_id = ?", id, orgid).Find(&number).Error
	return number, err
}

func GetTimeData(equitid int64, orgid int64, timenow int64) (information []*models.DeviceInformation, err error) {
	//db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	//err = db.Raw("select id,date,class,zone,bed_number,patient_id,contagion,dialysis_mode,start_time,end_time,dialysis_hour,hyperfiltratio,weight_loss,warning_value,user_total,move,failure_stage,fault_description,code_information,disinfect_type,disinfectant_type,disinfection,machine_run,fluid_path,disinfectant,disinfection_status,disinfection_residue,long_time,disinfec_startime,disinfec_endtime,dialysis_checked,dialysis_name,norms,dialysis_concentration,germ_checked,germ_name,germ_number,clean,sign_name,status,ctime,mtime,user_org_id,equiment_id,bed,stime from xt_device_information where DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= ? and equiment_id = ? and user_org_id = ?",timenow,equitid, orgid).Error
	day := time.Now().Day()
	oldMonth := day - 30
	t := time.Date(time.Now().Year(), time.Now().Month(), oldMonth, time.Now().Hour(), time.Now().Minute(), time.Now().Second(), time.Now().Nanosecond(), time.Local)

	err = UserReadDB().Model(&information).Where("date>= ? and date <= ? and equiment_id = ? and user_org_id = ? and dialysis_checked = 1 ", t.Unix(), timenow, equitid, orgid).Find(&information).Error
	return information, err
}

func GetTimeTwo(equitid int64, orgid int64, timenow int64) (information []*models.DeviceInformation, err error) {
	//db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	//err = db.Raw("select id,date,class,zone,bed_number,patient_id,contagion,dialysis_mode,start_time,end_time,dialysis_hour,hyperfiltratio,weight_loss,warning_value,user_total,move,failure_stage,fault_description,code_information,disinfect_type,disinfectant_type,disinfection,machine_run,fluid_path,disinfectant,disinfection_status,disinfection_residue,long_time,disinfec_startime,disinfec_endtime,dialysis_checked,dialysis_name,norms,dialysis_concentration,germ_checked,germ_name,germ_number,clean,sign_name,status,ctime,mtime,user_org_id,equiment_id,bed,stime from xt_device_information where DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= ? and equiment_id = ? and user_org_id = ?",timenow,equitid, orgid).Error
	day := time.Now().Day()
	oldMonth := day - 30
	t := time.Date(time.Now().Year(), time.Now().Month(), oldMonth, time.Now().Hour(), time.Now().Minute(), time.Now().Second(), time.Now().Nanosecond(), time.Local)
	err = UserReadDB().Model(&information).Where("date >= ? and date<= ? and equiment_id = ? and user_org_id = ? and germ_checked = 1 ", t.Unix(), timenow, equitid, orgid).Find(&information).Error
	return information, err
}

func GetTimeThree(equitid int64, orgid int64, timenow int64) (information []*models.DeviceInformation, err error) {
	//db := UserReadDB().Table("xt_device_information as x").Where("x.status = 1")
	//err = db.Raw("select id,date,class,zone,bed_number,patient_id,contagion,dialysis_mode,start_time,end_time,dialysis_hour,hyperfiltratio,weight_loss,warning_value,user_total,move,failure_stage,fault_description,code_information,disinfect_type,disinfectant_type,disinfection,machine_run,fluid_path,disinfectant,disinfection_status,disinfection_residue,long_time,disinfec_startime,disinfec_endtime,dialysis_checked,dialysis_name,norms,dialysis_concentration,germ_checked,germ_name,germ_number,clean,sign_name,status,ctime,mtime,user_org_id,equiment_id,bed,stime from xt_device_information where DATE_SUB(CURDATE(), INTERVAL 30 DAY) <= ? and equiment_id = ? and user_org_id = ?",timenow,equitid, orgid).Error
	day := time.Now().Day()
	oldMonth := day - 30
	t := time.Date(time.Now().Year(), time.Now().Month(), oldMonth, time.Now().Hour(), time.Now().Minute(), time.Now().Second(), time.Now().Nanosecond(), time.Local)
	err = UserReadDB().Model(&information).Where("date >= ? and date <= ?  and equiment_id = ? and user_org_id = ? and clean = 1 ", t.Unix(), timenow, equitid, orgid).Find(&information).Error
	return information, err
}

func DeleteImages(id int64) error {
	repair := models.DeviceRepair{}
	err := UserWriteDB().Model(&repair).Where("id=?", id).Update(map[string]interface{}{"images": "", "image_name": ""}).Error
	return err
}