XT_New/service/patient_service.go

package service

import (
	"XT_New/models"
	"strconv"
	"strings"
	"time"

	"fmt"

	"github.com/jinzhu/gorm"
)

//GetPatientList 返回患者的列表
func GetPatientList(orgID int64, keywords string, page, limit, schedulType, bindingState, lapseto, source, startTime, endTime, contagion, reimbursementWay, isscheduling, isprescription int64, isStartTime, isEndTime bool) (patients []*models.Patients, total int64, err error) {

	db := readDb.Table("xt_patients as p").Where("p.status=1")
	if orgID > 0 {
		db = db.Where("p.user_org_id=?", orgID)
	}

	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("p.name LIKE ? OR p.dialysis_no LIKE ?", likeKey, likeKey)
	}

	if schedulType > 0 {
		db = db.Joins("JOIN xt_schedule as s ON s.patient_id=p.id")
		db = db.Where("s.status=1 and s.schedule_type=?", schedulType)
	}

	if contagion > 0 {
		db = db.Joins("JOIN xt_patients_infectious_diseases as xpid ON xpid.patient_id=p.id")
		db = db.Where("xpid.disease_id=? and xpid.status=1", contagion)
	}

	if isscheduling == 1 {
		db = db.Where("EXISTS (?)", readDb.Table("xt_schedule as iss").Where("iss.patient_id=p.id and iss.status=1").QueryExpr())
	} else if isscheduling == 2 {
		db = db.Where("NOT EXISTS (?)", readDb.Table("xt_schedule as iss").Where("iss.patient_id=p.id and iss.status=1").QueryExpr())
	}
	if isprescription == 1 {
		db = db.Where("EXISTS (?)", readDb.Table("xt_dialysis_prescription as xdp").Where("xdp.patient_id=p.id and xdp.status=1").QueryExpr())
	} else if isprescription == 2 {
		db = db.Where("NOT EXISTS (?)", readDb.Table("xt_dialysis_prescription as xdp").Where("xdp.patient_id=p.id and xdp.status=1").QueryExpr())
	}

	if bindingState > 0 {
		db = db.Where("p.binding_state=?", bindingState)
	}
	if lapseto > 0 {
		db = db.Where("p.lapseto=?", lapseto)
	}
	if source > 0 {
		db = db.Where("p.source=?", source)
	}
	if reimbursementWay > 0 {
		db = db.Where("p.reimbursement_way_id = ?", reimbursementWay)
	}

	if isStartTime {
		db = db.Where("p.created_time>=?", startTime)
	}
	if isEndTime {
		db = db.Where("p.created_time<=?", endTime)
	}

	offset := (page - 1) * limit

	err = db.Order("p.id desc").Select(" p.id, p.user_org_id, p.user_id, p.patient_type, p.dialysis_no, p.admission_number, p.source, p.lapseto, p.partition_id, p.bed_id, p.name, p.alias, p.gender, p.marital_status, p.id_card_no, p.birthday, p.reimbursement_way_id, p.health_care_type, p.health_care_no, p.health_care_due_date, p.height, p.blood_type, p.rh, p.health_care_due_alert_date, p.education_level, p.profession, p.phone, p.home_telephone, p.relative_phone, p.relative_relations, p.home_address, p.work_unit, p.unit_address, p.children, p.receiving_date, p.is_hospital_first_dialysis, p.first_dialysis_date, p.first_dialysis_hospital, p.induction_period, p.initial_dialysis, p.total_dialysis, p.attending_doctor_id, p.head_nurse_id, p.evaluate, p.diagnose, p.remark, p.registrars_id, p.registrars, p.qr_code, p.binding_state, p.status, p.created_time, p.updated_time,p.user_sys_before_count").Group("p.id").Count(&total).Offset(offset).Limit(limit).Find(&patients).Error
	return
}

//GetAllPatientList 返回全部患者的列表
func GetAllPatientList(orgID int64) (patients []*models.Patients, total int64, err error) {

	db := readDb.Table("xt_patients as p").Where("p.user_org_id=? and p.status=1", orgID)

	err = db.Select(" p.id, p.user_org_id, p.user_id, p.patient_type, p.dialysis_no, p.admission_number, p.source, p.lapseto, p.partition_id, p.bed_id, p.name, p.alias, p.gender, p.marital_status, p.id_card_no, p.birthday, p.reimbursement_way_id, p.health_care_type, p.health_care_no, p.health_care_due_date, p.height, p.blood_type, p.rh, p.health_care_due_alert_date, p.education_level, p.profession, p.phone, p.home_telephone, p.relative_phone, p.relative_relations, p.home_address, p.work_unit, p.unit_address, p.children, p.receiving_date, p.is_hospital_first_dialysis, p.first_dialysis_date, p.first_dialysis_hospital, p.induction_period, p.initial_dialysis, p.total_dialysis, p.attending_doctor_id, p.head_nurse_id, p.evaluate, p.diagnose, p.remark, p.registrars_id, p.registrars, p.qr_code, p.binding_state, p.status, p.created_time, p.updated_time").Count(&total).Find(&patients).Error
	return
}

func GetPatientListByUpdateTime(orgID int64, syncTime int64, force int64) (patients []*models.PatientListForFaceList, total int64, err error) {
	db := readDb.Model(&models.PatientListForFaceList{}).Where("user_org_id=?  AND  status=1  AND  avatar <> 'https://images.shengws.com/201809182128222.png' AND avatar <> 'https://images.shengws.com/201809182128111.png' AND avatar <> ''", orgID)
	if force == 0 {
		db = db.Where("updated_time >= ?", syncTime)
	}
	err = db.Count(&total).Find(&patients).Error
	return
}

func GetPatientListBySchedules(orgID int64, syncTime int64) (patients []*models.SchedulePatients, total int64, err error) {
	db := readDb.Model(&models.SchedulePatients{}).Where("user_org_id=?  AND  status=1  AND  schedule_date = ?", orgID,syncTime).Preload("Patient", "status = 1 AND user_org_id = ? ", orgID,)
	err = db.Count(&total).Find(&patients).Error
	return
}

func GetPatientListById(orgID int64, patientId int64) (patients models.PatientListForFace, err error) {
	err = readDb.Model(&models.PatientListForFaceList{}).Where("user_org_id=? and id = ? and status=1", orgID, patientId).First(&patients).Error
	return
}

func GetPatientCount(orgID int64) (total int64) {
	readDb.Model(&models.Patients{}).Where("user_org_id=? and status=1", orgID).Count(&total)
	return
}

func GetLapsetoPatientCount(orgID int64, lapseto int64) (total int64) {
	readDb.Model(&models.Patients{}).Where("user_org_id=? and lapseto=? and status=1", orgID, lapseto).Count(&total)
	return
}

func ChechLastDialysisNo(orgID int64) (dialysisNo int64) {
	var patient models.Patients
	err := readDb.Model(&models.Patients{}).Where("status=1 and user_org_id=?", orgID).Order("dialysis_no desc").First(&patient).Error
	if err != nil {
		return
	}

	if patient.ID == 0 {
		return
	}
	dialysisNo, _ = strconv.ParseInt(patient.DialysisNo, 10, 64)
	return
}

func FindPatientByDialysisNo(orgID int64, dialysisNo string) (patient models.Patients, err error) {
	err = readDb.Model(&models.Patients{}).Where("status=1 and user_org_id=? and dialysis_no=?", orgID, dialysisNo).First(&patient).Error
	return
}

