XT_New/service/dialysis_service.go

package service

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

//GetPatientList 返回患者的列表
func GetSchedualPatientList(orgID int64, schedulDate int64, schedulType int64, partitionType int64, keywords string, page int64, limit int64) (schedule []*models.DialysisSchedule, err error) {
	var total int64
	//if len(keywords) > 0 {
	//	likeKey := "%" + keywords + "%"
	//	//db = db.Preload("MonitorPatients", "status = 1 AND user_org_id = ?  AND `name` LIKE ? ", orgID, likeKey).Preload("DeviceNumber", "status = 1 AND org_id = ? ", orgID).Preload("PredialysisEvaluation", "status = 1 AND user_org_id = ?  AND assessment_date = ? ", orgID, schedulDate).Preload("AssessmentAfterDislysis", "status = 1 AND user_org_id = ? AND assessment_date = ? ", orgID, schedulDate).Preload("MonitoringRecord", "status = 1 AND user_org_id = ?  AND monitoring_date  = ?", orgID, schedulDate).Where("status = 1 AND user_org_id = ? ", orgID)
	//	db = readDb.
	//		Model(&models.MonitorDialysisSchedule{}).
	//		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
	//		Preload("DeviceZone", "status = 1 AND org_id = ?", orgID).
	//		Preload("TreatmentMode", "status = 1").
	//		Preload("Prescription", "status = 1 AND user_org_id = ?", orgID).
	//		Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ?", orgID).
	//		Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ?", orgID).
	//		Preload("MonitoringRecord", "status = 1 AND  user_org_id = ?", orgID).
	//		Preload("DialysisOrder", "status = 1 AND user_org_id = ?", orgID).
	//		Preload("MonitorPatients", "status = 1 AND user_org_id = ?  AND `name` LIKE ?", orgID,likeKey)
	//
	//
	//} else {
	//}

	db := readDb.
		Model(&models.MonitorDialysisSchedule{}).
		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
		// Preload("DeviceZone", "status = 1 AND org_id = ?", orgID).
		Preload("TreatmentMode", "status = 1").
		Preload("Prescription", "status = 1 AND user_org_id = ? AND record_date = ?", orgID, schedulDate).
		Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ? AND assessment_date = ?", orgID, schedulDate).
		Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ? AND assessment_date = ?", orgID, schedulDate).
		Preload("MonitoringRecord", "status = 1 AND  user_org_id = ? AND monitoring_date = ?", orgID, schedulDate).
		Preload("DialysisOrder", "status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, schedulDate).
		Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID)
	db = db.Where("status = 1")
	if schedulDate > 0 {
		db = db.Where("schedule_date = ?", schedulDate)
	}

	db = db.Count(&total)
	fmt.Println(total)
	if schedulType > 0 {
		db = db.Where("schedule_type = ?", schedulType)
	}
	if partitionType > 0 {
		db = db.Where("partition_id = ?", partitionType)
	}

	offset := (page - 1) * limit
	errors := db.Offset(offset).Limit(limit).Find(&schedule).Error
	return schedule, errors
}

//用户基本信息
func FindPatientInfoById(orgID int64, id int64, time int64) (patient models.SchedualPatient2, err error) {
	err = readDb.Preload("DialysisSchedule", func(db *gorm.DB) *gorm.DB {
		return db.Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).Preload("DeviceZone", "status = 1 AND org_id = ?", orgID).Where("patient_id = ? AND user_org_id = ? AND schedule_date = ? ", id, orgID, time)
	}).Where("id = ? and user_org_id=? and status=1", id, orgID).First(&patient).Error
	return
}

//透析处方
func FindPatientPrescribeById(orgID int64, patientsId int64, recordDate int64) (patient models.DialysisPrescription, err error) {
	err = readDb.Model(&models.DialysisPrescription{}).Where("patient_id = ? and user_org_id=? and status=1 and  record_date = ? ", patientsId, orgID, recordDate).First(&patient).Error
	return
}

//透析方案中的透析处方
func FindDialysisSolution(orgID int64, patientsId int64) (patient models.DialysisSolution, err error) {
	err = readDb.Model(&models.DialysisSolution{}).Where("patient_id = ? and user_org_id=? and status=1", patientsId, orgID).Last(&patient).Error
	return
}

//透析方案中的透析模式
func FindTreatmentModeById(modeId int64) (mode models.TreatmentMode, err error) {
	err = readDb.Model(&models.TreatmentMode{}).Where("id = ? AND status=1", modeId).First(&mode).Error
	return
}

//接诊评估
func FindReceiverTreatmentAccessRecordById(orgID int64, patientsId int64, recordDate int64) (receiveTreatmentAsses models.ReceiveTreatmentAsses, err error) {
	err = readDb.Model(&models.ReceiveTreatmentAsses{}).Where("patient_id = ? and user_org_id=? and status=1 and record_date = ?", patientsId, orgID, recordDate).First(&receiveTreatmentAsses).Error
	return
}

//透前评估
func FindPredialysisEvaluationById(orgID int64, patientsId int64, recordDate int64) (patient models.PredialysisEvaluation, err error) {
	err = readDb.Model(&models.PredialysisEvaluation{}).Where("patient_id = ? and user_org_id=? and status=1 and assessment_date = ?", patientsId, orgID, recordDate).First(&patient).Error
	return
}

func FindPredialysisName(id int64, orgid int64) (models.Dataconfig, error) {
	dataconfig := models.Dataconfig{}
	err := readDb.Where("value = ? and org_id =? and status = 1", id, orgid).Find(&dataconfig).Error
	return dataconfig, err
}

//临时医嘱
func FindDoctorAdviceById(orgID int64, patientsId int64, recordDate int64) (patient []*models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("patient_id = ? and user_org_id=? and status=1 and record_date = ? AND  advice_type = 2", patientsId, orgID, recordDate).Find(&patient).Error
	return
}

func FindDoctorAdviceByInfo(orgID int64, patientsId int64, recordDate int64) (advices []*models.XtDoctorAdvice, err error) {
	//db := readDb.Table("xt_doctor_advice as a").Where("a.status = ?", 1)
	//err = db.Group("a.advice_name").Select("a.id,a.user_org_id,a.patient_id,a.advice_type,a.advice_date,a.start_time,a.advice_name,a.advice_desc,a.reminder_date,a.single_dose,a.single_dose_unit,a.prescribing_number,a.prescribing_number_unit,a.delivery_way,a.execution_frequency,a.advice_doctor,a.status,a.created_time,a.updated_time,a.advice_affirm,a.remark,a.stop_time,a.stop_reason,a.stop_doctor,a.stop_state,a.parent_id,a.execution_time,a.execution_staff,a.execution_state,a.checker,a.record_date,a.dialysis_order_id,a.check_time,a.check_state,a.drug_spec,a.drug_spec_unit,a.groupno,a.remind_type,a.frequency_type,a.day_count,a.week_day,a.template_id,r.user_name,s.user_name").Joins(" left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = a.execution_staff").Joins("left join sgj_users.sgj_user_admin_role as s on s.admin_user_id = a.checker").Where("a.user_org_id = ? and a.patient_id = ? and a.advice_date = ?", orgID, patientsId, recordDate).Find(&advices).Error
	//return
	err = readDb.Model(&models.DoctorAdvice{}).
		Where("patient_id = ? and user_org_id=? and status=1 and record_date = ? and advice_type = 2", patientsId, orgID, recordDate).
		Select("id, user_org_id, patient_id, advice_type, advice_date, record_date, start_time, advice_name,advice_desc, reminder_date, drug_spec, drug_spec_unit, single_dose, single_dose_unit, prescribing_number, prescribing_number_unit, delivery_way, execution_frequency, advice_doctor, status, created_time,updated_time, advice_affirm, remark, stop_time, stop_reason, stop_doctor, stop_state, parent_id, execution_time, execution_staff, execution_state, checker, check_state, check_time, groupno, IF(parent_id > 0, parent_id, id) as advice_order").Order("start_time asc, groupno desc, advice_order desc, id asc").
		Find(&advices).Error
	return
}
func GetTotalDialysisCout(orgid int64, patientid int64) (order []*models.DialysisOrder, total int64, err error) {

	err = readDb.Model(&order).Where("user_org_id = ? and patient_id = ? and status = 1", orgid, patientid).Find(&order).Count(&total).Error
	return order, total, err
}

//临时医嘱
func FindDoctorAdviceOrderById(orgID int64, patientsId int64, recordDate int64) (patient []*models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).
		Where("patient_id = ? and user_org_id=? and status=1 and record_date = ? and advice_type = 2", patientsId, orgID, recordDate).
		Select("id, user_org_id, patient_id, advice_type, advice_date, record_date, start_time, advice_name,advice_desc, reminder_date, drug_spec, drug_spec_unit, single_dose, single_dose_unit, prescribing_number, prescribing_number_unit, delivery_way, execution_frequency, advice_doctor, status, created_time,updated_time, advice_affirm, remark, stop_time, stop_reason, stop_doctor, stop_state, parent_id, execution_time, execution_staff, execution_state, checker, check_state, check_time, groupno, IF(parent_id > 0, parent_id, id) as advice_order").Order("start_time asc, groupno desc, advice_order desc, id asc").
		Find(&patient).Error
	return
}

