XT_New/service/device_service.go

package service

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

//////// 设备基本信息

func GetValidDevicesBy(orgID int64, deviceType int, zoneID int64) ([]*models.Device, error) {
	var devices []*models.Device
	db := readDb.Model(&models.Device{}).Where("org_id = ? AND status = 1", orgID)
	if deviceType != 0 {
		db = db.Where("device_type = ?", deviceType)
	}
	if zoneID != 0 {
		db = db.Where("device_zone_id = ?", zoneID)
	}
	err := db.Find(&devices).Error
	if err != nil {
		return nil, err
	}
	return devices, nil
}

// 根据设备关联表的 id，获取设备关联信息
func GetDeviceByID(orgID int64, deviceID int64) (*models.Device, error) {
	var device models.Device
	err := readDb.Model(&models.Device{}).Where("org_id = ? AND id = ?", orgID, deviceID).First(&device).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &device, nil
}

func GetDMDeviceByID(orgID int64, id int64) (*models.DeviceDM, error) {
	var device models.DeviceDM
	err := readDb.Model(&models.DeviceDM{}).Where("org_id = ? AND id = ?", orgID, id).First(&device).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &device, nil
}

func GetWTEDeviceByID(orgID int64, id int64) (*models.DeviceWTE, error) {
	var device models.DeviceWTE
	err := readDb.Model(&models.DeviceWTE{}).Where("org_id = ? AND id = ?", orgID, id).First(&device).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &device, nil
}

// type DeviceBaseInfoViewModel struct {
// 	DeviceType     int   `json:"device_type"`
// 	DeviceNumberID int64 `gorm:"column:device_number_id" json:"device_number_id"`

// 	ID                 int64  `gorm:"column:id" json:"id"`
// 	SerialNumber       string `json:"serial_number"`        // 序列号
// 	Name               string `json:"name"`                 // 设备名
// 	Manufacturer       string `json:"manufacturer"`         // 生产厂家
// 	RepairFactory      string `json:"repair_factory"`       // 维修厂家
// 	Model              string `json:"model"`                // 型号
// 	Department         string `json:"department"`           // 使用科室
// 	DepartmentNumber   string `json:"department_number"`    // 科室编号
// 	PurchaseDate       int64  `json:"purchase_date"`        // 购买日期
// 	InstallDate        int64  `json:"install_date"`         // 安装日期
// 	CommissioningDate  int64  `json:"commissioning_date"`   // 启用日期
// 	Maintainer         string `json:"maintainer"`           // 维修工程师
// 	MaintenanceCall    string `json:"maintenance_call"`     // 维修联系电话
// 	WarrantyPeriod     string `json:"warranty_period"`      // 保修期限
// 	DeviceStatus       int    `json:"device_status"`        // 机器状态 1.使用机 2.备用机 3.急诊机 4.报废机
// 	InitialUseTimes    int    `json:"initial_use_times"`    // 初始使用次数
// 	Mark               string `json:"mark"`                 // 备注
// 	RetirementDate     int64  `json:"retirement_date"`      // 报废日期
// 	RetirementReason   string `json:"retirement_reason"`    // 报废原因
// 	ServiceLife        int    `json:"service_life"`         // 使用年限
// 	WorkingTime        int    `json:"working_time"`         // 工作时长
// 	TreatmentMode      string `json:"treatment_mode"`       // 治疗模式  DeviceType = 1
// 	ReverseOsmosisMode int    `json:"reverse_osmosis_mode"` // 反渗模式  DeviceType = 2
// }

// // TODO
// func GetDeviceBaseInfoByDeviceID(deviceID int64) (*DeviceBaseInfoViewModel, error) {
// 	return nil, nil
// }