func FindPatientByIdCardNo(orgID int64, idCardNo string) (patient models.Patients, err error) {
	err = readDb.Model(&models.Patients{}).Where("status=1 and user_org_id=? and id_card_no=?", orgID, idCardNo).First(&patient).Error
	return
}
func FindPatientByMobile(orgID int64, mobile string) (patient models.Patients, err error) {
	err = readDb.Model(&models.Patients{}).Where("phone=? and user_org_id=? and status=1", mobile, orgID).First(&patient).Error
	return
}

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

func FindPatientByIdTwo(orgID int64, id int64) (patient models.XtPatientsNew, err error) {

	err = readDb.Model(&models.XtPatientsNew{}).Where("blood_id = ? and user_org_id = ? and status =1", id, orgID).First(&patient).Error
	return
}

func FindPatientByIdWithDiseases(orgID int64, id int64) (patient models.Patients, err error) {
	err = readDb.Model(&models.Patients{}).Preload("Contagions", "status = 1").Preload("Diseases", "status = 1").Where("id = ? and user_org_id=? and status=1", id, orgID).First(&patient).Error
	return
}

func FindPatientWithDeviceByNo(orgID int64, no string, 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("user_org_id = ? AND schedule_date = ? ", orgID, time)
	}).Preload("InfectiousDiseases", "status = 1").Where("user_org_id=? and dialysis_no = ? and status=1", orgID, no).First(&patient).Error
	return
}

func CreatePatient(patient *models.Patients, contagions []int64, diseases []int64) (err error) {

	user, _ := GetSgjUserByMobild(patient.Phone)
	customer, _ := GetSgjCoustomerByMobile(patient.UserOrgId, patient.Phone)

	utx := writeDb.Begin()
	btx := writeUserDb.Begin()

	if user.ID == 0 {

		user.Mobile = patient.Phone
		user.Avatar = patient.Avatar
		user.AvatarThumb = patient.Avatar
		user.Birthday = patient.Birthday
		user.Username = patient.Name
		user.Gender = patient.Gender
		user.Sources = 11
		user.Introduce = patient.Remark
		user.Status = 1
		user.UpdatedTime = patient.UpdatedTime
		user.CreatedTime = patient.CreatedTime
		err = btx.Create(&user).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}
	patient.UserId = user.ID

	if customer == nil {
		err = btx.Create(&models.SgjCustomer{
			UserOrgId:   patient.UserOrgId,
			UserId:      user.ID,
			Mobile:      patient.Phone,
			Name:        patient.Name,
			Gender:      patient.Gender,
			Birthday:    patient.Birthday,
			Sources:     11,
			Status:      1,
			CreatedTime: patient.CreatedTime,
			UpdatedTime: patient.UpdatedTime,
			Avatar:      patient.Avatar,
			Remark:      patient.Remark,
		}).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}

	err = utx.Create(patient).Error
	if err != nil {
		utx.Rollback()
		btx.Rollback()
		return
	}

	var lapseto models.PatientLapseto
	lapseto.PatientId = patient.ID
	lapseto.LapsetoType = patient.Lapseto
	lapseto.CreatedTime = patient.CreatedTime
	lapseto.UpdatedTime = patient.CreatedTime
	lapseto.Status = 1
	lapseto.LapsetoTime = patient.CreatedTime

	err = utx.Create(&lapseto).Error
	if err != nil {
		utx.Rollback()
		btx.Rollback()
		return
	}

	if len(contagions) > 0 {
		thisSQL := "INSERT INTO xt_patients_infectious_diseases (patient_id, disease_id, status, created_time, updated_time) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, contagion := range contagions {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, patient.ID)
			insertData = append(insertData, contagion)
			insertData = append(insertData, 1)
			insertData = append(insertData, patient.CreatedTime)
			insertData = append(insertData, patient.UpdatedTime)
		}
		thisSQL += strings.Join(insertParams, ", ")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}
	if len(diseases) > 0 {
		thisSQL := "INSERT INTO xt_patients_chronic_diseases (patient_id, disease_id, status, created_time, updated_time) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, disease := range diseases {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, patient.ID)
			insertData = append(insertData, disease)
			insertData = append(insertData, 1)
			insertData = append(insertData, patient.CreatedTime)
			insertData = append(insertData, patient.UpdatedTime)
		}
		thisSQL += strings.Join(insertParams, ", ")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}
	utx.Commit()
	btx.Commit()

	return
}

func GetLastPatientData(orgid int64) (models.Patients, error) {
	patients := models.Patients{}
	err := XTReadDB().Model(&patients).Where("user_org_id = ? and status = 1", orgid).Last(&patients).Error
	return patients, err
}

func CreatePatientsNew(patientsNew *models.XtPatientsNew) error {

	err := XTWriteDB().Model(&patientsNew).Create(&patientsNew).Error
	return err
}

func EditPatientLapseto(patient *models.Patients, lapseto *models.PatientLapseto) (err error) {
	utx := writeDb.Begin()
	err = utx.Model(&models.Patients{}).Where("id=?", patient.ID).Update(map[string]interface{}{"lapseto": patient.Lapseto}).Error
	//err = utx.Model(&models.PatientLapseto{}).Where("id=?", patient.ID).Update(map[string]interface{}{"lapseto_type": patient.Lapseto, "lapseto_time": time.Now().Unix(), "updated_time": time.Now().Unix()}).Error
	if err != nil {
		utx.Rollback()
		return
	}
	err = utx.Create(lapseto).Error
	if err != nil {
		utx.Rollback()
		return
	}
	// 删除排班和排班模板信息
	if lapseto.LapsetoType == 2 {
		now := time.Now()
		deleteScheduleErr := utx.Model(&models.PatientSchedule{}).Where("patient_id = ? AND schedule_date >= ? AND status = 1", patient.ID, lapseto.LapsetoTime).Updates(map[string]interface{}{
			"status":       0,
			"updated_time": now.Unix(),
		}).Error
		if deleteScheduleErr != nil {
			utx.Rollback()
			err = deleteScheduleErr
			return
		}

		deleteSchTempItemErr := utx.Model(&models.PatientScheduleTemplateItem{}).Where("patient_id = ? AND status = 1", patient.ID).Updates(map[string]interface{}{
			"status": 0,
			"mtime":  now.Unix(),
		}).Error
		if deleteSchTempItemErr != nil {
			utx.Rollback()
			err = deleteSchTempItemErr
			return
		}
	}
	utx.Commit()
	return
}

func UpdatePatient(patient *models.Patients, contagions []int64, diseases []int64) (err error) {
	// if len(contagions) > 0 || len(diseases) > 0 {
	utx := writeDb.Begin()
	err = utx.Save(patient).Error
	if err != nil {
		utx.Rollback()
		return
	}
	err = utx.Model(&models.InfectiousDiseases{}).Where("patient_id=?", patient.ID).Update(map[string]interface{}{"Status": 2, "UpdatedTime": patient.UpdatedTime}).Error
	fmt.Println("err", err)
	if err != nil {
		utx.Rollback()
		return
	}
	if len(contagions) > 0 && patient.IsInfectious == 2 {
		thisSQL := "INSERT INTO xt_patients_infectious_diseases (patient_id, disease_id, status, created_time, updated_time) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, contagion := range contagions {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, patient.ID)
			insertData = append(insertData, contagion)
			insertData = append(insertData, 1)
			insertData = append(insertData, time.Now().Unix())
			insertData = append(insertData, time.Now().Unix())
		}
		thisSQL += strings.Join(insertParams, ", ")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			return
		}
	}

	err = utx.Model(&models.ChronicDiseases{}).Where("patient_id=?", patient.ID).Update(map[string]interface{}{"Status": 2, "UpdatedTime": patient.UpdatedTime}).Error
	if err != nil {
		utx.Rollback()
		return
	}
	if len(diseases) > 0 {
		thisSQL := "INSERT INTO xt_patients_chronic_diseases (patient_id, disease_id, status, created_time, updated_time) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, disease := range diseases {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, patient.ID)
			insertData = append(insertData, disease)
			insertData = append(insertData, 1)
			insertData = append(insertData, time.Now().Unix())
			insertData = append(insertData, time.Now().Unix())
		}
		thisSQL += strings.Join(insertParams, ", ")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			return
		}
	}
	utx.Commit()

	// } else {
	// 	err = writeDb.Save(patient).Error
	// }
	return
}