//双人核对
func FindDoubleCheckById(orgID int64, patientsId int64, recordDate int64) (patient models.DoubleCheck, err error) {
	err = readDb.Model(&models.DoubleCheck{}).Where("patient_id = ? and user_org_id=? and status=1 and check_date = ? ", patientsId, orgID, recordDate).First(&patient).Error
	return
}

//透析监测
func FindAllMonitorRecord(orgID int64, patientsId int64, recordDate int64) (record []*models.MonitoringRecord, err error) {
	err = readDb.Model(&models.MonitoringRecord{}).Where("patient_id = ? and user_org_id=? and status=1 and monitoring_date = ?", patientsId, orgID, recordDate).Order("operate_time ASC").Find(&record).Error
	return
}

func FindAllMonitor(orgID int64, patientsId int64, recordDate int64) (record []*models.MonitoringRecord, err error) {
	err = readDb.Model(&models.MonitoringRecord{}).Where("patient_id = ? and user_org_id=? and status=1 and monitoring_date = ?", patientsId, orgID, recordDate).Order("operate_time ASC").Find(&record).Error
	return
}

//透后评估
func FindAssessmentAfterDislysisById(orgID int64, patientsId int64, recordDate int64) (patient models.AssessmentAfterDislysis, err error) {
	err = readDb.Model(&models.AssessmentAfterDislysis{}).Where("patient_id = ? and user_org_id=? and status=1 and assessment_date =?", patientsId, orgID, recordDate).First(&patient).Error
	return
}

//治疗小结
func FindTreatmentSummaryById(orgID int64, patientsId int64, recordDate int64) (patient models.TreatmentSummary, err error) {
	err = readDb.Model(&models.TreatmentSummary{}).Where("patient_id = ? and user_org_id=? and status=1 and assessment_date = ? ", patientsId, orgID, recordDate).First(&patient).Error
	return
}

//机构叫号配置
func FindQueueCallInfo(orgID int64) (queueConfig models.QueueCallConfig, err error) {
	err = readDb.Model(&models.QueueCallConfig{}).Where("org_id=? ", orgID).First(&queueConfig).Error
	return
}

//修改机构叫号配置
func UpDateQueueCallInfo(queueConfig models.QueueCallConfig) error {
	err := writeDb.Save(&queueConfig).Error
	return err
}

//所有设备信息
func FindAllDeviceInfo(orgID int64) (device []*models.Device, err error) {
	err = readDb.Model(&models.Device{}).Where("org_id=? and status=1 and device_type = 1", orgID).Find(&device).Error
	return device, err
}

//所有设备区域
func GetAllDeviceZone(orgId int64) (error, []*models.DeviceZone) {
	var zone []*models.DeviceZone
	err := readDb.Model(&zone).Where("org_id = ? AND status = 1", orgId).Find(&zone).Error

	return err, zone
}

//获取所有子药物
func FindAllSubDoctorAdvice(id int64, parentId int64) (error, []models.DoctorAdvice) {
	var subAdvies []models.DoctorAdvice
	err := readDb.Model(&subAdvies).Where("patient_id = ? AND parent_id = ?", id, parentId).Find(&subAdvies).Error

	return err, subAdvies
}

func FindAdivceById(orgId int64, patientId int64, id int64) (error, models.DoctorAdvice) {
	advices := models.DoctorAdvice{}
	err := readDb.Model(&advices).Where("user_org_id = ? AND patient_id = ? AND id = ? AND status = 1", orgId, patientId, id).Find(&advices).Error
	return err, advices
}

func FindSubAdivceById(patientId int64, parentId int64) []*models.DoctorAdvice {
	var subAdvices []*models.DoctorAdvice
	readDb.Model(&subAdvices).Where("patient_id = ? AND parent_id = ?", patientId, parentId).Find(&subAdvices)
	return subAdvices
}

func AddSigleRecord(prescription *models.DialysisPrescription) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.DialysisPrescription{}).Create(&prescription).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

func AddSigleSummaryRecord(summary *models.TreatmentSummary) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.TreatmentSummary{}).Create(&summary).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

func AddSigleReceiveTreatmentAssesRecord(receiveTreatmentAsses *models.ReceiveTreatmentAsses) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.ReceiveTreatmentAsses{}).Create(&receiveTreatmentAsses).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

func AddSigleAssessmentAfterDislysisRecord(assessmentAfterDislysis *models.AssessmentAfterDislysis) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.AssessmentAfterDislysis{}).Create(&assessmentAfterDislysis).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

func AddSigleAssessmentBeforeDislysisRecord(assessmentBeforeDislysis *models.PredialysisEvaluation) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.PredialysisEvaluation{}).Create(&assessmentBeforeDislysis).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

func AddSigleDoubleCheck(check *models.DoubleCheck) (err error) {
	tx := writeDb.Begin()
	errors := tx.Model(&models.PredialysisEvaluation{}).Create(&check).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return errors
}

//修改透析处方
func UpDateDialysisPrescription(dialysisPrescription *models.DialysisPrescription) error {
	err := writeDb.Save(&dialysisPrescription).Error
	return err
}

//修改接诊评估
func UpadateReceiveTreatmentAsses(receiveTreatmentAsses *models.ReceiveTreatmentAsses) error {
	err := writeDb.Save(receiveTreatmentAsses).Error
	return err
}

//修改透前评估
func UpadatePredialysisEvaluation(predialysisEvaluation *models.PredialysisEvaluation) error {
	err := writeDb.Save(&predialysisEvaluation).Error
	return err
}

//修改双人核对
func UpdateDoubleCheck(check *models.DoubleCheck) error {
	err := writeDb.Save(&check).Error
	return err
}

//修改透后评估
func UpdateAssessmentAfterDislysisRecord(assessmentAfterDislysis *models.AssessmentAfterDislysis) error {
	err := writeDb.Save(&assessmentAfterDislysis).Error
	return err
}

func UpdatePredialysisEvaluation(predialysisevaluation *models.PredialysisEvaluation, id int64) error {

	err := writeDb.Model(&predialysisevaluation).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"systolic_blood_pressure": predialysisevaluation.SystolicBloodPressure}).Error
	return err
}

func UpdatePredialysisEvaluationTwo(predialysisevaluation *models.PredialysisEvaluation, id int64) error {

	err := writeDb.Model(&predialysisevaluation).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"diastolic_blood_pressure": predialysisevaluation.DiastolicBloodPressure}).Error
	return err
}
func UpdatePredialysisEvaluationThree(predialysisevaluation *models.PredialysisEvaluation, id int64) error {

	err := writeDb.Model(&predialysisevaluation).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"pulse_frequency": predialysisevaluation.PulseFrequency}).Error
	return err
}

//修改
func UpdateSummeRecord(treatmentSummary *models.TreatmentSummary) error {
	err := writeDb.Save(&treatmentSummary).Error
	return err
}