// 创建透析机
func CreateDMDevice(dmDevice *models.DeviceDM, deviceNumber *models.DeviceNumber) (*models.Device, error) {
	now := time.Now().Unix()
	dmDevice.Status = 1
	dmDevice.CreateTime = now
	dmDevice.ModifyTime = now
	tx := writeDb.Begin()
	createDMErr := tx.Model(&models.DeviceDM{}).Create(dmDevice).Error
	if createDMErr != nil {
		tx.Rollback()
		return nil, createDMErr
	}
	device := models.Device{
		OrgID:        dmDevice.OrgID,
		DeviceType:   1,
		DMID:         dmDevice.ID,
		SerialNumber: dmDevice.SerialNumber,
		Name:         dmDevice.Name,
		Model:        dmDevice.Model,
		Status:       1,
		CreateTime:   now,
		ModifyTime:   now,
	}
	if deviceNumber != nil {
		device.DeviceNumber = deviceNumber.Number
		device.DeviceNumberID = deviceNumber.ID
		device.DeviceZoneID = deviceNumber.ZoneID
		device.DeviceGroupID = deviceNumber.GroupID
	}
	createDeviceErr := tx.Model(&models.Device{}).Create(&device).Error
	if createDeviceErr != nil {
		tx.Rollback()
		return nil, createDeviceErr
	}
	tx.Commit()
	return &device, nil
}

// 创建水处理机
func CreateWTEDevice(wteDevice *models.DeviceWTE, deviceNumber *models.DeviceNumber) (*models.Device, error) {
	now := time.Now().Unix()
	wteDevice.Status = 1
	wteDevice.CreateTime = now
	wteDevice.ModifyTime = now
	tx := writeDb.Begin()
	createWTEErr := tx.Model(&models.DeviceWTE{}).Create(wteDevice).Error
	if createWTEErr != nil {
		tx.Rollback()
		return nil, createWTEErr
	}
	device := models.Device{
		OrgID:        wteDevice.OrgID,
		DeviceType:   2,
		WTEID:        wteDevice.ID,
		SerialNumber: wteDevice.SerialNumber,
		Name:         wteDevice.Name,
		Model:        wteDevice.Model,
		Status:       1,
		CreateTime:   now,
		ModifyTime:   now,
	}
	if deviceNumber != nil {
		device.DeviceNumber = deviceNumber.Number
		device.DeviceNumberID = deviceNumber.ID
		device.DeviceZoneID = deviceNumber.ZoneID
		device.DeviceGroupID = deviceNumber.GroupID
	}
	createDeviceErr := tx.Model(&models.Device{}).Create(&device).Error
	if createDeviceErr != nil {
		tx.Rollback()
		return nil, createDeviceErr
	}
	tx.Commit()
	return &device, nil
}

func UpdateDMDevice(dmDevice *models.DeviceDM, deviceNumber *models.DeviceNumber, device *models.Device) error {
	now := time.Now().Unix()
	tx := writeDb.Begin()
	dmDevice.ModifyTime = now
	updateDMErr := tx.Save(dmDevice).Error
	if updateDMErr != nil {
		tx.Rollback()
		return updateDMErr
	}
	device.SerialNumber = dmDevice.SerialNumber
	device.Name = dmDevice.Name
	device.Model = dmDevice.Model
	if deviceNumber != nil {
		device.DeviceNumberID = deviceNumber.ID
		device.DeviceNumber = deviceNumber.Number
		device.DeviceZoneID = deviceNumber.ZoneID
		device.DeviceGroupID = deviceNumber.GroupID

	} else {
		device.DeviceNumberID = 0
		device.DeviceNumber = ""
		device.DeviceZoneID = 0
		device.DeviceGroupID = 0
	}
	device.ModifyTime = now
	updateDeviceErr := tx.Save(device).Error
	if updateDeviceErr != nil {
		tx.Rollback()
		return updateDeviceErr
	}
	tx.Commit()
	return nil
}

func UpdateWTEDevice(wteDevice *models.DeviceWTE, deviceNumber *models.DeviceNumber, device *models.Device) error {
	now := time.Now().Unix()
	tx := writeDb.Begin()
	wteDevice.ModifyTime = now
	updateWTEErr := tx.Save(wteDevice).Error
	if updateWTEErr != nil {
		tx.Rollback()
		return updateWTEErr
	}
	device.SerialNumber = wteDevice.SerialNumber
	device.Name = wteDevice.Name
	device.Model = wteDevice.Model
	device.DeviceNumberID = deviceNumber.ID
	device.DeviceNumber = deviceNumber.Number
	device.ModifyTime = now
	updateDeviceErr := tx.Save(device).Error
	if updateDeviceErr != nil {
		tx.Rollback()
		return updateDeviceErr
	}
	tx.Commit()
	return nil
}