func UpdatePatientLapseto(patientid int64, lapseto models.PatientLapseto) error {
	err := XTWriteDB().Model(&lapseto).Where("patient_id = ?", patientid).Updates(map[string]interface{}{"lapseto_type": lapseto.LapsetoType, "lapseto_time": time.Now().Unix(), "updated_time": time.Now().Unix()}).Error
	return err
}

func UpdatepatientTwo(patientsNew *models.XtPatientsNew, id int64) error {

	err := XTWriteDB().Model(&patientsNew).Where("blood_id = ?", id).Update(map[string]interface{}{"user_org_id": patientsNew.UserOrgId, "user_id": patientsNew.UserId, "avatar": patientsNew.Avatar, "patient_type": patientsNew.Avatar, "dialysis_no": patientsNew.DialysisNo, "admission_number": patientsNew.AdmissionNumber, "source": patientsNew.Source, "lapseto": patientsNew.Lapseto, "partition_id": patientsNew.PartitionId, "bed_id": patientsNew.BedId, "name": patientsNew.Name, "alias": patientsNew.Alias, "gender": patientsNew.Gender, "marital_status": patientsNew.MaritalStatus, "id_card_no": patientsNew.IdCardNo, "birthday": patientsNew.Birthday, "reimbursement_way_id": patientsNew.ReimbursementWayId, "health_care_type": patientsNew.HealthCareType, "health_care_no": patientsNew.HealthCareType, "health_care_due_date": patientsNew.HealthCareType, "height": patientsNew.Height, "blood_type": patientsNew.BloodType, "rh": patientsNew.Rh, "health_care_due_alert_date": patientsNew.HealthCareDueAlertDate, "education_level": patientsNew.EducationLevel, "profession": patientsNew.Profession, "phone": patientsNew.Phone, "home_telephone": patientsNew.HomeTelephone, "relative_phone": patientsNew.RelativePhone, "relative_relations": patientsNew.RelativeRelations, "home_address": patientsNew.HomeAddress, "work_unit": patientsNew.WorkUnit, "unit_address": patientsNew.UnitAddress, "children": patientsNew.Children, "receiving_date": patientsNew.ReceivingDate, "is_hospital_first_dialysis": patientsNew.IsHospitalFirstDialysis, "first_dialysis_date": patientsNew.FirstDialysisDate, "first_dialysis_hospital": patientsNew.FirstDialysisHospital, "predialysis_condition": patientsNew.PredialysisCondition, "pre_hospital_dialysis_frequency": patientsNew.PreHospitalDialysisFrequency, "pre_hospital_dialysis_times": patientsNew.PreHospitalDialysisFrequency, "hospital_first_dialysis_date": patientsNew.HospitalFirstDialysisDate, "induction_period": patientsNew.InductionPeriod, "initial_dialysis": patientsNew.InitialDialysis, "total_dialysis": patientsNew.TotalDialysis, "attending_doctor_id": patientsNew.AttendingDoctorId, "head_nurse_id": patientsNew.HeadNurseId, "evaluate": patientsNew.Evaluate, "diagnose": patientsNew.Diagnose, "remark": patientsNew.Remark, "registrars_id": patientsNew.RegistrarsId, "registrars": patientsNew.Registrars, "qr_code": patientsNew.QrCode, "binding_state": patientsNew.BindingState, "patient_complains": patientsNew.PatientComplains, "present_history": patientsNew.PresentHistory, "past_history": patientsNew.PastHistory, "temperature": patientsNew.Temperature,
		"pulse": patientsNew.Pulse, "respiratory": patientsNew.Respiratory, "sbp": patientsNew.Sbp, "dbp": patientsNew.Dbp, "nation": patientsNew.Nation, "native_place": patientsNew.NativePlace, "age": patientsNew.Age, "infectious_next_record_time": patientsNew.InfectiousNextRecordTime, "is_infectious": patientsNew.IsInfectious, "remind_cycle": patientsNew.RemindCycle, "response_result": patientsNew.ResponseResult, "is_open_remind": patientsNew.IsOpenRemind, "first_treatment_date": patientsNew.FirstTreatmentDate, "dialysis_age": patientsNew.DialysisAge, "expense_kind": patientsNew.ExpenseKind, "tell_phone": patientsNew.ExpenseKind, "contact_name": patientsNew.ContactName, "blood_patients": patientsNew.BloodPatients, "slow_patients": patientsNew.SlowPatients, "member_patients": patientsNew.MemberPatients, "ecommer_patients": patientsNew.EcommerPatients}).Error
	return err
}

func GetLastInfectionRecord(id int64, org_id int64, project_id int64, date int64) (inspection models.Inspection, err error) {
	err = readDb.Model(&models.Inspection{}).Where("patient_id=? and status=1 and org_id = ? and project_id = ? AND inspect_date = ? ", id, org_id, project_id, date).Last(&inspection).Error
	return
}

func GetAllInfectionRecord(date int64, org_id int64, patient_id int64, project_id int64) (inspection []*models.Inspection, err error) {
	err = readDb.Model(&models.Inspection{}).Where("patient_id=? and status=1 and org_id = ? and project_id = ? and inspect_date = ?", patient_id, org_id, project_id, date).Find(&inspection).Error
	return
}

func GetPatientDiseases(id int64) []int64 {
	var dis []models.ChronicDiseases
	ids := make([]int64, 0)
	err := readDb.Model(&models.ChronicDiseases{}).Where("patient_id=? and status=1", id).Find(&dis).Error
	if err != nil || len(dis) == 0 {
		return ids
	}
	for _, item := range dis {
		ids = append(ids, item.DiseaseId)
	}
	return ids
}
func GetPatientContagions(id int64) []int64 {
	var cis []models.InfectiousDiseases
	ids := make([]int64, 0)
	err := readDb.Model(&models.InfectiousDiseases{}).Where("patient_id=? and status=1", id).Find(&cis).Error
	if err != nil || len(cis) == 0 {
		return ids
	}
	for _, item := range cis {
		ids = append(ids, item.DiseaseId)
	}
	return ids
}

func FindPatientDialysisSolutionByMode(orgID int64, patientID, modeId int64) (solution models.DialysisSolution, err error) {
	err = readDb.Model(&models.DialysisSolution{}).Where("user_org_id=? and patient_id=? and mode_id=? and parent_id=0 and status=1", orgID, patientID, modeId).First(&solution).Error
	return
}

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

func FindPatientDialysisSolutionChild(orgID int64, id int64) (solution models.DialysisSolution, err error) {
	err = readDb.Model(&models.DialysisSolution{}).Where("parent_id = ? and status=1 and user_org_id=?", id, orgID).First(&solution).Error
	return
}

func CreatePatientDialysisSolution(solution *models.DialysisSolution) (err error) {
	err = writeDb.Create(solution).Error
	return
}

func UpdatePatientDialysisSolution(solution *models.DialysisSolution) (err error) {
	err = writeDb.Save(solution).Error
	return
}