// func UpdateDoctorAdviceById(m *models.DoctorAdvice, id int64, patientId int64) error {
// 	tx := writeDb.Begin()
// 	err := tx.Model(&models.DoctorAdvice{}).Where("patient_id = ? AND id = ? AND status = 1 ", patientId, id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1, "checker": m.Checker}).Error
// 	if err != nil {
// 		tx.Rollback()
// 	}
// 	tx.Commit()
// 	return err
// }
func ExceDoctorAdviceById(m *models.DoctorAdvice, id int64, patientId int64) error {
	err := writeDb.Model(&models.DoctorAdvice{}).Where("patient_id = ? AND (id = ? Or parent_id=?)  AND status = 1 ", patientId, id, id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	return err
}

func ExceHidDoctorAdviceById(m *models.HisDoctorAdviceInfo, id int64, patientId int64) error {
	err := writeDb.Model(&models.HisDoctorAdviceInfo{}).Where("patient_id = ? AND (id = ? Or parent_id=?)  AND status = 1 ", patientId, id, id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	return err
}

func CheckDoctorAdviceById(m *models.DoctorAdvice, id int64, patientId int64) error {
	err := writeDb.Model(&models.DoctorAdvice{}).Where("patient_id = ? AND (id = ? Or parent_id=?) AND status = 1 ", patientId, id, id).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	return err
}

func CheckHisDoctorAdviceById(m *models.HisDoctorAdviceInfo, id int64, patientId int64) error {
	err := writeDb.Model(&models.HisDoctorAdviceInfo{}).Where("patient_id = ? AND (id = ? Or parent_id=?) AND status = 1 ", patientId, id, id).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	return err
}

func CreateMonitor(m *models.MonitoringRecord) (err error) {
	return writeDb.Create(m).Error
}
func UpdateMonitor(m *models.MonitoringRecord) (err error) {
	return writeDb.Save(m).Error
}

func DelMonitor(patientId int64, recordId int64) error {
	tx := writeDb.Begin()
	updateTime := time.Now().Unix()
	err := tx.Model(&models.MonitoringRecord{}).Where("patient_id = ? AND id = ? AND status = 1 ", patientId, recordId).Updates(map[string]interface{}{"status": 0, "updated_time": updateTime}).Error
	if err != nil {
		tx.Rollback()
	}
	tx.Commit()
	return err
}

//修改长期处方

func UpdateSolution(solution *models.DialysisSolution) {
	writeDb.Save(&solution)

}

//创建长期处方
func CreateSolution(solution *models.DialysisSolution) {
	writeDb.Create(&solution)
}

func SavePrescriptionAndCreateSolution(solution *models.DialysisSolution, prescription *models.DialysisPrescription) (err error) {

	tx := writeDb.Begin()
	if prescription.ID > 0 {
		err = tx.Save(&prescription).Error
	} else {
		err = tx.Model(&models.DialysisPrescription{}).Create(&prescription).Error
	}

	if err != nil {
		tx.Rollback()
		return
	}

	err = tx.Create(&solution).Error

	if err != nil {
		tx.Rollback()
		return
	}

	tx.Commit()
	return
}

//透析处方
func FindDialysisPrescriptionByReordDate(id int64, recordDate int64, orgId int64) (error, *models.DialysisPrescription) {
	dialysisPrescription := models.DialysisPrescription{}
	err := readDb.Model(&dialysisPrescription).Where("patient_id = ? AND  record_date = ? AND status = 1 AND user_org_id = ? ", id, recordDate, orgId).Find(&dialysisPrescription).Error
	return err, &dialysisPrescription
}

func FindReceiveTreatmentAssesByReordDate(id int64, recordDate int64, orgId int64) (error, *models.ReceiveTreatmentAsses) {
	receiveTreatmentAsses := models.ReceiveTreatmentAsses{}
	err := readDb.Model(&receiveTreatmentAsses).Where("patient_id = ? AND  record_date = ? AND status = 1 AND user_org_id = ?", id, recordDate, orgId).Find(&receiveTreatmentAsses).Error
	return err, &receiveTreatmentAsses
}

//透前评估
func FindPredialysisEvaluationByReordDate(id int64, recordDate int64, orgId int64) (error, *models.PredialysisEvaluation) {
	dialysisEvaluation := models.PredialysisEvaluation{}
	err := readDb.Model(&models.PredialysisEvaluation{}).Where("patient_id = ? AND  assessment_date = ? AND status = 1 AND user_org_id = ?", id, recordDate, orgId).First(&dialysisEvaluation).Error
	return err, &dialysisEvaluation
}

//双人核对
func FindDoubleCheckByReordDate(id int64, recordDate int64, orgId int64) (error, *models.DoubleCheck) {
	check := models.DoubleCheck{}
	err := readDb.Model(&models.DoubleCheck{}).Where("patient_id = ? AND  check_date = ? AND status = 1 AND user_org_id = ?", id, recordDate, orgId).First(&check).Error
	return err, &check
}

func FindAssessmentAfterDislysisByReordDate(id int64, recordDate int64, orgId int64) (error, *models.AssessmentAfterDislysis) {
	assessmentAfterDislysis := models.AssessmentAfterDislysis{}
	err := readDb.Model(&models.AssessmentAfterDislysis{}).Where("patient_id = ? AND  assessment_date = ? AND status = 1 AND user_org_id = ?", id, recordDate, orgId).First(&assessmentAfterDislysis).Error
	return err, &assessmentAfterDislysis
}

func FindTreatmentSummaryByReordDate(id int64, recordDate int64, orgId int64) (error, *models.TreatmentSummary) {
	summary := models.TreatmentSummary{}
	err := readDb.Model(&models.TreatmentSummary{}).Where("patient_id = ? AND  assessment_date = ? AND status = 1 AND user_org_id = ?", id, recordDate, orgId).First(&summary).Error
	return err, &summary
}

func FindDoctorAdviceByReordDate(id int64, recordDate int64, orgId int64) (error, *models.DoctorAdvice) {
	advice := models.DoctorAdvice{}
	err := readDb.Model(&models.DoctorAdvice{}).Where("patient_id = ? AND  record_date =  ? AND parent_id = 0 AND status = 1 AND user_org_id = ? ", id, recordDate, orgId).First(&advice).Error
	return err, &advice
}

func FindDialysisRecordById(orgId int64, id int64, recordDate int64) (error, *models.DialysisOrder) {
	var count int64
	dialysisRecord := models.DialysisOrder{}
	err := readDb.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND patient_id = ? AND  dialysis_date = ?", orgId, id, recordDate).Find(&dialysisRecord).Count(&count).Error
	if count <= 0 {
		return err, nil
	}
	return err, &dialysisRecord
}

func FindDialysisSchedualById(orgId int64, id int64, recordDate int64) (error, *models.Schedule) {
	var count int64
	schedule := models.Schedule{}
	err := readDb.Model(&models.Schedule{}).Where("user_org_id = ? AND patient_id = ? AND  schedule_date = ?", orgId, id, recordDate).Find(&schedule).Count(&count).Error
	if count <= 0 {
		return err, nil
	}
	return err, &schedule
}

func CreateDialysisRecord(id int64, orgId int64, record *models.DialysisOrder) error {
	err := writeDb.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND patient_id = ? ", orgId, id).Create(&record).Error
	if err != nil {
		return err
	}
	dialysisPrescriptionErr := UpDateRecordIdToDialysisPrescription(id, orgId, record.DialysisDate, record.ID)
	if dialysisPrescriptionErr != nil {
		return dialysisPrescriptionErr
	}
	receiveTreatmentAssesErr := UpDateRecordIdToReceiveTreatmentAsses(id, orgId, record.DialysisDate, record.ID)
	if receiveTreatmentAssesErr != nil {
		return receiveTreatmentAssesErr
	}
	predialysisEvaluationErr := UpDateRecordIdToPredialysisEvaluation(id, orgId, record.DialysisDate, record.ID)
	if predialysisEvaluationErr != nil {
		return predialysisEvaluationErr
	}
	treatmentSummaryErr := UpDateRecordIdToTreatmentSummary(id, orgId, record.DialysisDate, record.ID)
	if treatmentSummaryErr != nil {
		return treatmentSummaryErr
	}
	doubleCheckErr := UpDateRecordIdToDoubleCheck(id, orgId, record.DialysisDate, record.ID)
	if doubleCheckErr != nil {
		return doubleCheckErr
	}
	adviceErrr := UpDateRecordIdToDoctorAdvice(id, orgId, record.DialysisDate, record.ID)
	if adviceErrr != nil {
		return adviceErrr
	}

	//透析监测
	records, err := FindAllMonitorRecord(orgId, id, record.DialysisDate)
	if err != nil {
		return err
	}
	var Ids []int64
	for _, item := range records {
		Ids = append(Ids, item.ID)
	}
	monitorErr := UpDateRecordIdToMonitor(Ids, record.ID)
	if monitorErr != nil {
		return monitorErr
	}
	return nil
}

func ModifyDialysisRecord(id int64, finishNurse int64, end_time int64, admin_user_id int64) error {
	err := writeDb.Model(&models.DialysisOrder{}).Where("id = ? AND status = 1 ", id).Updates(map[string]interface{}{"updated_time": time.Now().Unix(), "stage": 2, "finish_nurse": finishNurse, "end_time": end_time, "finish_creator": admin_user_id, "finish_modifier": admin_user_id}).Error
	return err

}

func UpdateSolutionByPatientId(id int64) error {
	err := writeDb.Model(&models.Patients{}).Where("id = ? AND status = 1 ", id).UpdateColumn("total_dialysis", gorm.Expr("total_dialysis + ?", 1)).Error
	return err

}

//更新透析处方记录ID
func UpDateRecordIdToDialysisPrescription(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.DialysisPrescription{}).Where("user_org_id = ? AND patient_id = ? AND record_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"record_id": recordId}).Error
	return errors
}

func UpDateRecordIdToReceiveTreatmentAsses(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.ReceiveTreatmentAsses{}).Where("user_org_id = ? AND patient_id = ? AND record_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"record_id": recordId}).Error
	return errors
}

func UpDateRecordIdToPredialysisEvaluation(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.PredialysisEvaluation{}).Where("user_org_id = ? AND patient_id = ? AND assessment_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

func UpDateRecordIdToAssessmentAfterDislysis(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.AssessmentAfterDislysis{}).Where("user_org_id = ? AND patient_id = ? AND assessment_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

func UpDateRecordIdToTreatmentSummary(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.TreatmentSummary{}).Where("user_org_id = ? AND patient_id = ? AND assessment_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

func UpDateRecordIdToMonitor(Ids []int64, recordId int64) error {
	errors := writeDb.Model(&models.MonitoringRecord{}).Where("id IN (?)", Ids).Update(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

func UpDateRecordIdToDoubleCheck(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.DoubleCheck{}).Where("user_org_id = ? AND patient_id = ? AND check_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

func UpDateRecordIdToDoctorAdvice(patientId int64, orgId int64, recordTime int64, recordId int64) error {
	errors := writeDb.Model(&models.DoctorAdvice{}).Where("user_org_id = ? AND patient_id = ? AND record_date = ? ", orgId, patientId, recordTime).Updates(map[string]interface{}{"dialysis_order_id": recordId}).Error
	return errors
}

//透析处方
func FindPatientPrescribeWidyDevideById(orgID int64, patientsId int64, recordDate int64) (patient models.DialysisPrescriptionAddtional, err error) {
	err = readDb.Preload("Device", "status = 1 AND org_id = ?", orgID).
		Model(&models.DialysisPrescriptionAddtional{}).
		Where("patient_id = ? and user_org_id=? and status=1 and  record_date = ? ", patientsId, orgID, recordDate).
		First(&patient).Error
	return
}

func FindDialysisMode(orgID int64, patientId int64, scheduleDate int64) (models.XtSchedule, error) {
	schedule := models.XtSchedule{}
	err = readDb.Where("user_org_id = ? and patient_id = ? and schedule_date = ? ", orgID, patientId, scheduleDate).Find(&schedule).Error
	return schedule, err
}

func FindDialysisMacher(orgid int64, patientid int64, dialysisDate int64) (models.XtDialysisOrders, error) {
	orders := models.XtDialysisOrders{}
	db := readDb.Table("xt_dialysis_order as o").Where("o.status = 1")
	table := readDb.Table("xt_device_number as n")
	fmt.Print("table", table)
	err := db.Select("o.id,o.dialysis_date,o.user_org_id,o.patient_id,o.prescription_id,o.stage,remark,o.bed_id,o.start_nurse,o.finish_nurse,o.status,o.created_time,o.updated_time,o.start_time,o.end_time,o.puncture_nurse,o.creator,o.modifier,o.finish_creator,o.finish_modifier,o.schedual_type,n.number,r.user_name").Joins("left join xt_device_number as n on n.id = o.bed_id").Joins("left join sgj_users.sgj_user_admin_role  as r on r.admin_user_id = o.start_nurse").Where("o.user_org_id = ? and o.patient_id = ? and o.dialysis_date =?", orgid, patientid, dialysisDate).Scan(&orders).Error
	return orders, err
}
func FindPunctureNurse(adminid int64, appid int64, orgid int64) (models.App_Roles, error) {
	role := models.App_Roles{}
	//err := UserReadDB().Where("admin_user_id = ? and app_id = ? and org_id = ?", adminid, appid, orgid).Find(&role).Error
	//return role, err
	db := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status =1")
	err := db.Select("r.id,r.admin_user_id,r.org_id,r.role_id,r.user_name,r.avatar,r.user_type,r.user_title,r.intro,r.status,r.ctime,e.url").Joins("left join sgj_user_admin_electronic_signature as e on e.creator = r.admin_user_id").Where("r.admin_user_id = ? and r.app_id = ? and r.org_id = ?", adminid, appid, orgid).Find(&role).Error
	return role, err
}

func FindeStartNuse(adminid int64, appid int64, orgid int64) (models.App_Roles, error) {
	role := models.App_Roles{}
	db := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	err := db.Select("r.id,r.admin_user_id,r.org_id,r.role_id,r.user_name,r.avatar,r.user_type,r.user_title,r.intro,r.status,r.ctime,e.url").Joins("left join sgj_user_admin_electronic_signature as e on e.creator = r.admin_user_id").Where("r.admin_user_id = ? and r.app_id = ? and r.org_id = ?", adminid, appid, orgid).Find(&role).Error
	//err := UserReadDB().Where("admin_user_id = ? and app_id = ? and org_id = ?", adminid, appid, orgid).Find(&role).Error
	return role, err
}

func FindDialysisWay(orgid int64, patientid int64, recorddate int64) (models.DialysisPrescription, error) {
	prescription := models.DialysisPrescription{}
	err := readDb.Where("user_org_id = ? and patient_id = ? and record_date = ? and status =1", orgid, patientid, recorddate).Find(&prescription).Error
	return prescription, err

}

func FindDoctorOrder(orgid int64, patientid int64, adviceDate int64) (models.XtDoctorAdvice, error) {
	advices := models.XtDoctorAdvice{}
	db := readDb.Table("xt_doctor_advice as a").Where("a.status = ?", 1)
	err := db.Select("a.id,a.user_org_id,a.patient_id,a.advice_type,a.advice_date,a.start_time,a.advice_name,a.advice_desc,a.reminder_date,a.single_dose,a.single_dose_unit,a.prescribing_number,a.prescribing_number_unit,a.delivery_way,a.execution_frequency,a.advice_doctor,a.status,a.created_time,a.updated_time,a.advice_affirm,a.remark,a.stop_time,a.stop_reason,a.stop_doctor,a.stop_state,a.parent_id,a.execution_time,a.execution_staff,a.execution_state,a.checker,a.record_date,a.dialysis_order_id,a.check_time,a.check_state,a.drug_spec,a.drug_spec_unit,a.groupno,a.remind_type,a.frequency_type,a.day_count,a.week_day,a.template_id").Where("a.user_org_id = ? and a.patient_id = ? and a.advice_date = ?", orgid, patientid, adviceDate).Find(&advices).Error
	return advices, err
}

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

func FindDoctorName(adminid int64, appid int64, orgid int64) (models.App_Roles, error) {
	role := models.App_Roles{}
	db := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
	err := db.Select("r.id,r.admin_user_id,r.org_id,r.role_id,r.user_name,r.avatar,r.user_type,r.user_title,r.intro,r.status,r.ctime,e.url").Joins("left join sgj_user_admin_electronic_signature as e on e.creator = r.admin_user_id").Where("r.admin_user_id = ? and r.app_id = ? and r.org_id = ?", adminid, appid, orgid).Find(&role).Error
	//err := UserReadDB().Where("admin_user_id = ? and app_id = ? and org_id = ?", adminid, appid, orgid).Find(&role).Error
	return role, err
}

/////////////// 新 18-10-22
func GetDialysisScheduals(orgID int64, scheduleDate int64) ([]*MDialysisScheduleVM, error) {
	var vms []*MDialysisScheduleVM
	db := readDb.
		Table("xt_schedule").
		Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
		Preload("DialysisOrder", "status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, scheduleDate).
		Preload("AssessmentBeforeDislysis", "status = 1 AND user_org_id = ? AND  assessment_date = ?", orgID, scheduleDate).
		Preload("Prescription", "status = 1 AND user_org_id = ? AND record_date = ?", orgID, scheduleDate).
		Preload("TreatmentSummary", "status = 1 AND user_org_id = ? AND assessment_date = ? ", orgID, scheduleDate).
		Preload("Advices", "status = 1 AND user_org_id = ? AND advice_date = ? ", orgID, scheduleDate).
		Preload("AssessmentAfterDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
		Where("status = 1 AND user_org_id = ?", orgID)
	if scheduleDate != 0 {
		db = db.Where("schedule_date = ?", scheduleDate)
	}

	err := db.Find(&vms).Error
	return vms, err
}

func GetDialysisSchedualsOne(orgID int64, scheduleDate int64) ([]*MDialysisScheduleVM, error) {
	var vms []*MDialysisScheduleVM
	db := readDb.
		Table("xt_schedule").
		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
		//Preload("DialysisOrder", "status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, scheduleDate).
		//Preload("AssessmentBeforeDislysis", "status = 1 AND user_org_id = ? AND  assessment_date = ?", orgID, scheduleDate).
		//Preload("Prescription", "status = 1 AND user_org_id = ? AND record_date = ?", orgID, scheduleDate).
		//Preload("TreatmentSummary", "status = 1 AND user_org_id = ? AND assessment_date = ? ", orgID, scheduleDate).
		//Preload("Advices", "status = 1 AND user_org_id = ? AND advice_date = ? ", orgID, scheduleDate).
		//Preload("AssessmentAfterDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
		Where("status = 1 AND user_org_id = ?", orgID)
	if scheduleDate != 0 {
		db = db.Where("schedule_date = ?", scheduleDate)
	}

	err := db.Find(&vms).Error
	return vms, err
}

func GetLastAcceptsAssessment(patient int64, orgId int64) (error, models.ReceiveTreatmentAsses) {
	var receiveTreatmentAsses models.ReceiveTreatmentAsses
	err := readDb.Model(&models.ReceiveTreatmentAsses{}).Where("patient_id = ? AND status = 1 AND user_org_id = ?", patient, orgId).Last(&receiveTreatmentAsses).Error
	return err, receiveTreatmentAsses
}

func GetDialysisWatch(orgID int64, schedulDate int64, schedulType int64, partitionType int64, page int64, limit int64) (schedule []*models.DialysisSchedule, err error, total int64) {
	db := readDb.
		Model(&models.MonitorDialysisSchedule{}).
		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
		// Preload("DeviceZone", "status = 1 AND org_id = ?", orgID).
		Preload("TreatmentMode", "status = 1").
		Preload("Prescription", "status = 1 AND user_org_id = ?", orgID).
		Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ?", orgID).
		Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ?", orgID).
		Preload("MonitoringRecord", func(db *gorm.DB) *gorm.DB {
			return db.Where("status = 1 AND user_org_id = ?", orgID).Order("operate_time asc")
		}).
		Preload("DialysisOrder", "status = 1 AND user_org_id = ?", orgID).
		Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID)
	db = db.Where("xt_schedule.status = 1 AND user_org_id = ?", orgID)
	if schedulDate > 0 {
		db = db.Where("schedule_date = ?", schedulDate)
	}
	if schedulType > 0 {
		db = db.Where("schedule_type = ?", schedulType)
	}
	if partitionType > 0 {
		db = db.Joins("inner join xt_device_number on xt_device_number.id = xt_schedule.bed_id and xt_device_number.zone_id = ? and xt_device_number.status = 1", partitionType)
		// db = db.Where("partition_id = ?", partitionType)
	}
	offset := (page - 1) * limit
	err = db.Count(&total).Offset(offset).Limit(limit).Order("bed_id desc").Find(&schedule).Error
	return schedule, err, total
}

func GetDialysisWatchByKeyword(orgID int64, keyword string, schedulType int64, partitionType int64, page int64, limit int64) (schedules []*models.DialysisSchedule, err error, total int64) {
	//var patients []*models.Patients
	//getPatientErr := readDb.Model(&models.Patients{}).Where("status = 1 AND user_org_id = ? AND (name like ? OR dialysis_no like ?)", orgID, "%"+keyword+"%", "%"+keyword+"%").Find(&patients).Error
	//if getPatientErr != nil {
	//	return nil, getPatientErr, 0
	//}
	//patientIDs := make([]int64, len(patients))
	//for index, patient := range patients {
	//	patientIDs[index] = patient.ID
	//}
	//
	//db := readDb.
	//	Model(&models.DialysisSchedule{}).
	//	Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
	//	Preload("TreatmentMode", "status = 1").
	//	Preload("Prescription", "status = 1 AND user_org_id = ?", orgID).
	//	Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ?", orgID).
	//	Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ?", orgID).
	//	Preload("MonitoringRecord", "status = 1 AND  user_org_id = ?", orgID).
	//	Preload("DialysisOrder", "status = 1 AND user_org_id = ?", orgID).
	//	Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID)
	//db = db.Where("xt_schedule.status = 1 AND patient_id in (?)", patientIDs)
	//if schedulType > 0 {
	//	db = db.Where("schedule_type = ?", schedulType)
	//}
	//if partitionType > 0 {
	//	db = db.Joins("inner join xt_device_number as d_n on d_n.id = xt_schedule.bed_id and d_n.zone_id = ? and d_n.status = 1", partitionType)
	//
	//}
	//var schedules []*models.DialysisSchedule
	//total := int64(0)
	//err := db.Count(&total).Offset(limit * (page - 1)).Limit(limit).Order("schedule_date desc").Find(&schedules).Error
	//return schedules, err, total

	db := readDb.Model(&models.DialysisSchedule{}).Where("status = 1")

	if schedulType > 0 {
		db = db.Where("scheudle_type = ?", schedulType)
	}

	if partitionType > 0 {
		db = db.Where("partition_id = ?", partitionType)
	}

	err = db.Count(&total).Offset(limit * (page - 1)).Limit(limit).Order("schedule_date desc").Find(&schedules).Error
	return schedules, err, total
}

func GetAdminUserES(orgID int64, appID int64, ids []int64) (es []*models.AdminUserElectronicSignature, err error) {
	err = readUserDb.Model(&models.AdminUserElectronicSignature{}).Where("org_id=? and app_id=? and creator in (?) and status=1", orgID, appID, ids).Find(&es).Error
	return
}

//
//func GetAdminUserEsOne(orgid int64) (admin []*models.UserAdminRoles, err error) {
//
//	db := readUserDb.Table("sgj_user_admin_role as x").Where("x.status = 1")
//	table := readUserDb.Table("sgj_user_admin_electronic_signature as s")
//	fmt.Println("table", table)
//	err = db.Select("x.id,x.admin_user_id,x.user_name,x.org_id,s.creator,s.url,s.hash").Joins("left join sgj_user_admin_electronic_signature as s on s.creator = x.admin_user_id").Where("x.org_id = ?", orgid).Scan(&admin).Error
//	return admin, err
//}

func GetAdminUserEsOne(orgid int64) (admin []*models.UserAdminRoles, err error) {
	db := readUserDb.Table("sgj_user_admin_role as x").Where("x.status =1")
	table := readUserDb.Table("sgj_user_admin_electronic_signature as s")
	fmt.Println("table", table)
	err = db.Select("x.id,x.admin_user_id,x.user_name,x.org_id,s.creator,s.url,s.hash").Joins("left join sgj_user_admin_electronic_signature as s on s.creator = x.admin_user_id").Where("x.org_id = ?", orgid).Scan(&admin).Error
	return admin, err
}

func UpDateDialysisPrescriptionDoctorSign(patient int64, date int64, orgId int64, doctor_id int64) (err error) {
	err = writeDb.Model(&models.DialysisPrescription{}).Where("user_org_id = ? AND patient_id = ? AND record_date = ? ", orgId, patient, date).Updates(map[string]interface{}{"prescription_doctor": doctor_id}).Error
	return
}

func GetAllAdminUserES(orgID int64, appId int64) (es []*models.AdminUserElectronicSignature, err error) {
	err = readUserDb.Model(&models.AdminUserElectronicSignature{}).Where("org_id=? and app_id = ?  and status=1", orgID, appId).Find(&es).Error
	return
}

func GetAllStarfEs(orgid int64) (es []*models.SgjUserAdminRoles, err error) {
	redis := RedisClient()
	defer redis.Close()

	// cur_date := time.Now().Format("2006-01-02")
	key := strconv.FormatInt(orgid, 10) + ":starfes"
	starfes_str, _ := redis.Get(key).Result()

	if len(starfes_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		db := readUserDb.Table("sgj_user_admin_role as x").Where("x.status = 1")
		err = db.Select("x.id,x.admin_user_id,x.org_id,x.app_id,x.role_id,x.user_name,x.avatar,x.user_type,s.creator,s.url,s.hash").Joins("left join sgj_user_admin_electronic_signature as s on s.creator = x.admin_user_id and s.status = 1").Where("x.org_id = ?", orgid).Scan(&es).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				if len(es) <= 0 {
					redis.Set(key, "starfes_str_null", time.Second*60*60*18)
				}
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(es) > 0 {
				//缓存数据
				starfes_str, err := json.Marshal(es)
				if err == nil {
					redis.Set(key, starfes_str, time.Second*60*60*18)
					return es, nil
				}
			} else {
				redis.Set(key, "starfes_str_null", time.Second*60*60*18)
				return es, nil
			}
			return es, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if starfes_str == "starfes_str_null" {
			return es, nil
		} else {
			json.Unmarshal([]byte(starfes_str), &es)
			return es, nil
		}
	}
}

func FindLastMonitorRecord(patient_id int64, org_id int64) (record models.MonitoringRecord, err error) {
	err = readDb.Model(&models.MonitoringRecord{}).Where("patient_id = ? AND status = 1 AND user_org_id = ?", patient_id, org_id).Last(&record).Error
	return
}

func FindLastMonitorRecordToday(patient_id int64, org_id int64, monitoring_date int64) (record models.MonitoringRecord, err error) {
	err = readDb.Model(&models.MonitoringRecord{}).Where("patient_id = ? AND status = 1 AND user_org_id = ? AND monitoring_date = ?", patient_id, org_id, monitoring_date).Last(&record).Error
	return
}

func FindFirstMonitorRecordToday(patient_id int64, org_id int64, monitoring_date int64) (record models.MonitoringRecord, err error) {
	err = readDb.Model(&models.MonitoringRecord{}).Where("patient_id = ? AND status = 1 AND user_org_id = ? AND monitoring_date = ?", patient_id, org_id, monitoring_date).First(&record).Error
	return
}

func ExceDoctorAdviceByGroupNo(m *models.DoctorAdvice, groupNo int64, org_id int64) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("groupno = ?  AND user_org_id = ? AND status = 1 AND execution_state = 2", groupNo, org_id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()

	return err
}

func ExceOldDoctorAdvice(m *models.DoctorAdvice, advice_id int64) (err error) {

	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND id = ?", advice_id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id = ?", advice_id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func CheckDoctorAdviceByGroupNo(m *models.DoctorAdvice, groupNo int64, org_id int64) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("groupno = ?  AND user_org_id = ?  AND status = 1 AND check_state = 0", groupNo, org_id).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()

	return err
}

func CheckOldDoctorAdvice(m *models.DoctorAdvice, advice_id int64) (err error) {

	ut := writeDb.Begin()
	err = writeDb.Model(&models.DoctorAdvice{}).Where("status = 1   AND id = ?", advice_id).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = writeDb.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id = ?", advice_id).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func DeleteDoctorAdviceByGroupNo(m *models.DoctorAdvice) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("groupno = ? AND user_org_id =  ?", m.GroupNo, m.UserOrgId).Update(map[string]interface{}{"UpdatedTime": m.UpdatedTime, "Status": 0, "modifier": m.Modifier}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()

	return
}

func GetDialysisBoard(orgID int64, scheduleDate int64, offset, limit int64) ([]*models.DialysisBoardVM, error) {
	var boards []*models.DialysisBoardVM
	db := readDb.
		Table("xt_schedule").
		Preload("Patient", "status = 1 AND user_org_id = ?", orgID).
		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
		Preload("DeviceZone", "status = 1 AND org_id = ?", orgID).
		Preload("DialysisOrder", "status = 1 AND user_org_id = ?", orgID).
		Preload("SigninAndWeigh", "status = 1 AND user_org_id = ?", orgID).
		Preload("NextSchedules", func(db *gorm.DB) *gorm.DB {
			return db.Where("user_org_id = ? AND schedule_date > ? AND status = 1", orgID, scheduleDate).
				Order("schedule_date asc, id asc")
		}).
		Where("status = 1 AND user_org_id = ?", orgID)
	if scheduleDate != 0 {
		db = db.Where("schedule_date = ?", scheduleDate)
	}

	err := db.Offset(offset).Limit(limit).Find(&boards).Error
	return boards, err
}

func GetOneDialysisOrder(orgID, orderData int64, patient_id int64) (*models.DialysisOrder, error) {
	var order models.DialysisOrder
	var err error
	err = readDb.Model(&models.DialysisOrder{}).Where("user_org_id=? and dialysis_date=? and status=1 and patient_id = ?", orgID, orderData, patient_id).First(&order).Error
	if err == gorm.ErrRecordNotFound {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &order, nil
}

func GetOrgInfoTemplate(orgID int64) (models.GobalTemplate, error) {
	var templateInfo models.GobalTemplate
	var err error
	err = readDb.Model(&models.GobalTemplate{}).Where("org_id=? and status=1", orgID).First(&templateInfo).Error
	return templateInfo, err
}

func FindAdminRoleTypeById(orgId int64, adminUserId int64, appId int64) (models.App_Role, error) {
	var appRole models.App_Role
	var err error
	err = readUserDb.Model(&models.App_Role{}).Where("org_id =? and app_id = ? and admin_user_id = ? and status=1", orgId, appId, adminUserId).First(&appRole).Error
	return appRole, err

}

func BatchExceOldDoctorAdvice(m *models.DoctorAdvice, ids []string) (err error) {

	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND id IN (?) AND execution_state = 2", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id IN (?) AND execution_state = 2 ", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime, "execution_staff": m.ExecutionStaff, "execution_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func BatchCheckOldDoctorAdvice(m *models.DoctorAdvice, ids []string, org_id int64, date int64) (err error) {

	ut := writeDb.Begin()
	err = writeDb.Model(&models.DoctorAdvice{}).Where("status = 1   AND id IN (?) AND user_org_id = ? AND advice_date = ?", ids, org_id, date).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}

	err = writeDb.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id IN (?) AND user_org_id = ? AND advice_date = ?", ids, org_id, date).Updates(map[string]interface{}{"check_time": m.CheckTime, "checker": m.Checker, "check_state": 1}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func ModifyScheduleMode(mode_id int64, patient_id int64, recordDate int64, org_id int64) {
	ut := writeDb.Begin()
	err = writeDb.Model(&models.Schedule{}).Where("status = 1   AND user_org_id = ? AND patient_id = ? AND schedule_date = ? ", org_id, patient_id, recordDate).Updates(map[string]interface{}{"updated_time": time.Now().Unix(), "mode_id": mode_id}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
}

func FindDialysisOrderById(id int64) (error, *models.DialysisOrder) {
	dialysisRecord := models.DialysisOrder{}
	err := readDb.Model(&models.DialysisOrder{}).Where("id = ? AND status = 1", id).Find(&dialysisRecord).Error
	return err, &dialysisRecord
}

func ModifyExceDoctorAdviceByGroupNo(m *models.DoctorAdvice, groupNo int64, org_id int64) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("groupno = ?  AND user_org_id = ? AND status = 1 AND execution_state = 1", groupNo, org_id).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()

	return err
}

func BatchModifyExceOldDoctorAdvice(m *models.DoctorAdvice, ids []string) (err error) {

	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND id IN (?) AND execution_state = 1", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id IN (?) AND execution_state = 1 ", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func UpdateOrderCount(good_type_id int64, good_id int64, number string, org_id int64) {
	writeDb.Model(&models.WarehouseOutInfo{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND is_sys = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, number).UpdateColumn("count", gorm.Expr("count - ?", 1))

}

func UpdateOrderInfoDetails(good_type_id int64, good_id int64, time int64, org_id int64, patient_id int64, newNiprocart int64, out *models.WarehouseOutInfo) {
	writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND warehouse_out_order_number = ? AND patient_id = ?", good_id, good_type_id, org_id, out.WarehouseOutOrderNumber, patient_id).Updates(map[string]interface{}{"good_id": newNiprocart, "warehouse_out_id": out.ID, "warehouse_out_order_number": out.WarehouseOutOrderNumber})
}

func FindOrderInfoByGoodId(good_type_id int64, good_id int64, number string, org_id int64) (err error, out models.WarehouseOutInfo) {
	err = writeDb.Model(&models.WarehouseOutInfo{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, number).Find(&out).Error
	return
}

func FindGoodUserById(good_type_id int64, good_id int64, id int64, org_id int64, record_time int64) (user models.AutomaticReduceDetail, err error) {
	err = readDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND patient_id = ? AND org_id = ? AND record_time = ? ", good_id, good_type_id, id, org_id, record_time).First(&user).Error
	return
}

func FindOldOrderInfoByGoodId(time int64, org_id int64) (err error, out models.WarehouseOutInfo) {
	err = readDb.Model(&models.WarehouseOutInfo{}).Where(" org_id = ? AND status = 1 AND sys_record_time = ? ", org_id, time).First(&out).Error
	return
}

func FindStockOutOrderNumberByTime(time int64, org_id int64) (err error, out models.WarehouseOut) {
	err = readDb.Model(&models.WarehouseOut{}).Where(" org_id = ? AND status = 1 AND warehouse_out_time = ? ", org_id, time).First(&out).Error
	return
}

func UpdateDetails(good_type_id int64, good_id int64, time int64, org_id int64, patient_id int64, newNiprocart int64, out *models.WarehouseOutInfo) {
	writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND warehouse_out_order_number = ? AND patient_id = ?", good_id, good_type_id, org_id, out.WarehouseOutOrderNumber, patient_id).Updates(map[string]interface{}{"good_id": newNiprocart, "warehouse_out_id": out.ID, "warehouse_out_order_number": out.WarehouseOutOrderNumber})
}

func FindPatientIsOpenRemindById(patient_id int64, org_id int64) (patients models.Patients, err error) {
	err = readDb.Model(&models.Patients{}).Where("status = 1 AND id = ? AND user_org_id = ?", patient_id, org_id).First(&patients).Error
	return
}

func GetMaxLongAdviceGroupID(orgId int64, patient_id int64) (group int64) {
	var advice models.DoctorAdvice
	err := readDb.Table("xt_doctor_advice").Where("user_org_id=? AND patient_id = ? AND status = 1 AND advice_type = 1 AND frequency_type > 0", orgId, patient_id).Select("max(groupno) as groupno").First(&advice).Error
	if err != nil {
		fmt.Println(err)
		group = 0
	}
	group = advice.GroupNo
	return
}

func GetLastLongAdviceByGroupNo(orgId int64, patient_id int64) (advice []*models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND advice_type = 1  AND stop_state = 2 AND parent_id = 0 AND frequency_type <> 0", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	return
}

func GetLastLongAdviceByGroupNoOne(orgId int64, patient_id int64) (advice []*models.DoctorAdvice, err error) {

	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":long_advice"
	long_advice_str, _ := redis.Get(key).Result()

	if len(long_advice_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND advice_type = 1  AND stop_state = 2 AND parent_id = 0 AND frequency_type <> 0", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(advice) > 0 {
				//缓存数据
				starfes_str, err := json.Marshal(advice)
				if err == nil {
					redis.Set(key, starfes_str, time.Second*60*60*18)
					return advice, nil
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
				return advice, nil
			}
			return advice, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if long_advice_str == "null" {
			return advice, nil
		} else {
			json.Unmarshal([]byte(long_advice_str), &advice)
			return advice, nil
		}
	}
	err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND advice_type = 1  AND stop_state = 2 AND parent_id = 0 AND frequency_type <> 0", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	return
}

func GetLastLongAdviceByGroupNoThree(orgId int64, patient_id int64) (advice []*models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ?  AND  advice_type = 1 AND frequency_type = 2 AND stop_state = 2 AND parent_id = 0 ", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	return
}

func GetLastLongAdviceByGroupNoFour(orgId int64, patient_id int64) (advice []*models.DoctorAdvice, err error) {
	//err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ?  AND  advice_type = 1 AND frequency_type = 2 AND stop_state = 2 AND parent_id = 0 ", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	//return

	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":long_advice"
	long_advice_str, _ := redis.Get(key).Result()

	if len(long_advice_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ?  AND  advice_type = 1 AND frequency_type = 2 AND stop_state = 2 AND parent_id = 0 ", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(advice) > 0 {
				//缓存数据
				starfes_str, err := json.Marshal(advice)
				if err == nil {
					redis.Set(key, starfes_str, time.Second*60*60*18)
					return advice, nil
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
				return advice, nil
			}
			return advice, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if long_advice_str == "null" {
			return advice, nil
		} else {
			json.Unmarshal([]byte(long_advice_str), &advice)
			return advice, nil
		}
	}
	err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND advice_type = 1  AND stop_state = 2 AND parent_id = 0 AND frequency_type <> 0", orgId, patient_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	return
}

func FindAllDoctorAdviceByTime(now int64, end int64, patient_id int64, orgId int64, temp_id string) (advice []*models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("status = 1 AND user_org_id = ? AND patient_id = ? AND advice_type = 2   AND advice_date > ? AND advice_date <= ? AND template_id = ?  ", orgId, patient_id, end, now, temp_id).Preload("ChildDoctorAdvice", "status = 1").Find(&advice).Error
	return
}

func UpdateScheduleModeId(patient_id int64, org_id int64, date int64, mode_id int64) (err error) {
	err = writeDb.Model(&models.Schedule{}).Where("status =1 AND user_org_id = ? AND patient_id = ? AND schedule_date = ?", org_id, patient_id, date).Updates(map[string]interface{}{"mode_id": mode_id, "updated_time": time.Now().Unix()}).Error
	return
}

func UpdateAssessmentAfterDate(patient_id int64, org_id int64, date int64, actual_treatment_hour int64, actual_treatment_minute int64) (err error) {
	err = writeDb.Model(&models.AssessmentAfterDislysis{}).Where("status =1 AND user_org_id = ? AND patient_id = ? AND assessment_date = ?", org_id, patient_id, date).Updates(map[string]interface{}{"actual_treatment_hour": actual_treatment_hour, "actual_treatment_minute": actual_treatment_minute}).Error
	return
}

func CreateDialysisBeforePrepare(beforePrepares []*models.DialysisBeforePrepare) (err error) {
	if len(beforePrepares) > 0 {
		utx := writeDb.Begin()
		if len(beforePrepares) > 0 {
			thisSQL := "INSERT INTO dialysis_before_prepare (user_org_id, patient_id, record_date, good_id, good_type_id,count,ctime,mtime,creater,modifier,status,commdity_code) VALUES "
			insertParams := make([]string, 0)
			insertData := make([]interface{}, 0)
			for _, prepare := range beforePrepares {
				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?)")
				insertData = append(insertData, prepare.UserOrgId)
				insertData = append(insertData, prepare.PatientId)
				insertData = append(insertData, prepare.RecordDate)
				insertData = append(insertData, prepare.GoodId)
				insertData = append(insertData, prepare.GoodTypeId)
				insertData = append(insertData, prepare.Count)
				insertData = append(insertData, prepare.Ctime)
				insertData = append(insertData, prepare.Mtime)
				insertData = append(insertData, prepare.Creater)
				insertData = append(insertData, prepare.Modifier)
				insertData = append(insertData, 1)
				insertData = append(insertData, prepare.CommdityCode)
			}
			thisSQL += strings.Join(insertParams, ", ")
			err = utx.Exec(thisSQL, insertData...).Error
			if err != nil {
				utx.Rollback()
				return
			}
		}
		utx.Commit()
	}
	return

}

func UpdateDialysisBeforePrepare(info *models.DialysisBeforePrepare) (err error) {
	err = writeDb.Save(&info).Error
	return err
}

func UpdateDialysisBeforePrepareTwo(info *models.DialysisBeforePrepare) (err error) {
	err = writeDb.Model(&models.DialysisBeforePrepare{}).
		Where("status = 1 and good_id = ? AND good_type_id = ? AND patient_id = ? AND user_org_id = ? AND record_date = ?", info.GoodId, info.GoodTypeId, info.PatientId, info.UserOrgId, info.RecordDate).
		Updates(map[string]interface{}{"count": info.Count, "updated_time": time.Now().Unix(), "modifier": info.Modifier, "commdity_code": info.CommdityCode, "status": 1}).Error

	return err
}

func UpdateAutoReduceDetailSix(detail *models.AutomaticReduceDetail) (err error) {

	err = writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? and good_type_id = ? And patient_id = ? and org_id =? and record_time = ?", detail.GoodId, detail.GoodTypeId, detail.PatientId, detail.OrgId, detail.RecordTime).Updates(map[string]interface{}{"count": detail.Count, "mtime": detail.Mtime, "status": 1}).Error
	return err
}

func UpdateOrderCountSub(good_type_id int64, good_id int64, number string, org_id int64, count int64) {
	writeDb.Model(&models.WarehouseOutInfo{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND is_sys = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, number).UpdateColumn("count", gorm.Expr("count - ?", count))

}

func UpdateOrderCountAdd(good_type_id int64, good_id int64, number string, org_id int64, count int64) {
	writeDb.Model(&models.WarehouseOutInfo{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND is_sys = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, number).UpdateColumn("count", gorm.Expr("count + ?", count))

}

func UpdateUserInfoDetails(good_type_id int64, good_id int64, time int64, org_id int64, patient_id int64, count int64, out *models.WarehouseOutInfo) {
	writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND warehouse_out_order_number = ? AND patient_id = ?", good_id, good_type_id, org_id, out.WarehouseOutOrderNumber, patient_id).Updates(map[string]interface{}{"count": count, "status": 1})
	//writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND is_sys = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, out.WarehouseOutOrderNumber).UpdateColumn("count", count)

}

func UpdateDrugUserInfoDetails(drug_id int64, time int64, org_id int64, patient_id int64, count int64, out *models.DrugWarehouseOutInfo) {
	writeDb.Model(&models.DrugAutomaticReduceDetail{}).Where("drug_id = ? AND org_id = ? AND status = 1 AND warehouse_out_order_number = ? AND patient_id = ?", drug_id, org_id, out.WarehouseOutOrderNumber, patient_id).Updates(map[string]interface{}{"count": count})
	//writeDb.Model(&models.AutomaticReduceDetail{}).Where("good_id = ? AND good_type_id = ? AND org_id = ? AND status = 1 AND is_sys = 1 AND warehouse_out_order_number = ? ", good_id, good_type_id, org_id, out.WarehouseOutOrderNumber).UpdateColumn("count", count)

}

func FindDialysisBeforePrepare(patient_id int64, good_id int64, good_type_id int64, user_org_id int64, record_time int64) (count int64) {
	readDb.Model(&models.DialysisBeforePrepare{}).Where("user_org_id = ? AND patient_id = ?  AND good_id = ? AND good_type_id = ? AND record_date = ? AND status = 1 AND count<> 0", user_org_id, patient_id, good_id, good_type_id, record_time).Count(&count)
	return

}

func GetExecutionDoctors(orgid int64, patientid int64, id int64) (doctorAdvice []*models.DoctorAdvice, err error) {

	err = readDb.Model(&doctorAdvice).Where("user_org_id = ? and patient_id = ? AND (id = ? Or parent_id=?) and status = 1", orgid, patientid, id, id).Find(&doctorAdvice).Error
	return doctorAdvice, err
}

func GetHisExecutionDoctors(orgid int64, patientid int64, id int64) (doctorAdvice []*models.HisDoctorAdviceInfo, err error) {

	err = readDb.Model(&models.HisDoctorAdviceInfo{}).Where("user_org_id = ? and patient_id = ? AND (id = ? Or parent_id=?) and status = 1", orgid, patientid, id, id).Find(&doctorAdvice).Error
	return doctorAdvice, err
}

func FindHisDoctorAdviceById(orgID int64, id int64) (advice models.HisDoctorAdviceInfo, err error) {
	err = readDb.Model(&models.HisDoctorAdviceInfo{}).Where("user_org_id=? and status=1 and id = ?", orgID, id).First(&advice).Error
	return
}

func FindHisDoctorAdviceByIds(orgID int64, ids []string) (advice []*models.HisDoctorAdviceInfo, err error) {
	err = readDb.Model(&models.HisDoctorAdviceInfo{}).Where("user_org_id=? and status=1 and id in (?)", orgID, ids).Find(&advice).Error
	return
}

func SaveHisDoctorAdvice(advice *models.HisDoctorAdviceInfo) (err error) {
	err = writeDb.Save(&advice).Error
	return
}

func GetGoodInfoMation(orgid int64) (goodinfo []*models.GoodInfo, err error) {

	err = XTReadDB().Model(&goodinfo).Where("org_id = ? and status = 1 AND  find_in_set('停用',good_status) = 0", orgid).Preload("GoodSotckInfo", "stock_count > 0 and status = 1").Find(&goodinfo).Error
	return goodinfo, err
}

func GetDialysisBeforePrepare(goodTypeId int64, goodId int64, orgid int64, patientId int64) (*models.DialysisBeforePrepare, error) {

	prepare := models.DialysisBeforePrepare{}
	err := XTReadDB().Where("good_type_id = ? and good_id = ? and user_org_id = ? and status =1 and patient_id = ?", goodTypeId, goodId, orgid, patientId).Last(&prepare).Error
	if err == gorm.ErrRecordNotFound {
		return nil, err
	}
	if err != nil {
		return nil, err
	}
	return &prepare, nil
}

func CreateDialysisBeforePrepareOne(prepare *models.DialysisBeforePrepare) error {

	err := XTReadDB().Create(&prepare).Error
	return err
}

func ModifyExceDoctorAdviceById(m *models.HisDoctorAdviceInfo, ids []string) (err error) {

	ut := writeDb.Begin()
	err = ut.Model(&models.HisDoctorAdviceInfo{}).Where("status = 1   AND id IN (?) AND execution_state = 1", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.HisDoctorAdviceInfo{}).Where("status = 1   AND parent_id IN (?) AND execution_state = 1 ", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func ModifyHisPrescriptionProject(m *models.HisPrescriptionProject, ids []string) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.HisPrescriptionProject{}).Where("status = 1   AND id IN (?) AND execution_state = 1", ids).Updates(map[string]interface{}{"execution_time": m.ExecutionTime}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err
}

func FindHisProjectById(orgID int64, id int64) (advice models.HisPrescriptionProject, err error) {
	err = readDb.Model(&models.HisPrescriptionProject{}).Where("user_org_id=? and status=1 and id = ?", orgID, id).First(&advice).Error
	return
}

func SaveHisProject(advice *models.HisPrescriptionProject) (err error) {
	err = writeDb.Save(&advice).Error
	return
}

func FindAllHisProjectById(orgID int64, patient_id int64, record_time int64) (advice []*models.HisPrescriptionProject, err error) {
	err = readDb.Model(&models.HisPrescriptionProject{}).Preload("HisProject", "status = 1").Preload("GoodInfo", "status = 1").Where("user_org_id=? and status=1 and patient_id = ? AND record_date = ?", orgID, patient_id, record_time).Find(&advice).Error
	return
}

func GetAllPcPatientListByList(orgID int64) (patients []*MSchedualPatientVMList, err error) {
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgID, 10) + ":" + ":patient_list_all"
	patient_info_str, _ := redis.Get(key).Result()

	if len(patient_info_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Where("user_org_id=? and status=1 and lapseto = 1", orgID).Find(&patients).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				if len(patients) <= 0 {
					redis.Set(key, "null", time.Second*60*60*18)
				}
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(patients) > 0 {
				//缓存数据
				patient_info_json, err := json.Marshal(&patients)
				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 patients, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if patient_info_str == "null" {
			return nil, nil
		} else {
			json.Unmarshal([]byte(patient_info_str), &patients)
			return patients, nil
		}
	}
}

func GetAllPcAdvicestByList(orgID int64, scheduleDate int64) (advices []*VMDoctorAdvice, err error) {
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgID, 10) + ":" + ":advice_list_all"
	advice_list_str, _ := redis.Get(key).Result()

	if len(advice_list_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Where("status = 1 AND user_org_id = ? AND advice_type = 2 AND advice_date = ? ", orgID, scheduleDate).Find(&advices).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				if len(advices) <= 0 {
					redis.Set(key, "null", time.Second*60*60*18)
				}
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(advices) > 0 {
				//缓存数据
				advice_list_str, err := json.Marshal(&advices)
				if err == nil {
					redis.Set(key, advice_list_str, time.Second*60*60*18)
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
			}
			return advices, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if advice_list_str == "null" {
			return nil, nil
		} else {
			json.Unmarshal([]byte(advice_list_str), &advices)
			return advices, nil
		}

	}
}

func GetAllPcDialysisOrdersByList(orgID int64, scheduleDate int64) (dialysisOrders []*MDialysisOrderVMList, err error) {
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgID, 10) + ":" + ":dialysis_orders_list_all"
	dialysis_orders_list_all, _ := redis.Get(key).Result()

	if len(dialysis_orders_list_all) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).Where("status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, scheduleDate).Find(&dialysisOrders).Error

		if err != nil {
			if err == gorm.ErrRecordNotFound {
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(dialysisOrders) > 0 {
				//缓存数据
				dialysis_orders_list_all, err := json.Marshal(&dialysisOrders)
				if err == nil {
					redis.Set(key, dialysis_orders_list_all, time.Second*60*60*18)
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
			}
			return dialysisOrders, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if dialysis_orders_list_all == "null" {
			return nil, nil
		} else {
			json.Unmarshal([]byte(dialysis_orders_list_all), &dialysisOrders)
			return dialysisOrders, nil
		}

	}
}

func GetAllPcAssessmentAfterDislysisByList(orgID int64, scheduleDate int64) (assessmentAfterDislysis []*AssessmentAfterDislysis, err error) {
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgID, 10) + ":" + ":assessment_after_dislysis_list_all"
	assessment_after_dislysis__all, _ := redis.Get(key).Result()

	if len(assessment_after_dislysis__all) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Where("status = 1  AND user_org_id = ? AND assessment_date = ?", orgID, scheduleDate).Find(&assessmentAfterDislysis).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				if len(assessmentAfterDislysis) <= 0 {
					redis.Set(key, "null", time.Second*60*60*18)
				}
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(assessmentAfterDislysis) > 0 {
				//缓存数据
				assessment_after_dislysis__all, err := json.Marshal(&assessmentAfterDislysis)
				if err == nil {
					redis.Set(key, assessment_after_dislysis__all, time.Second*60*60*18)
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
			}
			return assessmentAfterDislysis, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if assessment_after_dislysis__all == "null" {
			return nil, nil
		} else {
			json.Unmarshal([]byte(assessment_after_dislysis__all), &assessmentAfterDislysis)
			return assessmentAfterDislysis, nil
		}

	}
}

func GetAllPcTreatmentSummarysByList(orgID int64, scheduleDate int64) (treatmentSummarys []*VMTreatmentSummary, err error) {
	redis := RedisClient()
	defer redis.Close()
	key := strconv.FormatInt(orgID, 10) + ":" + ":treatment_summarys_list_all"
	treatment_summarys_all, _ := redis.Get(key).Result()

	if len(treatment_summarys_all) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		err = readDb.Where("status = 1  AND user_org_id = ? AND assessment_date = ?", orgID, scheduleDate).Find(&treatmentSummarys).Error
		if err != nil {
			if err == gorm.ErrRecordNotFound {
				if len(treatment_summarys_all) <= 0 {
					redis.Set(key, "null", time.Second*60*60*18)
				}
				return nil, nil
			} else {
				return nil, err
			}
		} else {
			if len(treatmentSummarys) > 0 {
				//缓存数据
				treatment_summarys_all, err := json.Marshal(&treatmentSummarys)
				if err == nil {
					redis.Set(key, treatment_summarys_all, time.Second*60*60*18)
				}
			} else {
				redis.Set(key, "null", time.Second*60*60*18)
			}
			return treatmentSummarys, nil
		}
	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		if treatment_summarys_all == "null" {
			return nil, nil
		} else {
			json.Unmarshal([]byte(treatment_summarys_all), &treatmentSummarys)
			return treatmentSummarys, nil
		}
	}
}

func UpdateTeamProjectExceStatus(ids []int64, admin_user_id int64, execution_time int64) (err error) {
	ut := writeDb.Begin()
	db := ut.Model(&models.HisPrescriptionProject{})
	err = db.Where("status = 1   AND id IN (?)", ids).Updates(map[string]interface{}{"execution_time": execution_time, "execution_state": 1, "execution_staff": admin_user_id}).Error
	if err != nil {
		ut.Rollback()
		return
	}

	ut.Commit()
	return err

}

func UpdateTeamProjectCheckStatus(ids []int64, patient_id int64, record_date int64, user_org_id int64, admin_user_id int64, check_time int64) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.HisPrescriptionProject{}).Where("status = 1   AND id IN (?) AND patient_id = ? AND user_org_id = ? AND record_date = ?", ids, patient_id, user_org_id, record_date).Updates(map[string]interface{}{"check_time": check_time, "check_state": 1, "checker": admin_user_id}).Error
	if err != nil {
		ut.Rollback()
		return
	}

	ut.Commit()
	return err

}

func GetCheckTeamProject(team_id int64, patient_id int64, record_date int64, user_org_id int64) (ps []*models.HisPrescriptionProject, err error) {
	err = readDb.Model(&models.HisPrescriptionProject{}).Joins("JOIN xt_his_project as p On p.id = his_prescription_project.project_id AND p.cost_classify = 3").Where("his_prescription_project.team_id IN (?) AND his_prescription_project.patient_id = ? AND his_prescription_project.user_org_id = ? AND his_prescription_project.record_date = ? AND his_prescription_project.status = 1", team_id, patient_id, user_org_id, record_date).Find(&ps).Error
	return
}