func UpdateDevice(device *models.Device) error {
	err := writeDb.Save(device).Error
	return err
}

func GetDeviceCountForDeviceNumberID(orgID int64, deviceNumberID int64) (int, error) {
	var count int
	err := readDb.Model(&models.Device{}).Where("device_number_id = ? AND org_id = ? AND status = 1", deviceNumberID, orgID).Count(&count).Error
	if err != nil {
		return 0, err
	}
	return count, nil
}

//////// 分区 Zone

func GetAllValidDeviceZones(orgID int64) ([]*models.DeviceZone, error) {
	var zones []*models.DeviceZone
	err := readDb.Model(&models.DeviceZone{}).Where("org_id = ?", orgID).Find(&zones).Error
	if err != nil {
		return nil, err
	}
	return zones, nil
}

func GetAllValidDeviceZonesOne(orgID int64) ([]*models.DeviceZone, error) {
	var zones []*models.DeviceZone
	err := readDb.Model(&models.DeviceZone{}).Where("org_id = ? and status = 1", orgID).Find(&zones).Error
	if err != nil {
		return nil, err
	}
	return zones, nil
}

func GetDeviceZoneByID(orgID int64, zoneID int64) (*models.DeviceZone, error) {
	var zone models.DeviceZone
	err := readDb.Model(&models.DeviceZone{}).Where("org_id = ? AND id = ?", orgID, zoneID).First(&zone).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &zone, nil
}

func GetZoneByName(name string, orgid int64) (*models.DeviceZone, error) {
	zones := models.DeviceZone{}
	err := XTReadDB().Model(&zones).Where("name = ? and org_id = ? and status = 1", name, orgid).Find(&zones).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}

	return &zones, nil
}

func GetZoneByNameOne(name string, orgid int64) (zone models.DeviceZone, err error) {

	err = XTReadDB().Model(&zone).Where("name = ? and org_id=? and status = 1", name, orgid).First(&zone).Error
	return zone, err
}

func CreateDeviceZone(orgID int64, name string, type_ int) (*models.DeviceZone, error) {
	now := time.Now().Unix()
	zone := models.DeviceZone{
		OrgID:      orgID,
		Name:       name,
		Type:       type_,
		Status:     1,
		CreateTime: now,
		ModifyTime: now,
	}
	err := writeDb.Model(&models.DeviceZone{}).Create(&zone).Error
	if err != nil {
		return nil, err
	}
	return &zone, nil
}

func UpdateDeviceZone(zone *models.DeviceZone) error {
	err := writeDb.Save(zone).Error
	return err
}

//////// 分组 Group

func GetAllValidDeviceGroups(orgID int64) ([]*models.DeviceGroup, error) {
	var groups []*models.DeviceGroup
	err := readDb.Model(&models.DeviceGroup{}).Where("org_id = ? AND status = 1", orgID).Find(&groups).Error
	if err != nil {
		return nil, err
	}
	return groups, nil
}

func GetDeviceGroupByID(orgID int64, groupID int64) (*models.DeviceGroup, error) {
	var group models.DeviceGroup
	err := readDb.Model(&models.DeviceGroup{}).Where("org_id = ? AND id = ?", orgID, groupID).First(&group).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &group, nil
}

func GetDeviceGroupName(name string, orgid int64) (*models.DeviceGroup, error) {
	group := models.DeviceGroup{}
	err := XTReadDB().Model(&group).Where("name = ? and org_id = ? and status =1", name, orgid).Find(&group).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}

	return &group, nil

}