//GetPatientDialysisSolutionList 返回患者透析方案的列表
func GetPatientDialysisSolutionList(orgID int64, patientID int64, page, limit int64) (solutions []*models.DialysisSolution, total int64, err error) {

	offset := (page - 1) * limit
	db := readDb.Table("xt_dialysis_solution as ds").Where("ds.status=1")
	if orgID > 0 {
		db = db.Where("ds.user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("ds.patient_id=?", patientID)
	}
	db = db.Count(&total).Offset(offset).Limit(limit)

	err = db.Order("id desc").Find(&solutions).Error
	if err != nil {
		return
	}
	if len(solutions) > 0 {
		nilNameIds := make([]int64, 0)
		for _, solution := range solutions {
			if len(solution.ModeName) == 0 {
				nilNameIds = append(nilNameIds, solution.ModeId)
			}
		}
		if len(nilNameIds) > 0 {
			var modes []*models.TreatmentMode
			err = readDb.Model(&models.TreatmentMode{}).Where("id IN (?)", nilNameIds).Find(&modes).Error
			if err != nil {
				return
			}

			modesMap := make(map[int64]models.TreatmentMode, 0)
			for _, mode := range modes {
				modesMap[mode.ID] = *mode
			}
			for index, solution := range solutions {
				if _, exixt := modesMap[solution.ModeId]; exixt && len(solution.ModeName) == 0 {
					solutions[index].ModeName = modesMap[solution.ModeId].Name
				}
			}
		}
	}
	return
}

//GetPatientDryWeightAdjustList 返回患者调整干体重的列表
func GetPatientDryWeightAdjustList(orgID int64, patientID int64, page int64, limit int64) (weights []*models.DryWeightAdjust, total int64, err error) {
	db := readDb.Table("xt_dry_weight_adjust as dwa").Where("dwa.status=1")
	if orgID > 0 {
		db = db.Where("dwa.user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("dwa.patient_id=?", patientID)
	}

	db = db.Select("dwa.id, dwa.user_org_id, dwa.patient_id, dwa.weight, dwa.adjusted_value, dwa.doctor, dwa.registrars_id, dwa.remark, dwa.status, dwa.created_time, dwa.updated_time").Count(&total).Order("id desc")

	if page > 0 && limit > 0 {
		offset := (page - 1) * limit
		db = db.Offset(offset).Limit(limit)
	}
	err = db.Find(&weights).Error
	return
}

func CreateDryWeightAdjust(m *models.DryWeightAdjust) (err error) {
	err = writeDb.Create(m).Error
	return
}

func FindPatientLastDryWeightAdjust(orgID int64, id int64) (weight models.DryWeightAdjust, err error) {
	err = readDb.Model(&models.DryWeightAdjust{}).Where("user_org_id=? and patient_id=? and status=1", orgID, id).Order("id desc").First(&weight).Error
	return
}

func CreateDoctorAdvice(m *models.DoctorAdvice) (err error) {
	return writeDb.Create(m).Error
}
func GetMaxAdviceGroupID(orgId int64) (group int64) {
	var advice models.DoctorAdvice
	err := readDb.Table("his_doctor_advice_info").Where("user_org_id=?", orgId).Select("max(groupno) as groupno").First(&advice).Error
	if err != nil {
		fmt.Println(err)
		group = 0
	}
	group = advice.GroupNo
	return
}
func CreateGroupAdvice(orgId int64, group int64, advices []*models.GroupAdvice) (err error) {
	if group == 0 {
		group = GetMaxAdviceGroupID(orgId) + 1
	}

	tx := writeDb.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	for _, advice := range advices {
		advice.GroupNo = group
		if err = tx.Create(advice).Error; err != nil {
			tx.Rollback()
			return
		}
	}
	tx.Commit()
	return
}

func CreateMGroupAdvice(orgId int64, advices []*models.GroupAdvice, groupNo int64) (list []*models.GroupAdvice, err error) {
	if groupNo <= 0 {
		group := GetMaxAdviceGroupID(orgId)
		groupNo = group + 1
	}
	tx := writeDb.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	for _, advice := range advices {
		advice.GroupNo = groupNo
		if err = tx.Create(advice).Error; err != nil {
			tx.Rollback()
			return
		}
		list = append(list, advice)
		if len(advice.Children) > 0 {
			for _, child := range advice.Children {
				child.GroupNo = groupNo
				child.ParentId = advice.ID
				fmt.Println(child)
				if err = tx.Create(&child).Error; err != nil {
					tx.Rollback()
					return
				}
				list = append(list, child)
			}
		}

	}
	tx.Commit()
	return
}

func UpdateDoctorAdvice(m *models.DoctorAdvice) (err error) {
	return writeDb.Save(m).Error
}

func StopGroupAdvice(orgId int64, groupNo int64, m *models.DoctorAdvice) (err error) {
	err = writeDb.Model(&models.DoctorAdvice{}).Where("user_org_id=? and groupno=?", orgId, groupNo).Update(map[string]interface{}{"UpdatedTime": m.UpdatedTime, "StopState": 1, "StopReason": m.StopReason, "StopDoctor": m.StopDoctor, "StopTime": m.StopTime}).Error
	if err != nil {
		return
	}
	return
}

func StopDoctorAdvice(m *models.DoctorAdvice) (err error) {

	ut := writeDb.Begin()
	err = ut.Save(m).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("parent_id=?", m.ID).Update(map[string]interface{}{"UpdatedTime": m.UpdatedTime, "StopState": 1, "StopReason": m.StopReason, "StopDoctor": m.StopDoctor, "StopTime": m.StopTime, "Modifier": m.Modifier}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return
}

func DeleteSolution(m *models.DialysisSolution) (err error) {

	if m.ParentId > 0 {
		return writeDb.Save(m).Error
	} else {
		ut := writeDb.Begin()
		err = ut.Save(m).Error
		if err != nil {
			ut.Rollback()
			return
		}
		err = ut.Model(&models.DialysisSolution{}).Where("parent_id=?", m.ID).Update(map[string]interface{}{"UpdatedTime": m.UpdatedTime, "Status": 0}).Error
		if err != nil {
			ut.Rollback()
			return
		}
		ut.Commit()
	}

	return
}

func DeleteDoctorAdvice(m *models.DoctorAdvice) (err error) {

	if m.ParentId > 0 {
		return writeDb.Save(m).Error
	} else {
		ut := writeDb.Begin()
		err = ut.Save(m).Error
		if err != nil {
			ut.Rollback()
			return
		}
		err = ut.Model(&models.DoctorAdvice{}).Where("parent_id=? AND user_org_id = ?", m.ID, 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 DeleteGroupAdvice(orgId int64, groupNo int64, admin_user_id int64) (err error) {
	err = writeDb.Model(&models.DoctorAdvice{}).Where("user_org_id = ? and groupno = ?", orgId, groupNo).Update(map[string]interface{}{"UpdatedTime": time.Now().Unix(), "Status": 0, "Modifier": admin_user_id}).Error
	if err != nil {
		return
	}
	return
}

func FindDoctorAdvice(orgID, id int64) (advice models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("id = ? and user_org_id=? and status = 1", id, orgID).First(&advice).Error
	return
}
func FindDoctorAdviceByGroupNo(orgID, groupNo int64) (advice models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("groupno = ? and user_org_id=? and status = 1", groupNo, orgID).First(&advice).Error
	return
}
func GetDoctorAdviceList(orgID, patientID, advice_type, stop, start, end int64, keywords string) (advices []*models.DoctorAdvices, total int64, err error) {

	db := readDb.Table("xt_doctor_advice as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Print("table", table)
	if orgID > 0 {
		db = db.Where("x.user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("x.patient_id = ?", patientID)
	}
	if advice_type > 0 {
		db = db.Where("x.advice_type = ?", advice_type)
	} else if advice_type == 0 {
		db = db.Where("x.advice_type in (?)", []int{1, 3})
	}

	if stop == 1 {
		db = db.Where("(x.stop_state=? or x.execution_state=?)", stop, stop)
	} else if stop == 2 {
		db = db.Where("x.stop_state=? and x.execution_state=?", stop, stop)
	}

	if start != 0 {
		db = db.Where("x.start_time>=?", start)
	}
	if end != 0 {
		db = db.Where("start_time<=?", end)
	}
	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("x.advice_name LIKE ?", likeKey)
	}
	err = db.Group("x.id").Count(&total).Select("x.id, x.user_org_id, x.patient_id, x.advice_type, x.advice_date, x.record_date, x.start_time, x.advice_name,x.advice_desc, x.reminder_date, x.drug_spec, x.drug_spec_unit, x.single_dose, x.single_dose_unit, x.prescribing_number, x.prescribing_number_unit, x.delivery_way, x.execution_frequency, x.advice_doctor, x.status, x.created_time,x.updated_time, x.advice_affirm, x.remark, x.stop_time, x.stop_reason, x.stop_doctor, x.stop_state, x.parent_id, x.execution_time, x.execution_staff, x.execution_state, x.checker, x.check_state, x.check_time, x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.parent_id,r.user_name, IF(x.parent_id > 0, x.parent_id, x.id) as advice_order").Joins("Left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.advice_doctor").Order("start_time desc, groupno desc, advice_order desc, id asc").Scan(&advices).Error
	fmt.Print("err", err)
	return
}

func GetDoctorAdviceListOne(orgID, patientID, advice_type, stop, start, end int64, keywords string, page int64, limit int64) (advices []*models.DoctorAdvices, total int64, err error) {

	db := readDb.Table("xt_doctor_advice as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Print("table", table)
	if orgID > 0 {
		db = db.Where("x.user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("x.patient_id = ?", patientID)
	}
	if advice_type == 1 && advice_type > 0 {
		db = db.Where("x.advice_type = ?", advice_type)
	}
	if advice_type == 3 && advice_type > 0 {
		db = db.Where("x.advice_type = 2 or x.advice_type = 3")
	}
	if stop == 1 {
		db = db.Where("(x.stop_state=? or x.execution_state=?)", stop, stop)
	} else if stop == 2 {
		db = db.Where("x.stop_state=? and x.execution_state=?", stop, stop)
	}

	if start != 0 {
		db = db.Where("x.start_time>=?", start)
	}
	if end != 0 {
		db = db.Where("start_time<=?", end)
	}
	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("x.advice_name LIKE ?", likeKey)
	}
	offset := (page - 1) * limit
	err = db.Group("x.id").Count(&total).Offset(offset).Limit(limit).Select("x.id, x.user_org_id, x.patient_id, x.advice_type, x.advice_date, x.record_date, x.start_time, x.advice_name,x.advice_desc, x.reminder_date, x.drug_spec, x.drug_spec_unit, x.single_dose, x.single_dose_unit, x.prescribing_number, x.prescribing_number_unit, x.delivery_way, x.execution_frequency, x.advice_doctor, x.status, x.created_time,x.updated_time, x.advice_affirm, x.remark, x.stop_time, x.stop_reason, x.stop_doctor, x.stop_state, x.parent_id, x.execution_time, x.execution_staff, x.execution_state, x.checker, x.check_state, x.check_time, x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.parent_id,r.user_name, IF(x.parent_id > 0, x.parent_id, x.id) as advice_order").Joins("Left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.advice_doctor").Order("start_time desc, groupno desc, advice_order desc, id asc").Scan(&advices).Error
	fmt.Print("err", err)
	return
}

func GetDoctorAdviceListTwo(orgID int64, patientID int64, advice_type int64, stop int64, start int64, end int64, keywords string, limit int64, page int64) (advices []*models.DoctorAdvices, total int64, err error) {

	db := readDb.Table("xt_doctor_advice as x").Where("x.status = 1")
	table := UserReadDB().Table("sgj_user_admin_role as r")
	fmt.Println(table)
	if orgID > 0 {
		db = db.Where("x.user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("x.patient_id = ?", patientID)
	}
	if advice_type == 1 {
		db = db.Where("x.advice_type = ?", advice_type)
	}
	if advice_type == 3 {
		db = db.Where("x.advice_type <> 1")
	}

	if stop == 1 {
		db = db.Where("(x.stop_state=? or x.execution_state=?)", stop, stop)
	} else if stop == 2 {
		db = db.Where("x.stop_state=? and x.execution_state=?", stop, stop)
	}

	if start != 0 {
		db = db.Where("x.start_time>=?", start)
	}
	if end != 0 {
		db = db.Where("start_time<=?", end)
	}
	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("x.advice_name LIKE ?", likeKey)
	}
	offset := (page - 1) * limit
	err = db.Order("x.start_time desc").Group("x.start_time").Count(&total).Offset(offset).Limit(limit).Select("x.id, x.user_org_id, x.patient_id, x.advice_type, x.advice_date, x.record_date, x.start_time, x.advice_name,x.advice_desc, x.reminder_date, x.drug_spec, x.drug_spec_unit, x.single_dose, x.single_dose_unit, x.prescribing_number, x.prescribing_number_unit, x.delivery_way, x.execution_frequency, x.advice_doctor, x.status, x.created_time,x.updated_time, x.advice_affirm, x.remark, x.stop_time, x.stop_reason, x.stop_doctor, x.stop_state, x.parent_id, x.execution_time, x.execution_staff, x.execution_state, x.checker, x.check_state, x.check_time, x.groupno,x.remind_type,x.frequency_type,x.day_count,x.week_day,x.parent_id,r.user_name, IF(x.parent_id > 0, x.parent_id, x.id) as advice_order").Joins("Left join sgj_users.sgj_user_admin_role as r on r.admin_user_id = x.advice_doctor").Scan(&advices).Error
	fmt.Print("错误是什么", err)
	return

}

func GetDoctorAdvicePageList(orgID, patientID, advice_type, stop, start, end int64, keywords string, page, limit int64) (advices []*models.DoctorAdvice, total int64, err error) {

	offset := (page - 1) * limit

	db := readDb.Model(&models.DoctorAdvice{}).Where("status=1")
	if orgID > 0 {
		db = db.Where("user_org_id=?", orgID)
	}
	if patientID > 0 {
		db = db.Where("patient_id = ?", patientID)
	}
	if advice_type > 0 {
		db = db.Where("advice_type = ?", advice_type)
	}
	if stop == 1 {
		db = db.Where("(stop_state=? or execution_state=?) and parent_id=0", stop, stop)
	} else if stop == 2 {
		db = db.Where("stop_state=? and execution_state=?", stop, stop)
	}

	if start != 0 {
		db = db.Where("start_time>=?", start)
	}
	if end != 0 {
		db = db.Where("start_time<=?", end)
	}
	if len(keywords) > 0 {
		likeKey := "%" + keywords + "%"
		db = db.Where("advice_name LIKE ?", likeKey)
	}
	err = db.Count(&total).Select("id,user_org_id,patient_id,advice_type,advice_date,start_time,advice_name,advice_desc,reminder_date,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 IF(parent_id>0, parent_id, id) as advice_order").Order("advice_order desc, id").Offset(offset).Limit(limit).Scan(&advices).Error
	return
}
func CreateSubDoctorAdvice(advices []*models.DoctorAdvice) (err error) {
	if len(advices) > 0 {
		utx := writeDb.Begin()
		if len(advices) > 0 {
			thisSQL := "INSERT INTO xt_doctor_advice (single_dose_unit, prescribing_number, prescribing_number_unit, advice_name, advice_desc,single_dose,created_time,updated_time,patient_id,parent_id,user_org_id,record_date,advice_type,drug_spec_unit) VALUES "
			insertParams := make([]string, 0)
			insertData := make([]interface{}, 0)
			for _, advice := range advices {
				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
				insertData = append(insertData, advice.SingleDoseUnit)
				insertData = append(insertData, advice.PrescribingNumber)
				insertData = append(insertData, advice.PrescribingNumberUnit)
				insertData = append(insertData, advice.AdviceName)
				insertData = append(insertData, advice.AdviceDesc)
				insertData = append(insertData, advice.SingleDose)
				insertData = append(insertData, advice.CreatedTime)
				insertData = append(insertData, advice.UpdatedTime)
				insertData = append(insertData, advice.PatientId)
				insertData = append(insertData, advice.ParentId)
				insertData = append(insertData, advice.UserOrgId)
				insertData = append(insertData, advice.RecordDate)
				insertData = append(insertData, 2)
				insertData = append(insertData, advice.DrugSpecUnit)

			}
			thisSQL += strings.Join(insertParams, ", ")
			err = utx.Exec(thisSQL, insertData...).Error
			if err != nil {
				utx.Rollback()
				return
			}
		}
		utx.Commit()
	}
	return

}

func GetPatientDialysisRecord(orgID, patientID int64, page, limit, start, end, mode_id int64) ([]*models.PatientDialysisRecord, int64, error) {

	offset := (page - 1) * limit
	var total int64
	var err error
	var orders []*models.PatientDialysisRecord

	// err = readDb.Table("xt_dialysis_order as do").
	// Preload("DialysisPrescription", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
	// Preload("PredialysisEvaluation", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
	// Preload("AssessmentAfterDislysis", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
	// Preload("TreatmentSummary", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
	// Joins("JOIN xt_schedule as s ON s.patient_id=? and FROM_UNIXTIME(s.schedule_date, '%Y-%m-%d')=FROM_UNIXTIME(do.dialysis_date, '%Y-%m-%d')", patientID).
	// Joins("JOIN xt_device_zone as dz ON dz.org_id = ? and dz.id=s.partition_id", orgID).
	// Where("do.patient_id=? and do.user_org_id=? and do.stage = 2 and do.status=1", patientID, orgID).Count(&total).Offset(offset).Limit(limit).Order("do.dialysis_date desc").Select(" do.id, do.dialysis_date, do.user_org_id, do.patient_id, do.prescription_id, do.stage, do.remark, do.status, do.created_time, do.updated_time, s.schedule_type, s.partition_id, dz.name as partition_name").Find(&orders).Error

	db := readDb.Table("xt_dialysis_order as do").
		Preload("DialysisPrescription", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
		Preload("PredialysisEvaluation", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
		Preload("DialysisPrescription", func(db *gorm.DB) *gorm.DB {
			return readDb.Where("patient_id=? and user_org_id=? and status=1", patientID, orgID).Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
				return readUserDb.Where("status = 1")
			})
		}).
		Preload("AssessmentAfterDislysis", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
		Preload("TreatmentSummary", "patient_id=? and user_org_id=? and status=1", patientID, orgID).
		Preload("Device", "org_id=? and status=1", orgID).
		Preload("UserAdminRole", func(db *gorm.DB) *gorm.DB {
			return readUserDb.Where("org_id=? and status = 1", orgID)
		}).
		Joins("JOIN xt_schedule as s ON s.patient_id=? and FROM_UNIXTIME(s.schedule_date, '%Y-%m-%d')=FROM_UNIXTIME(do.dialysis_date, '%Y-%m-%d')", patientID).
		Joins("JOIN xt_device_zone as dz ON dz.org_id = ? and dz.id=s.partition_id", orgID).
		Where("do.patient_id=? and do.user_org_id=? and do.stage = 2 and do.status=1", patientID, orgID).Group("s.schedule_date")

	if start != 0 {
		db = db.Where("do.dialysis_date>=?", start)
	}
	if end != 0 {
		db = db.Where("do.dialysis_date<=?", end)
	}
	if mode_id > 0 {
		db = db.Joins("JOIN xt_dialysis_prescription as dp ON dp.record_id=do.id")
		db = db.Where("dp.mode_id=?", mode_id)
	}

	err = db.Count(&total).Offset(offset).Limit(limit).Order("do.dialysis_date desc").Select("do.bed_id, do.id, do.dialysis_date, do.user_org_id, do.patient_id, do.prescription_id, do.stage, do.remark, do.status, do.created_time, do.updated_time,do.start_nurse,do.finish_nurse ,s.schedule_type, s.partition_id, dz.name as partition_name").Find(&orders).Error

	if len(orders) > 0 {
		ids := make([]int64, 0)
		for _, order := range orders {
			dialyzer := order.DialysisPrescription.Dialyzer
			ids = append(ids, dialyzer)
		}
		if len(ids) > 0 {
			var dialyzers []*models.DeviceNumber
			err = readDb.Model(&models.DeviceNumber{}).Where("id IN (?) and org_id=? and status=1", ids, orgID).Find(&dialyzers).Error
			if err != nil {
				return nil, 0, err
			}

			dialyzerMap := make(map[int64]models.DeviceNumber, 0)
			for _, item := range dialyzers {
				dialyzerMap[item.ID] = *item
			}
			for orderIndex, order := range orders {
				if _, exist := dialyzerMap[order.DialysisPrescription.Dialyzer]; exist {
					orders[orderIndex].DeviceNumber = dialyzerMap[order.DialysisPrescription.Dialyzer].Number
				}
			}
		}
	}

	return orders, total, err
}

func GetPatientTreatmentSummaryList(orgID, patientID, page, limit, start, end int64) (list []*models.TreatmentSummary, total int, err error) {

	offset := (page - 1) * limit
	fmt.Println(offset)
	fmt.Println(limit)
	db := readDb.Model(&models.TreatmentSummary{}).Where("user_org_id = ? and patient_id=?", orgID, patientID)
	if start != 0 {
		db = db.Where("assessment_date >= ?", start)
	}
	if end != 0 {
		db = db.Where("assessment_date <= ?", end)
	}
	db = db.Where("status=1")
	err = db.Count(&total).Offset(offset).Limit(limit).Order("assessment_date desc, id desc").Find(&list).Error
	return

}

func GetPatientScheduleList(orgID int64, patientID int64, page int64, limit int64, start int64) (schedules []*models.PatientSchedule, err error) {
	offset := (page - 1) * limit
	err = readDb.Table("xt_schedule as s").
		Preload("DeviceZone", "org_id=? and status=1", orgID).
		Preload("DeviceNumber", "org_id=? and status=1", orgID).
		Preload("TreatmentMode", "status=1").
		Where("s.patient_id =? and s.user_org_id=? and s.schedule_date>=? and s.status=1", patientID, orgID, start).
		Limit(limit).Offset(offset).Find(&schedules).Error
	return
}

func GetMonitorRecord(orgID int64, date int64, partition int64) ([]*models.NewVMMonitorDialysisSchedule, error) {
	var mds []*models.NewVMMonitorDialysisSchedule
	db := readDb.
		Model(&models.NewVMMonitorDialysisSchedule{}).
		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, date).
		Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ? AND assessment_date = ?", orgID, date).
		Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ? AND assessment_date = ? ", orgID, date).
		Preload("MonitoringRecord", "status = 1 AND  user_org_id = ? AND monitoring_date = ?", orgID, date).
		Preload("DialysisOrder", "status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, date).
		Preload("DialysisOrder.DeviceNumber", "status = 1 AND  org_id = ?", orgID).
		Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID).
		Where("status = 1 AND user_org_id = ?", orgID)
	if date != 0 {
		db = db.Where("schedule_date = ? ", date)
	}
	if partition != 0 {
		db = db.Where("partition_id = ? ", partition)
	}
	err := db.Find(&mds).Error
	return mds, err
}

func MobileGetMonitorsWithPatient(orgID int64, keyword string, page int) ([]*models.MonitorDialysisSchedule, error) {
	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
	}
	patientIDs := make([]int64, len(patients))
	for index, patient := range patients {
		patientIDs[index] = patient.ID
	}

	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 = ?", orgID).
		Where("status = 1 AND user_org_id = ? AND patient_id in (?)", orgID, patientIDs)

	var schedules []*models.MonitorDialysisSchedule
	err := db.Offset(20 * (page - 1)).Limit(20).Order("schedule_date desc").Find(&schedules).Error
	return schedules, err
}

func GetPatientByKeyWord(orgID int64, keywords string) (patient []*models.Patients, err error) {
	db := readDb.Model(&models.Patients{}).Where("user_org_id=? and status=1", orgID)
	if len(keywords) > 0 {
		likekey := "%" + keywords + "%"
		err = db.Where("name LIKE ? OR dialysis_no LIKE ? ", likekey, likekey).Find(&patient).Error
	} else {
		err = db.Find(&patient).Error
	}
	return
}

func FindDoctorAdviceByGoroupNo(orgID int64, groupno int64) (advice models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("user_org_id=?  AND groupno = ? AND status = 1", orgID, groupno).First(&advice).Error
	return
}

func FindOldDoctorAdvice(orgID int64, advice_id int64) (advice models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("id = ? AND user_org_id=? AND status = 1", advice_id, orgID).First(&advice).Error
	return
}

func UpdateAdviceGroupStartTime(orgID int64, groupNO int64, startTime int64, admin_user_id int64) error {
	now := time.Now().Unix()
	err := writeDb.Model(&models.DoctorAdvice{}).Where("user_org_id = ? AND status = 1 AND execution_state <> 1 AND check_state <> 1 AND groupno = ? AND admin_user_id = ?", orgID, groupNO, admin_user_id).Updates(map[string]interface{}{
		"start_time":   startTime,
		"updated_time": now,
		"modifier":     admin_user_id,
	}).Error
	return err
}

func QueryPatientById(id int64) *models.Patients {
	var pat models.Patients
	err := readDb.Model(&models.Patients{}).Where("id=?", id).First(&pat).Error
	if err != nil {

	}
	return &pat
}

func FindAllDoctorAdviceByGoroupNo(orgID int64, groupno int64) (advice []models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("user_org_id=?  AND groupno = ? AND status = 1", orgID, groupno).Find(&advice).Error
	return
}

func FindDoctorAdviceByIds(orgID int64, ids []string) (advice []models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("id IN (?) AND user_org_id = ? AND status = 1", ids, orgID).Find(&advice).Error
	return
}

func BatchDeleteDoctorAdvice(ids []string, user_id int64) (err error) {
	ut := writeDb.Begin()
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND id IN (?)", ids).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix(), "modifier": user_id}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id IN (?)", ids).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix(), "modifier": user_id}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err

}

func FindAdviceByGoroupNo(orgID int64, groupno int64) (advice []models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("user_org_id=?  AND groupno = ? AND status = 1 AND parent_id = 0", orgID, groupno).Find(&advice).Error
	return
}

func UpdateDoctorAdviceAndSubAdvice(m *models.DoctorAdvice) (err error) {
	ut := writeDb.Begin()
	err = ut.Save(m).Error
	if err != nil {
		ut.Rollback()
		return
	}
	err = ut.Model(&models.DoctorAdvice{}).Where("status = 1   AND parent_id IN (?)", m.ID).Updates(map[string]interface{}{"start_time": m.StartTime, "groupno": m.GroupNo, "mtime": time.Now().Unix()}).Error
	if err != nil {
		ut.Rollback()
		return
	}
	ut.Commit()
	return err

}

func GetAllWaitRemindPatient(org_id int64, page int64, limit int64) (total int64, patient []*models.Patients, err error) {
	type Total struct {
		Count int64
	}
	var totals Total

	offset := (page - 1) * limit
	err = readDb.Raw("select *  from xt_patients where user_org_id = ? AND infectious_next_record_time > 0 AND status = 1  AND date_sub(DATE_FORMAT(date(from_unixtime(`xt_patients`.`infectious_next_record_time`)),'%Y-%m-%d'), interval 7 day) <= now() Order by infectious_next_record_time", org_id).Offset(offset).Limit(limit).Scan(&patient).Error
	readDb.Raw("select Count(id) as count  from xt_patients where user_org_id = ? AND infectious_next_record_time > 0 AND status = 1  AND date_sub(DATE_FORMAT(date(from_unixtime(`xt_patients`.`infectious_next_record_time`)),'%Y-%m-%d'), interval 7 day) <= now() Order by infectious_next_record_time", org_id).Scan(&totals)

	return totals.Count, patient, err
}

func UpdatePatientRemindStatus(patient_id int64, remind int64, org_id int64) (err error) {
	err = writeDb.Model(&models.Patients{}).Where("status = 1  AND id = ? AND user_org_id = ?", patient_id, org_id).Updates(map[string]interface{}{"is_open_remind": remind}).Error
	return
}

func CreatePatientWeightAdjust(m *models.SgjPatientDryweight) (err error) {
	err = writeDb.Create(m).Error
	return
}

func FindLastDryWeightAdjust(orgID int64, id int64) (weight models.SgjPatientDryweight, err error) {
	err = readDb.Model(&models.SgjPatientDryweight{}).Where("user_org_id=? and patient_id=? and status=1", orgID, id).Order("id desc").First(&weight).Error
	return
}

func GetSchedualPatientByKeyWord(orgID int64, keywords string, date int64) (patient []*models.Patients, err error) {
	db := readDb.Model(&models.Patients{}).Where("user_org_id=? and status=1 and lapseto = 1 ", orgID)
	if len(keywords) > 0 {
		likekey := "%" + keywords + "%"
		err = db.Where("(name LIKE ? OR dialysis_no LIKE ?) AND NOT EXISTS (Select * FROM `xt_dialysis_order` as d Where d.`dialysis_date` = ? AND d.`status` = 1 AND d.`patient_id` = xt_patients.id AND  d.user_org_id = xt_patients.user_org_id)", likekey, likekey, date).Find(&patient).Error
	} else {
		err = db.Find(&patient).Error
	}
	return
}

func GetPatientScheduleOne(patientid int64, nowdate int64, orgid int64) (models.XtSchedule, error) {
	schedule := models.XtSchedule{}
	err := XTReadDB().Model(&schedule).Where("patient_id = ? and schedule_date = ? and user_org_id = ? and status =1", patientid, nowdate, orgid).Find(&schedule).Error
	return schedule, err
}

func CreateExportPatient(patient *models.Patients, contagions []int64, org_creator int64) (err error) {
	user, _ := GetSgjUserByMobild(patient.Phone)
	customer, _ := GetSgjCoustomerByMobile(patient.UserOrgId, patient.Phone)
	utx := writeDb.Begin()
	btx := writeUserDb.Begin()
	if user.ID == 0 {
		user.Mobile = patient.Phone
		user.Avatar = patient.Avatar
		user.AvatarThumb = patient.Avatar
		user.Birthday = patient.Birthday
		user.Username = patient.Name
		user.Gender = patient.Gender
		user.Sources = 11
		user.Introduce = patient.Remark
		user.Status = 1
		user.UpdatedTime = patient.UpdatedTime
		user.CreatedTime = patient.CreatedTime
		err = btx.Create(&user).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}
	patient.UserId = user.ID

	if customer == nil {
		err = btx.Create(&models.SgjCustomer{
			UserOrgId:   patient.UserOrgId,
			UserId:      user.ID,
			Mobile:      patient.Phone,
			Name:        patient.Name,
			Gender:      patient.Gender,
			Birthday:    patient.Birthday,
			Sources:     11,
			Status:      1,
			CreatedTime: patient.CreatedTime,
			UpdatedTime: patient.UpdatedTime,
			Avatar:      patient.Avatar,
			Remark:      patient.Remark,
		}).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}

	err = utx.Create(patient).Error
	if err != nil {
		utx.Rollback()
		btx.Rollback()
		return
	}

	if patient.DryWeight > 0 {
		var dryWeight models.SgjPatientDryweight
		dryWeight.PatientId = patient.ID
		dryWeight.UserOrgId = patient.UserOrgId
		dryWeight.Status = 1
		dryWeight.AdjustedValue = "/"
		dryWeight.Creator = org_creator
		dryWeight.UserId = org_creator
		dryWeight.Ctime = time.Now().Unix()
		dryWeight.Mtime = time.Now().Unix()
		dryWeight.DryWeight = patient.DryWeight
		dryWeight.Remakes = ""
		err = utx.Create(&dryWeight).Error
	}

	var lapseto models.PatientLapseto
	lapseto.PatientId = patient.ID
	lapseto.LapsetoType = patient.Lapseto
	lapseto.CreatedTime = patient.CreatedTime
	lapseto.UpdatedTime = patient.CreatedTime
	lapseto.Status = 1
	lapseto.LapsetoTime = patient.CreatedTime

	err = utx.Create(&lapseto).Error
	if err != nil {
		utx.Rollback()
		btx.Rollback()
		return
	}

	if len(contagions) > 0 {
		thisSQL := "INSERT INTO xt_patients_infectious_diseases (patient_id, disease_id, status, created_time, updated_time) VALUES "
		insertParams := make([]string, 0)
		insertData := make([]interface{}, 0)
		for _, contagion := range contagions {
			insertParams = append(insertParams, "(?, ?, ?, ?, ?)")
			insertData = append(insertData, patient.ID)
			insertData = append(insertData, contagion)
			insertData = append(insertData, 1)
			insertData = append(insertData, patient.CreatedTime)
			insertData = append(insertData, patient.UpdatedTime)
		}
		thisSQL += strings.Join(insertParams, ", ")
		err = utx.Exec(thisSQL, insertData...).Error
		if err != nil {
			utx.Rollback()
			btx.Rollback()
			return
		}
	}
	patientsNew := models.XtPatientsNew{
		Name:              patient.Name,
		Gender:            patient.Gender,
		Phone:             patient.Phone,
		IdCardNo:          patient.IdCardNo,
		FirstDialysisDate: patient.FirstDialysisDate,
		Source:            patient.Source,
		Lapseto:           patient.Lapseto,
		IsInfectious:      patient.IsInfectious,
		DialysisNo:        patient.DialysisNo,
		Height:            patient.Height,
		HomeAddress:       patient.HomeAddress,
		IsExcelExport:     1,
		BloodPatients:     1,
		Status:            1,
		CreatedTime:       time.Now().Unix(),
		UserOrgId:         patient.UserOrgId,
		BloodId:           patient.ID,
		Avatar:            "https://images.shengws.com/201809182128111.png",
	}
	err = utx.Create(&patientsNew).Error
	if err != nil {
		utx.Rollback()
		btx.Rollback()
		return
	}
	utx.Commit()
	btx.Commit()

	return
}

func FindPatientPhoneIsExist(phone string, org_id int64) (count int64) {
	readDb.Model(&models.Patients{}).Where("user_org_id = ? AND phone = ? AND status = 1", org_id, phone).Count(&count)
	return
}

func FindPatientIdCardNoIsExist(id_card_no string, org_id int64) (count int64) {
	readDb.Model(&models.Patients{}).Where("user_org_id = ? AND id_card_no = ? AND status = 1", org_id, id_card_no).Count(&count)
	return
}

func CreateExportErrLog(log *models.ExportErrLog) {
	writeDb.Create(&log)
	return
}

func FindPatientExportLog(org_id int64, export_time int64) (errLogs []*models.ExportErrLog, err error) {
	err = readDb.Model(&models.ExportErrLog{}).Where("user_org_id = ? AND export_time = ? AND log_type = 1", org_id, export_time).Find(&errLogs).Error
	return
}

func CreateExportLog(log *models.ExportLog) {
	writeDb.Create(&log)
}

func UpdateDoctorEditAdvice(advice models.XtDoctorAdvice, orgid int64, groupno int64, date int64, patientid int64) error {

	err := XTWriteDB().Model(&advice).Where("user_org_id = ? and groupno = ? and advice_date = ? and patient_id = ?", orgid, groupno, date, patientid).Update(map[string]interface{}{"start_time": advice.StartTime, "updated_time": advice.UpdatedTime}).Error
	return err
}

func GetPatientsByKey(orgID int64, keywords string) (patient []*models.Patients, err error) {
	db := readDb.Model(&models.Patients{}).Where("user_org_id=? and status=1 and lapseto = 1 ", orgID)
	if len(keywords) > 0 {
		likekey := "%" + keywords + "%"
		err = db.Where("(name LIKE ? OR dialysis_no LIKE ?)", likekey, likekey).Find(&patient).Error
	} else {
		err = db.Find(&patient).Error
	}
	return
}

func FindAllDoctorAdviceByGoroupNoTwo(orgID int64, groupno int64) (advice []models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("user_org_id=?  AND groupno = ? AND status = 1 AND execution_state = 2", orgID, groupno).Find(&advice).Error
	return
}

func FindDoctorAdviceByIdsTwo(orgID int64, ids []string) (advice []models.DoctorAdvice, err error) {
	err = readDb.Model(&models.DoctorAdvice{}).Where("user_org_id = ? AND status = 1 AND execution_state = 2 AND (id IN (?) OR parent_id IN (?))", orgID, ids, ids).Find(&advice).Error
	return
}

func CreateHisGroupAdvice(orgId int64, advices []*models.HisGroupAdvice, groupNo int64) (list []*models.HisGroupAdvice, err error) {
	if groupNo <= 0 {
		group := GetMaxAdviceGroupID(orgId)
		groupNo = group + 1
	}
	tx := writeDb.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	for _, advice := range advices {
		advice.Groupno = groupNo
		if err = tx.Create(advice).Error; err != nil {
			tx.Rollback()
			return
		}
		list = append(list, advice)
		if len(advice.Children) > 0 {
			for _, child := range advice.Children {
				child.Groupno = groupNo
				child.ParentId = advice.ID
				fmt.Println(child)
				if err = tx.Create(&child).Error; err != nil {
					tx.Rollback()
					return
				}
				list = append(list, child)
			}
		}

	}
	tx.Commit()
	return
}