func CreateDeviceGroup(orgID int64, name string) (*models.DeviceGroup, error) {
	now := time.Now().Unix()
	group := models.DeviceGroup{
		OrgID:      orgID,
		Name:       name,
		Status:     1,
		CreateTime: now,
		ModifyTime: now,
	}
	err := writeDb.Model(&models.DeviceGroup{}).Create(&group).Error
	if err != nil {
		return nil, err
	}
	return &group, nil
}

func GetUpdateDeviceGroupByName(name string, orgid int64) (group models.DeviceGroup, err error) {
	err = XTReadDB().Model(&group).Where("name = ? and org_id = ? and status =1", name, orgid).Find(&group).Error
	return group, err
}

func UpdateDeviceGroup(group *models.DeviceGroup) error {
	err := writeDb.Save(group).Error
	return err
}

//////// 机号 Number

type DeviceNumberVM struct {
	ID     int64  `gorm:"column:id" json:"id"`
	OrgID  int64  `gorm:"column:org_id" json:"-"`
	Number string `gorm:"column:number" json:"number"`
	ZoneID int64  `gorm:"column:zone_id" json:"zone_id"`
	Status int64  `gorm:"column:status" json:"status" form:"status"`
}

func (DeviceNumberVM) TableName() string {
	return "xt_device_number"
}

type DeviceNumberViewModel struct {
	DeviceNumberVM
	ZoneName  string              `gorm:"column:zone_name" json:"zone_name"`
	GroupName string              `gorm:"column:group_name" json:"group_name"`
	Zone      models.VMDeviceZone `gorm:"ForeignKey:ZoneID" json:"zone"`
}

func GetAllValidDeviceNumbers(orgID int64) ([]*DeviceNumberViewModel, error) {
	var vms []*DeviceNumberViewModel = make([]*DeviceNumberViewModel, 0)
	rows, err := readDb.Raw("SELECT n.*, z.name as zone_name, g.name as group_name FROM xt_device_number  as n join xt_device_zone as z on z.id = n.zone_id AND z.status = 1 join xt_device_group as g on g.id = n.group_id WHERE (n.org_id = ? AND n.status = 1) order by sort ", orgID).Rows()
	defer rows.Close()
	if err != nil {
		return nil, err
	}
	for rows.Next() {
		var vm DeviceNumberViewModel
		readDb.ScanRows(rows, &vm)
		vms = append(vms, &vm)
	}
	return vms, nil
}

func GetAllBedNumber(orgId int64) (devicenumber []*models.XtDeviceNumber, err error) {

	err = XTReadDB().Raw("select id as bed_id,org_id,number as bed_number,group_id,zone_id from xt_device_number as n Where NOT EXISTS (select id,bed_id from sgj_users.xt_device_addmacher as a where a.bed_id = n.id and a.status = 1) AND n.org_id = ? AND n.status = 1 ", orgId).Scan(&devicenumber).Error
	return devicenumber, err
}

func GetAllBedNumberTwo(orgId int64, id int64) (devicenumber []*models.XtDeviceNumber, err error) {

	err = XTReadDB().Raw("select id as bed_id,org_id,number as bed_number,group_id,zone_id from xt_device_number as n Where NOT EXISTS (select id,bed_id from sgj_users.xt_device_addmacher as a where a.bed_id = n.id and a.status = 1 and a.id <> ?) AND n.org_id = ? AND n.status = 1 ", id, orgId).Scan(&devicenumber).Error
	return devicenumber, err
}

func GetAllMachineByOrgId(orgid int64) (addmacher []*models.DeviceAddmacher, err error) {

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

func GetAllDeviceNumbers(orgID int64, record_date int64, schedule_type int64) ([]*DeviceNumberViewModel, error) {
	var vms []*DeviceNumberViewModel = make([]*DeviceNumberViewModel, 0)
	rows, err := readDb.Raw("SELECT n.*, z.name as zone_name, g.name as group_name FROM xt_device_number as n join xt_device_zone as z on z.id = n.zone_id join xt_device_group as g on g.id = n.group_id  WHERE (n.org_id = ? AND n.status = 1) AND NOT EXISTS (Select * FROM xt_schedule as s, `xt_dialysis_order` as d Where d.`dialysis_date` = ? AND d.`status` = 1 AND d.`patient_id` = s.`patient_id` AND   s.user_org_id = n.org_id AND s.`bed_id` = n.id AND s.`schedule_date` = ? AND s.`schedule_type` = ? AND s.status = 1 )", orgID, record_date, record_date, schedule_type).Rows()
	defer rows.Close()
	if err != nil {
		return nil, err
	}
	for rows.Next() {
		var vm DeviceNumberViewModel
		readDb.ScanRows(rows, &vm)
		vms = append(vms, &vm)
	}
	return vms, nil
}

func GetDeviceNumberByID(orgID int64, numberID int64) (*models.DeviceNumber, error) {
	var number models.DeviceNumber
	err := readDb.Model(&models.DeviceNumber{}).Where("org_id = ? AND id = ? ", orgID, numberID).First(&number).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &number, nil
}

func GetCreateDeviceNumber(num string, orgid int64) (*models.DeviceNumber, error) {
	number := models.DeviceNumber{}
	err := XTReadDB().Model(&number).Where("number = ? and org_id = ? and status = 1", num, orgid).Find(&number).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}

	return &number, nil
}

func CreateDeviceNumber(orgID int64, number string, zoneID int64, groupID int64, sort int64) (*models.DeviceNumber, error) {
	now := time.Now().Unix()
	numberModel := models.DeviceNumber{
		OrgID:      orgID,
		Number:     number,
		ZoneID:     zoneID,
		GroupID:    groupID,
		Status:     1,
		CreateTime: now,
		ModifyTime: now,
		Sort:       sort,
	}
	err := writeDb.Model(&models.DeviceNumber{}).Create(&numberModel).Error
	if err != nil {
		return nil, err
	}
	return &numberModel, nil
}

func GetDeviceNumberByName(num string, zoneId int64, orgid int64) (number models.DeviceNumber, err error) {

	err = XTReadDB().Model(&number).Where("number = ? and zone_id = ? and org_id = ? and status =1", num, zoneId, orgid).First(&number).Error
	return number, err
}

func UpdateDeviceNumber(number *models.DeviceNumber) error {
	now := time.Now().Unix()
	number.ModifyTime = now
	tx := writeDb.Begin()
	updateNumberErr := tx.Save(number).Error
	if updateNumberErr != nil {
		tx.Rollback()
		return updateNumberErr
	}
	updateDeviceErr := tx.Model(&models.Device{}).Where("org_id = ? AND device_number_id = ?", number.OrgID, number.ID).Updates(map[string]interface{}{"device_number": number.Number}).Error
	if updateDeviceErr != nil {
		tx.Rollback()
		return updateDeviceErr
	}
	tx.Commit()
	return nil
}

func GetAddMacherByBedId(bedid int64, user_org_id int64) (*models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Where("bed_id = ? and status = 1 and user_org_id = ?", bedid, user_org_id).Find(&addmacher).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		} else {
			return nil, err
		}
	}
	return &addmacher, nil
}

func UpdateAddmacherByBedId(bedId int64, addmacher models.DeviceAddmacher) error {
	tx := UserWriteDB().Begin()
	err := tx.Model(&addmacher).Where("bed_id = ? and status = 1", bedId).Updates(map[string]interface{}{"zone_id": addmacher.ZoneId}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	tx.Commit()
	return nil
}

func GetDeviceNumberCountForZoneID(orgID int64, zoneID int64) (int, error) {
	var count int
	err := readDb.Model(&models.DeviceNumber{}).Where("zone_id = ? AND org_id = ? AND status = 1", zoneID, orgID).Count(&count).Error
	if err != nil {
		return 0, err
	}
	return count, nil
}

func GetDeviceNumberCountForGroupID(orgID int64, groupID int64) (int, error) {
	var count int
	err := readDb.Model(&models.DeviceNumber{}).Where("group_id = ? AND org_id = ? AND status = 1", groupID, orgID).Count(&count).Error
	if err != nil {
		return 0, err
	}
	return count, nil
}

func GetScheduleCountForDeviceNumber(orgID int64, deviceNumberID int64, beginDate int64) (int, error) {
	var count int
	err := readDb.Model(&models.Schedule{}).Where("bed_id = ? AND user_org_id = ? AND schedule_date >= ? AND status = 1", deviceNumberID, orgID, beginDate).Count(&count).Error
	if err != nil {
		return 0, err
	}
	return count, nil
}

func GetScheduleTemplateItemCountForDeviceNumber(orgID int64, deviceNumberID int64) (int, error) {
	var count int
	err := readDb.Model(&models.PatientScheduleTemplateItem{}).Where("device_number_id = ? AND org_id = ? AND status = 1", deviceNumberID, orgID).Count(&count).Error
	if err != nil {
		return 0, err
	}
	return count, nil
}

func GetZoneId(bednumber int64, orgid int64) (models.DeviceNumber, error) {

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

func GetLastMacherData(orgid int64) (models.DeviceAddmacher, error) {
	addmacher := models.DeviceAddmacher{}
	err := UserReadDB().Model(&addmacher).Where("user_org_id = ? AND status = ?", orgid, 1).Last(&addmacher).Error
	return addmacher, err
}

func AddTreatMode(machineid int64, orgid int64, treatmodes []int64) (err error) {
	utx := XTWriteDB().Begin()
	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 _, contagion := range treatmodes {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, machineid)
			insertData = append(insertData, contagion)
			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 DeleteBedNumber(id int64,orgid int64)(error){
//	//err := writeDb.Model(&models.DeviceNumber{}).Where("id = ? AND org_id = ?", id, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
//	err := writeDb.Model(&models.DeviceNumber{}).Where("id = ? AND org_id = ?", id, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
//
//
//	fmt.Println("错误是什么",err)
//	return  err
//
//}
//
//func DeleteZoneId(id int64,orgid int64)(error)  {
//	err := writeDb.Model(&models.DeviceZone{}).Where("id = ? AND org_id = ?", id, orgid).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
//	return  err
//}

func GetAllMachineInfo(page int64, limit int64, keyword string, zoneid int64, equimentid int64, statusid int64, orgid int64) (addmahcer []*models.DeviceAddmachers, total int64, err error) {

	db := readUserDb.Table("xt_device_addmacher as a").Where("a.status = 1")
	table := XTReadDB().Table("xt_device_zone as x")
	d := readUserDb.Table("xt_device_mode as m")
	d2 := XTReadDB().Table("xt_device_number as n")
	d3 := XTReadDB().Table("xt_device_information as i")
	fmt.Print("d", d)
	fmt.Println("table", table)
	fmt.Print("d2", d2, d3)
	if orgid > 0 {
		db = db.Where("a.user_org_id = ?", orgid)
	}
	if zoneid > 0 {
		db = db.Where("a.zone_id = ?", zoneid)
	}
	if equimentid > 0 {
		db = db.Where("a.device_type = ?", equimentid)
	}
	if statusid > 0 {
		db = db.Where("a.machine_status = ?", statusid)
	}

	if len(keyword) > 0 {
		keyword = "%" + keyword + "%"
		db = db.Where("a.serial_number LIKE ? OR a.device_name LIKE ? OR a.unit_type LIKE ?", keyword, keyword, keyword)
	}

	offset := (page - 1) * limit

	err = db.Group("a.id").Order("a.ctime asc").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.bed_id,x.name,m.device_mode,n.number,i.equiment_id").Count(&total).
		Joins("Left JOIN xt_device_mode as m on m.id = a.unit_type ").Joins("left join sgj_xt.xt_device_number as n on n.id = a.bed_id").Joins("Left JOIN sgj_xt.xt_device_zone as x On x.id = n.zone_id").Joins("left join xt_device_information as i on i.bed_number = a.bed_id").Offset(offset).Limit(limit).Scan(&addmahcer).Error

	if err != nil {

		return
	}
	return
}

func GetAllMachine(zoneid int64, classid int64, deviceid int64, timenow int64, orgid int64) (addmahcer []*models.DeviceAddmachers, err error) {
	fmt.Println("timenow", timenow)
	db := readUserDb.Table("xt_device_addmacher as a").Where("a.status = 1")
	//db := XTReadDB().Table("xt_device_addmacher as a").Where("a.status = 1")
	tab := XTReadDB().Table("xt_schedule as x")
	fmt.Println("tab", tab)
	d := readUserDb.Table("xt_device_mode as m")
	fmt.Print("d", d)
	table := XTReadDB().Table("xt_device_number as n")
	fmt.Print("table", table)
	if orgid > 0 {
		db = db.Where("a.user_org_id = ?", orgid)
	}
	if zoneid > 0 {
		db = db.Where("a.zone_id = ?", zoneid)
	}

	if deviceid > 0 {
		db = db.Where("a.device_type = ?", deviceid)
	}
	if classid > 0 {
		error := db.Joins("LEFT JOIN sgj_xt.xt_schedule as x On x.bed_id = a.bed_id").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Joins("lefj join sgj_xt.xt_device_number as n on n.id = a.bed_id").Where("x.user_org_id = ? AND x.schedule_date = ? AND x.schedule_type = ? AND x.status = ?", orgid, timenow, classid, 1).Order("a.ctime desc").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,d.device_mode,n.number").Find(&addmahcer).Error
		fmt.Println("err", error)
	} else {
		err = db.Order("a.ctime asc").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.bed_id,d.device_mode,n.number").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Joins("left join sgj_xt.xt_device_number as n on n.id = a.bed_id").Find(&addmahcer).Error
		fmt.Println("错误是什么", err)
		if err != nil {

			return
		}
	}
	return
}

func GetMachineDetail(id int64, orgid int64) (models.DeviceAddmachers, error) {
	addmacher := models.DeviceAddmachers{}
	//  //	//err := readUserDb.Model(&addmacher).Where("id = ? AND user_org_id = ? AND status = 1", id, orgid).Find(&addmacher).Error
	db := readUserDb.Table("xt_device_addmacher as a").Where("a.status =1")
	d := readUserDb.Table("xt_device_mode as d")
	fmt.Print("d", d)
	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 as device_mode,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").Joins("left join xt_device_mode as d on d.id = a.unit_type ").Where("a.id = ? and a.user_org_id = ?", id, orgid).Find(&addmacher).Error
	return addmacher, err
}

func GetTreatModel(id int64, orgid int64) (mode []*models.DeviceTreatmentmode, err error) {
	err = XTReadDB().Model(&mode).Where("machine_id = ? AND user_org_id = ? AND status = 1 ", id, orgid).Find(&mode).Error

	return mode, err
}

func GetPatientId(id int64) (models.XtPatientsNew, error) {

	patientsNew := models.XtPatientsNew{}
	err := XTReadDB().Model(&patientsNew).Where("blood_id = ? and status = 1", id).Find(&patientsNew).Error
	return patientsNew, err
}

func GetPatientInfectious(id int64) (infectious []*models.InfectiousDiseases, err error) {

	err = XTReadDB().Where("patient_id=? and status=1", id).Find(&infectious).Error
	return infectious, err
}

func GetPatientIdOne(patient_id int64, orgId int64) (models.XtPatientsNew, error) {

	patientsNew := models.XtPatientsNew{}
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":patient_info"

	patient_info_str, _ := redis.Get(key).Result()

	if len(patient_info_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Model(&models.Patients{}).Where("blood_id = ? and user_org_id=? and status=1", patient_id, orgId).First(&patientsNew).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				return patientsNew, nil
			} else {
				return patientsNew, err
			}
		} else {
			if patientsNew.ID > 0 {
				//缓存数据
				patient_info_json, err := json.Marshal(&patientsNew)

				if err == nil {
					redis.Set(key, patient_info_json, time.Second*60*60*18)
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
			}
			return patientsNew, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map

		if patient_info_str == "null" {
			return patientsNew, nil
		} else {
			json.Unmarshal([]byte(patient_info_str), &patientsNew)
			return patientsNew, nil
		}

	}
}

func GetAllBedNumberSix(orgId int64) (devicenumber []*models.ScheduleDeviceNumber, err error) {

	err = XTReadDB().Where("org_id = ? and status = 1", orgId).Find(&devicenumber).Error
	return devicenumber, err
}

func GetAllBedNumberTen(orgId int64, zone_id int64) (devicenumber []*models.ScheduleDeviceNumber, err error) {

	err = XTReadDB().Where("org_id = ? and status = 1 and zone_id = ?", orgId, zone_id).Find(&devicenumber).Error
	return devicenumber, err
}

func GetAllBedNumberSeven(orgId int64) (devicenumber []*models.SgjDeviceNumber, err error) {

	err = XTReadDB().Where("org_id = ? and status= 1", orgId).Preload("Zone", "status = 1").Find(&devicenumber).Error
	return devicenumber, err
}

func ChangeScheduleById(id int64, mode_id int64) error {

	err := XTWriteDB().Model(&models.XtSchedule{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"mode_id": mode_id}).Error
	fmt.Println("err233322323232232323", err)
	return err
}

func ChangeDialysisSolution(patient_id int64, schedule_date int64, org_id int64, mode_id int64) error {

	err := XTWriteDB().Model(&models.DialysisPrescription{}).Where("patient_id = ? and record_date =? and user_org_id = ? and status = 1", patient_id, schedule_date, org_id).Update(map[string]interface{}{"mode_id": mode_id}).Error
	return err

}

func GetScheduleByClassType(schedule_type int64, schedule_date int64, bed_id int64, user_org_id int64) (models.XtSchedule, error) {
	schedule := models.XtSchedule{}
	err := XTReadDB().Where("schedule_type = ? and schedule_date = ? and bed_id = ? and user_org_id = ? and status = 1", schedule_type, schedule_date, bed_id, user_org_id).Find(&schedule).Error
	return schedule, err
}

func GetPartionId(bed_id int64, org_id int64) (models.XtDeviceNumber, error) {

	number := models.XtDeviceNumber{}
	err = XTReadDB().Where("id = ? and status = 1 and org_id = ?", bed_id, org_id).Find(&number).Error
	return number, err
}

func UpdateScheduleById(id int64, schedule models.Schedule) error {

	err := XTWriteDB().Model(&models.Schedule{}).Where("id = ? and status =1", id).Update(map[string]interface{}{"patient_id": schedule.PatientId, "mode_id": schedule.ModeId}).Error
	return err
}

func GetScheduleTemplateForDeviceNumber(orgID int64, deviceNumberID int64, template_id int64, week_type int64, time_type int64) (models.PatientScheduleTemplateItem, error) {
	var item models.PatientScheduleTemplateItem
	err := readDb.Model(&models.PatientScheduleTemplateItem{}).Where("device_number_id = ? AND org_id = ? AND status = 1 AND template_id = ? AND weekday = ? AND time_type = ?", deviceNumberID, orgID, template_id, week_type, time_type).First(&item).Error
	return item, err
}

//某模板下，某周几下，该床位是否有患者
func GetScheduleTemplateOne(orgID int64, deviceNumberID int64, template_id int64, week_type int64) (models.PatientScheduleTemplateItem, error) {
	var item models.PatientScheduleTemplateItem
	err := readDb.Model(&models.PatientScheduleTemplateItem{}).Where("device_number_id = ? AND org_id = ? AND status = 1 AND template_id = ? AND weekday = ?", deviceNumberID, orgID, template_id, week_type).First(&item).Error
	return item, err
}

//某模板下，某周几下，是否有排班
func GetScheduleTemplateTwo(orgID int64, template_id int64, week_type int64, patient_id int64) (models.PatientScheduleTemplateItem, error) {
	var item models.PatientScheduleTemplateItem
	err := readDb.Model(&models.PatientScheduleTemplateItem{}).Where("patient_id = ? AND org_id = ? AND status = 1 AND template_id = ? AND weekday = ?", patient_id, orgID, template_id, week_type).First(&item).Error
	return item, err
}