XT_New/controllers/mobile_api_controllers/patient_api_controller.go

package mobile_api_controllers

import (
	"XT_New/enums"
	"XT_New/models"
	"XT_New/service"
	"XT_New/utils"
	"encoding/json"
	"fmt"
	"github.com/jinzhu/gorm"
	"math"
	"strings"

	// "fmt"
	"reflect"
	"strconv"
	"time"
)

type PatientApiController struct {
	MobileBaseAPIAuthController
}

func (c *PatientApiController) GetPatientInfoWithDiseases() {
	id, _ := c.GetInt64("patient", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminUserInfo := c.GetMobileAdminUserInfo()
	patient, _ := service.FindPatientByIdWithDiseases(adminUserInfo.Org.Id, id)
	if patient.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
	Registrars, err := service.GetAdminUser(adminUserInfo.Org.Id, adminUserInfo.App.Id, patient.RegistrarsId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	if Registrars != nil {
		patient.Registrars = Registrars.Name
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
	return

}

func (c *PatientApiController) CreateDialysisSolution() {
	id, _ := c.GetInt64("patient", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()
	patient, _ := service.FindPatientById(adminUserInfo.Org.Id, id)
	if patient.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	//根据路由来做权限
	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	//template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)

	//if template.TemplateId == 2 || template.TemplateId == 6 {
	//	if appRole.UserType == 3 {
	//		headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//		if getPermissionErr != nil {
	//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//			return
	//		} else if headNursePermission == nil {
	//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//			return
	//		}
	//	}
	//}

	var solution models.DialysisSolution

	code := defaultSolutionFormData(&solution, c.Ctx.Input.RequestBody, "create")
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	solution.RegistrarsId = adminUserInfo.AdminUser.Id
	solution.Doctor = adminUserInfo.AdminUser.Id
	solution.Status = 1
	solution.PatientId = id
	solution.CreatedTime = time.Now().Unix()
	solution.UserOrgId = adminUserInfo.Org.Id
	solution.UpdatedTime = time.Now().Unix()
	solution.SubName = ""
	solution.ParentId = 0

	err := service.CreatePatientDialysisSolution(&solution)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionCreate)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":      "ok",
		"solution": solution,
	})
	return
}

func (c *PatientApiController) EditDialysisSolution() {
	id, _ := c.GetInt64("id", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()
	solution, _ := service.FindPatientDialysisSolution(adminUserInfo.Org.Id, id)
	if solution.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionNotExist)
		return
	}

	//if solution.Doctor != adminUserInfo.AdminUser.Id {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	code := defaultSolutionFormData(&solution, c.Ctx.Input.RequestBody, "update")
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	// solution.RegistrarsId = adminUserInfo.AdminUser.Id
	solution.Doctor = adminUserInfo.AdminUser.Id
	solution.Status = 1
	// solution.PatientId = id
	// solution.CreatedTime = time.Now().Unix()
	// solution.UserOrgId = adminUserInfo.Org.Id
	solution.UpdatedTime = time.Now().Unix()
	// solution.SubName = ""
	// solution.ParentId = 0

	err := service.UpdatePatientDialysisSolution(&solution)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionUpdate)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":      "ok",
		"solution": solution,
	})
	return
}

func (c *PatientApiController) CreateDoctorAdvice() {

	patient, _ := c.GetInt64("id", 0)
	if patient <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()
	patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
	if patientInfo.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)

	//if appRole.UserType == 3{
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdvicePermissionDeniedModify)
	//	return
	//}

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	var advice models.DoctorAdvice
	code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "create")
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	if advice.ParentId > 0 {
		old, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, advice.ParentId)
		if old.ID == 0 || old.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
			return
		}

		if old.StopState == 1 || old.ExecutionState == 1 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
			return
		}

		if old.ParentId > 0 {
			advice.ParentId = old.ParentId
		}
		advice.StartTime = old.StartTime
		advice.AdviceDoctor = old.AdviceDoctor
		advice.DeliveryWay = old.DeliveryWay
		advice.ExecutionFrequency = old.ExecutionFrequency
		advice.GroupNo = old.GroupNo

	}

	advice.Status = 1
	advice.CreatedTime = time.Now().Unix()
	advice.UpdatedTime = time.Now().Unix()
	advice.StopState = 2
	advice.ExecutionState = 2
	advice.UserOrgId = adminUserInfo.Org.Id
	advice.PatientId = patient
	advice.AdviceDoctor = adminUserInfo.AdminUser.Id

	err := service.CreateDoctorAdvice(&advice)
	key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
	redis := service.RedisClient()
	defer redis.Close()
	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
	redis.Set(keyOne, "", time.Second)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":    "ok",
		"advice": advice,
	})
	return
}

func (c *PatientApiController) EditDoctorAdvice() {
	id, _ := c.GetInt64("id", 0)
	patient_id, _ := c.GetInt64("patient_id")
	doc_advice_date, _ := c.GetInt64("advice_date")
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	redis := service.RedisClient()
	adminUserInfo := c.GetMobileAdminUserInfo()

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

	code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "update")
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	advice.Status = 1
	advice.UpdatedTime = time.Now().Unix()
	advice.UserOrgId = adminUserInfo.Org.Id
	advice.Modifier = adminUserInfo.AdminUser.Id

	//处理修改医嘱开始时间逻辑(不包括子医嘱)
	//1.一组医嘱内只有一条医嘱(不包括子医嘱)的情况下，只需要直接修改医嘱开始时间，不需要重新分配组号
	//2.一组医嘱内有多条医嘱(不包括子医嘱)的情况下,需要为修改的那条医嘱重新分配组号，并修改医嘱开始时间
	var err error
	var isChangeGroup bool
	if advice.ParentId == 0 {
		adviceSlice, _ := service.FindAdviceByGoroupNo(adminUserInfo.Org.Id, advice.GroupNo)
		sourceAdvice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice.ID)
		if len(adviceSlice) == 1 {
			//判断前端上传上来的开始时间和数据库中想要修改的那条医嘱的开始时间是否相同，如果不同，需要修改子医嘱的开始时间，如果相同直接修改，不需要修改子医嘱的开始时间
			if advice.StartTime == sourceAdvice.StartTime {
				err = service.UpdateDoctorAdvice(&advice)
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

				defer redis.Close()
				redis.Set(key, "", time.Second)
				keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + ":advice_list_all"
				redis.Set(keyOne, "", time.Second)
				isChangeGroup = false
			} else {
				err = service.UpdateDoctorAdviceAndSubAdvice(&advice)
				isChangeGroup = false
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

				defer redis.Close()
				redis.Set(key, "", time.Second)
				keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
				redis.Set(keyOne, "", time.Second)
			}
		} else if len(adviceSlice) > 1 {

			//判断前端上传上来的开始时间和数据库中想要修改的那条医嘱的开始时间是否相同，如果不同，需要重新分配组，如果相同直接修改，不需要分配组
			if advice.StartTime == sourceAdvice.StartTime {
				err = service.UpdateDoctorAdvice(&advice)
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

				defer redis.Close()
				redis.Set(key, "", time.Second)
				keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
				redis.Set(keyOne, "", time.Second)
				isChangeGroup = false

			} else {
				gruopNo := service.GetMaxAdviceGroupID(adminUserInfo.Org.Id)
				gruopNo = gruopNo + 1
				advice.GroupNo = gruopNo
				err = service.UpdateDoctorAdviceAndSubAdvice(&advice)
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

				defer redis.Close()
				redis.Set(key, "", time.Second)
				keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
				redis.Set(keyOne, "", time.Second)
				isChangeGroup = true

			}
		}
	} else {
		isChangeGroup = false
		err = service.UpdateDoctorAdvice(&advice)
		redis := service.RedisClient()
		defer redis.Close()
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
		redis.Set(key, "", time.Second)
		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"
		redis.Set(keyOne, "", time.Second)

	}
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
		return
	}

	if !isChangeGroup {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg":      "ok",
			"advice":   advice,
			"isChange": isChangeGroup, //方便前端处理数据
		})

	} else {
		newGroupAdvice, err := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, advice.GroupNo)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":      "ok",
			"advice":   newGroupAdvice,
			"isChange": isChangeGroup, //方便前端处理数据
		})

	}
	return
}

func (c *PatientApiController) StopDoctorAdvice() {
	id, _ := c.GetInt64("id", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()
	advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

	//if advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//	return
	//}

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	if advice.StopState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
		return
	}

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	if dataBody["stop_time"] == nil || reflect.TypeOf(dataBody["stop_time"]).String() != "string" {
		utils.ErrorLog("stop_time")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	stopTime, _ := dataBody["stop_time"].(string)
	if len(stopTime) == 0 {
		utils.ErrorLog("len(stop_time) == 0")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", stopTime, loc)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	advice.StopTime = theTime.Unix()

	if dataBody["stop_reason"] == nil || reflect.TypeOf(dataBody["stop_reason"]).String() != "string" {
		utils.ErrorLog("stop_reason")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	stopReason, _ := dataBody["stop_reason"].(string)
	if len(stopReason) == 0 {
		utils.ErrorLog("len(stop_reason) == 0")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	advice.StopReason = stopReason

	advice.Status = 1
	advice.UpdatedTime = time.Now().Unix()
	advice.StopDoctor = adminUserInfo.AdminUser.Id
	advice.StopState = 1
	advice.StopTime = time.Now().Unix()
	advice.Modifier = adminUserInfo.AdminUser.Id

	err = service.StopDoctorAdvice(&advice)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStopAdviceFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":    "ok",
		"advice": advice,
	})
	return
}

func (c *PatientApiController) DeleteDoctorAdvice() {
	id, _ := c.GetInt64("id", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()

	advice, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, id)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

	//if !adminUserInfo.AdminUser.IsSuperAdmin && advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//	return
	//}

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	advice.UpdatedTime = time.Now().Unix()
	advice.Status = 0
	advice.Modifier = adminUserInfo.AdminUser.Id

	err := service.DeleteDoctorAdvice(&advice)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	return
}

func (c *PatientApiController) ExecDoctorAdvice() {
	execution_time := c.GetString("execution_time")

	origin, _ := c.GetInt64("origin", 0)
	groupno, _ := c.GetInt64("groupno", -1)

	if origin != 2 {
		var ids []string
		if groupno == 0 {
			advice_ids := c.GetString("advice_id")
			ids = strings.Split(advice_ids, ",")
		}
		if groupno < 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		if len(execution_time) <= 0 {
			utils.ErrorLog("execution_time")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		timeLayout2 := "2006-01-02 15:04:05"
		loc, _ := time.LoadLocation("Local")

		theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
		if errs != nil {
			utils.ErrorLog(errs.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetMobileAdminUserInfo()

		var advice models.DoctorAdvice

		if groupno > 0 {
			advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
			for _, item := range advices {
				if item.ExecutionState == 2 {
					advice = item
				}
			}
		} else {
			advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
			for _, item := range advices {
				if item.ExecutionState == 2 {
					advice = item
				}
			}
		}

		if advice.ExecutionState == 1 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
			return
		}

		if advice.Checker >= 0 && advice.Checker == adminUserInfo.AdminUser.Id {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
			return
		}

		if advice.StartTime > theTime.Unix() {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
			return
		}

		execution_staff := adminUserInfo.AdminUser.Id

		advices := models.DoctorAdvice{
			ExecutionStaff: execution_staff,
			ExecutionTime:  theTime.Unix(),
			UpdatedTime:    time.Now().Unix(),
		}
		var err error
		if groupno > 0 {
			err = service.ExceDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"

			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			toTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04:05", execution_time)
			theTime := toTime.Format("2006-01-02")

			fmt.Println("theTIME", theTime)
			keyFour := "scheduals_" + theTime + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)

			defer redis.Close()
		} else {

			err = service.BatchExceOldDoctorAdvice(&advices, ids)
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"

			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			toTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04:05", execution_time)
			theTime := toTime.Format("2006-01-02")
			fmt.Println("theTIME", theTime)
			keyFour := "scheduals_" + theTime + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
			redis.Set(keyFour, "", time.Second)
			keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keySix, "", time.Second)
			defer redis.Close()
			//清空key 值
			redis.Set(key, "", time.Second)

		}

		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
			return
		}

		advice.ExecutionStaff = execution_staff
		advice.ExecutionTime = theTime.Unix()
		advice.ExecutionState = 1
		advice.Modifier = adminUserInfo.AdminUser.Id

		//处理出库相关逻辑

		//1.判断是否启用药品管理和自备药出库功能

		//药品管理信息
		_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(adminUserInfo.Org.Id)

		//自备药信息
		privateDrugConfig, _ := service.GetDrugSetByUserOrgId(adminUserInfo.Org.Id)

		if drugStockConfig.IsOpen == 1 {
			if groupno > 0 {
				advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)

				isHasWay := false //用来判断是否包含来自药品库的医嘱
				for _, item := range advices {
					if item.Way == 1 {
						isHasWay = true
					}

				}

				if isHasWay {
					var total int64
					var prescribing_number_total int64
					for _, item := range advices {
						if item.Way == 1 {
							houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
							//查询该药品的剩余库存
							list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId, houseConfig.DrugStorehouseOut)

							//查询改药品信息
							medical, _ := service.GetBaseDrugMedical(item.DrugId)
							//判断单位是否相等
							if medical.MaxUnit == item.PrescribingNumberUnit {
								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
								//转化为最小单位
								total = list.Count * medical.MinNumber
								prescribing_number_total = count * medical.MinNumber
							}
							if medical.MinUnit == item.PrescribingNumberUnit {
								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
								total = list.Count*medical.MinNumber + list.StockMinNumber
								prescribing_number_total = count
							}

							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "3",
									"advice": advice,
									"ids":    ids,
								})
								return
							}
							if prescribing_number_total > total {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "2",
									"advice": advice,
									"ids":    ids,
								})
								return
							}
							if prescribing_number_total <= total {

								//查询是否出库按钮开启
								adviceSetting, _ := service.FindAdviceSettingById(item.UserOrgId)
								if adviceSetting.IsAdviceOpen == 1 {
									//查询是否出库按钮开启
									prescriptionConfig, _ := service.FindPrescriptionConfigById(item.UserOrgId)
									if prescriptionConfig.IsOpen == 1 {
										if medical.IsUse == 2 {
											service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
											//查询默认仓库
											houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
											//查询默认仓库剩余多少库存
											list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
											var sum_count int64
											var sum_in_count int64
											for _, it := range list {
												baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
												if it.MaxUnit == baseDrug.MaxUnit {
													it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
													it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
												}
												sum_count += it.StockMaxNumber + it.StockMinNumber
												sum_in_count += it.WarehousingCount
											}
											service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.UserOrgId)
										}
									}
								} else {
									if medical.IsUse == 2 {
										service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
										//查询默认仓库
										houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
										//查询默认仓库剩余多少库存
										list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
										var sum_count int64
										var sum_in_count int64
										for _, it := range list {
											baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
											if it.MaxUnit == baseDrug.MaxUnit {
												it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
												it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
											}
											sum_count += it.StockMaxNumber + it.StockMinNumber
											sum_in_count += it.WarehousingCount
										}
										service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.UserOrgId)
									}
								}
							}
						}
					}
				}
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "1",
					"advice": advice,
					"ids":    ids,
				})
				return
			} else {

				advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
				isHasWay := false //用来判断是否包含来自药品库的医嘱

				for _, item := range advices {
					if item.Way == 1 {
						isHasWay = true
					}
				}

				if isHasWay {
					var total int64
					var prescribing_number_total int64
					for _, item := range advices {

						if item.Way == 1 {
							houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
							//查询该药品的剩余库存
							list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId, houseConfig.DrugStorehouseOut)

							//查询改药品信息
							medical, _ := service.GetBaseDrugMedical(item.DrugId)

							//判断单位是否相等
							if medical.MaxUnit == item.PrescribingNumberUnit {
								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
								//转化为最小单位
								total = list.Count*medical.MinNumber + list.StockMinNumber

								prescribing_number_total = count * medical.MinNumber
							}

							if medical.MinUnit == item.PrescribingNumberUnit {
								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
								total = list.Count*medical.MinNumber + list.StockMinNumber
								prescribing_number_total = count
							}

							fmt.Println("开医嘱数量", prescribing_number_total)
							fmt.Println("剩余库存", total)

							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "3",
									"advice": advice,
									"ids":    ids,
								})
								return
							}
							if prescribing_number_total > total {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "2",
									"advice": advice,
									"ids":    ids,
								})
								return
							}

							if prescribing_number_total <= total {
								if medical.IsUse == 2 {
									service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, &item)
									//查询默认仓库
									houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
									//查询默认仓库剩余多少库存
									list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
									var sum_count int64
									var sum_in_count int64
									for _, it := range list {
										baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
										if it.MaxUnit == baseDrug.MaxUnit {
											it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
											it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
										}
										sum_count += it.StockMaxNumber + it.StockMinNumber
										sum_in_count += it.WarehousingCount
									}
									service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.UserOrgId)
									c.ServeSuccessJSON(map[string]interface{}{
										"msg":    "1",
										"advice": advice,
										"ids":    ids,
									})
									return
								}
								if medical.IsUse == 1 {
									c.ServeSuccessJSON(map[string]interface{}{
										"msg":    "1",
										"advice": advice,
										"ids":    ids,
									})
									return
								}

							}
						}
					}
				}
			}
		}

		if privateDrugConfig != nil && privateDrugConfig.DrugStart == 1 {
			if groupno > 0 {
				advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
				for _, item := range advices {

					if item.ExecutionState == 1 && item.Way == 2 {
						prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
						count, _ := strconv.ParseInt(prescribingNumber, 10, 64)

						timeStr := time.Now().Format("2006-01-02")
						timeArr := strings.Split(timeStr, "-")
						total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.Org.Id)

						total = total + 1
						warehousing_out_order := strconv.FormatInt(adminUserInfo.Org.Id, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
						number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
						number = number + total
						warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
						//插入自备药出库单
						outStock := models.XtSelfOutStock{
							DrugName:       item.AdviceName,
							DrugNameId:     item.DrugNameId,
							DrugSpec:       item.AdviceDesc,
							OutstoreNumber: count,
							AdminUserId:    adminUserInfo.AdminUser.Id,
							StorckTime:     item.AdviceDate,
							UserOrgId:      adminUserInfo.Org.Id,
							CreatedTime:    time.Now().Unix(),
							Status:         1,
							PatientId:      item.PatientId,
							ExitMode:       2,
							MedicId:        item.DrugId,
							StockOutNumber: warehousing_out_order,
						}
						//查询 该患者是否已出库
						out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)

						if errcode == gorm.ErrRecordNotFound {
							service.CreateOutStock(&outStock)
						} else if errcode == nil {
							err := service.UpdatedSelfOutSatock(out.ID, &outStock)
							fmt.Println("err", err)
						}
					}
				}
			} else {

				advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
				for _, item := range advices {

					if item.ExecutionState == 1 && item.Way == 2 {

						prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
						count, _ := strconv.ParseInt(prescribingNumber, 10, 64)

						timeStr := time.Now().Format("2006-01-02")
						timeArr := strings.Split(timeStr, "-")
						total, _ := service.FindAllDrugWarehouseOut(adminUserInfo.Org.Id)

						total = total + 1
						warehousing_out_order := strconv.FormatInt(adminUserInfo.Org.Id, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
						number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
						number = number + total
						warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)

						//插入自备药出库单
						outStock := models.XtSelfOutStock{
							DrugName:       item.AdviceName,
							DrugNameId:     item.DrugNameId,
							DrugSpec:       item.AdviceDesc,
							OutstoreNumber: count,
							AdminUserId:    adminUserInfo.AdminUser.Id,
							StorckTime:     item.AdviceDate,
							UserOrgId:      adminUserInfo.Org.Id,
							CreatedTime:    time.Now().Unix(),
							Status:         1,
							PatientId:      item.PatientId,
							ExitMode:       2,
							MedicId:        item.DrugId,
							StockOutNumber: warehousing_out_order,
						}

						//查询 该患者是否已出库
						out, errcode := service.GetSelfOutStock(adminUserInfo.Org.Id, item.AdviceDate, item.PatientId, item.AdviceName, item.AdviceDesc)

						if errcode == gorm.ErrRecordNotFound {
							service.CreateOutStock(&outStock)
						} else if errcode == nil {
							err := service.UpdatedSelfOutSatock(out.ID, &outStock)
							fmt.Println("err", err)
						}
					}
				}
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "1",
					"advice": advice,
					"ids":    ids,
				})
				return
			}
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"msg":    "1",
			"advice": advice,
			"ids":    ids,
		})
		return
	} else if origin == 2 {
		var ids []string
		advice_ids := c.GetString("advice_id")
		ids = strings.Split(advice_ids, ",")

		if len(execution_time) <= 0 {
			utils.ErrorLog("execution_time")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		timeLayout2 := "2006-01-02 15:04:05"
		loc, _ := time.LoadLocation("Local")
		theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)

		if errs != nil {
			utils.ErrorLog(errs.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adminInfo := c.GetMobileAdminUserInfo()
		creater := c.GetMobileAdminUserInfo().AdminUser.Id
		advices, _ := service.FindHisDoctorAdviceByIds(adminInfo.Org.Id, ids)
		var err error
		for _, item := range advices {
			if item.ExecutionState == 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
				return
			}

			if item.Checker >= 0 && item.Checker == adminInfo.AdminUser.Id {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
				return
			}

			if item.StartTime > theTime.Unix() {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
				return
			}

			item.ExecutionState = 1
			item.ExecutionStaff = adminInfo.AdminUser.Id
			item.ExecutionTime = theTime.Unix()
			err = service.SaveHisDoctorAdvice(item)
			key := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			recordDate := theTime.Format("2006-01-02")
			keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminInfo.Org.Id, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)

			defer redis.Close()
		}

		if err == nil {

			//药品管理信息
			_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(adminInfo.Org.Id)
			if drugStockConfig.IsOpen == 1 {
				for _, item := range advices {
					//查询改药品信息
					medical, _ := service.GetBaseDrugMedical(item.DrugId)
					//查询这个患者这个患者这个药已经出库的所有数量
					advicelist, _ := service.GetAllHisDoctorAdviceById(item.DrugId, item.PatientId, item.AdviceDate, item.UserOrgId)
					drugoutlist, _ := service.GetAllDrugFlowById(item.DrugId, item.PatientId, item.AdviceDate, item.UserOrgId)
					var total_count int64
					var drug_count int64
					for _, it := range advicelist {
						if it.PrescribingNumberUnit == medical.MaxUnit {
							prescribingNumber_temp := strconv.FormatFloat(math.Abs(it.PrescribingNumber), 'f', 0, 64)
							prenumber, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
							total_count += prenumber * medical.MinNumber
						}
						if it.PrescribingNumberUnit == medical.MinUnit {
							prescribingNumber_temp := strconv.FormatFloat(math.Abs(it.PrescribingNumber), 'f', 0, 64)
							prenumber, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
							total_count += prenumber
						}

					}

					for _, its := range drugoutlist {
						if its.CountUnit == medical.MaxUnit {
							drug_count += its.Count * medical.MinNumber
						}
						if its.CountUnit == medical.MinUnit {
							drug_count += its.Count
						}
					}
					if total_count == drug_count {
						advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
						c.ServeSuccessJSON(map[string]interface{}{
							"msg":    "1",
							"advice": advice,
							"ids":    ids,
						})
						return
					}

					advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)

					var total int64
					var prescribing_number_total int64
					//查询该药品是否有库存
					houseConfig, _ := service.GetAllStoreHouseConfig(advice.UserOrgId)
					list, _ := service.GetDrugTotalCount(advice.DrugId, advice.UserOrgId, houseConfig.DrugStorehouseOut)

					//判断单位是否相等
					if medical.MaxUnit == advice.PrescribingNumberUnit {
						prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
						count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
						//转化为最小单位
						total = list.Count*medical.MinNumber + list.StockMinNumber
						prescribing_number_total = count * medical.MinNumber
					}
					//fmt.Println("医嘱开的数量", total)
					if medical.MinUnit == advice.PrescribingNumberUnit {
						prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
						count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
						total = list.Count*medical.MinNumber + list.StockMinNumber
						prescribing_number_total = count
					}

					//fmt.Println("数量一", prescribing_number_total)
					//fmt.Println("数量二", total)

					if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
						c.ServeSuccessJSON(map[string]interface{}{
							"msg":    "3",
							"advice": advice,
							"ids":    ids,
						})
						return
					}
					if prescribing_number_total > total {
						c.ServeSuccessJSON(map[string]interface{}{
							"msg":    "2",
							"advice": advice,
							"ids":    ids,
						})
						return
					}
					if prescribing_number_total <= total {
						if medical.IsUse == 2 {
							config, _ := service.GetDrugOpenConfigOne(adminInfo.Org.Id)
							if config.IsOpen != 1 {
								service.HisDrugsDelivery(adminInfo.Org.Id, creater, &advice)
								//查询默认仓库
								houseConfig, _ := service.GetAllStoreHouseConfig(medical.OrgId)
								//查询默认仓库剩余多少库存
								list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, medical.OrgId, medical.ID)
								var sum_count int64
								var sum_in_count int64
								for _, it := range list {
									baseDrug, _ := service.GetBaseDrugMedical(medical.ID)
									if it.MaxUnit == baseDrug.MaxUnit {
										it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
										it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
									}
									sum_count += it.StockMaxNumber + it.StockMinNumber
									sum_in_count += it.WarehousingCount
								}
								service.UpdateMedicalSumCount(medical.ID, sum_count, sum_in_count, medical.OrgId)
							}

						}
					}
				}
			}
			for _, item := range advices {
				advice, _ := service.FindHisDoctorAdviceById(adminInfo.Org.Id, item.ID)
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "1",
					"advice": advice,
					"ids":    ids,
				})
			}

		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		}

	}
}

func (c *PatientApiController) ModifyExecDoctorAdvice() {
	execution_time := c.GetString("execution_time")
	fmt.Println("execution_time", execution_time)
	groupno, _ := c.GetInt64("groupno", -1)

	var ids []string
	if groupno == 0 {
		advice_ids := c.GetString("advice_id")
		ids = strings.Split(advice_ids, ",")
	}
	if groupno < 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	if len(execution_time) <= 0 {
		utils.ErrorLog("execution_time")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout2 := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")

	theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetMobileAdminUserInfo()

	var advice models.DoctorAdvice

	if groupno > 0 {
		advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
		for _, item := range advices {
			if item.ExecutionState == 1 {
				advice = item

			}
		}
	} else {
		advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
		for _, item := range advices {
			if item.ExecutionState == 1 {
				advice = item
			}
		}
	}

	//if advice.ExecutionStaff != adminUserInfo.AdminUser.Id {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//	if getPermissionErr != nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//		return
	//	} else if headNursePermission == nil {
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//		return
	//	}
	//}

	if advice.StartTime > theTime.Unix() {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
		return
	}

	advices := models.DoctorAdvice{
		ExecutionTime: theTime.Unix(),
		UpdatedTime:   time.Now().Unix(),
	}
	var err error
	if groupno > 0 {

		err = service.ModifyExceDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
		redis := service.RedisClient()
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
		fmt.Println("keyThh322323232323232323223", key)
		redis.Set(key, "", time.Second)
		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
		redis.Set(keyOne, "", time.Second)

		defer redis.Close()

	} else {
		err = service.BatchModifyExceOldDoctorAdvice(&advices, ids)
		err = service.ModifyExceDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
		redis := service.RedisClient()
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
		fmt.Println("keyTwohh322323232323232323223", key)
		redis.Set(key, "", time.Second)
		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
		redis.Set(keyOne, "", time.Second)

		defer redis.Close()
	}

	//判断是否开启his
	errs, config := service.FindXTHisRecordByOrgId(adminUserInfo.Org.Id)
	//如果开启去修改执行时间
	if config.IsOpen == 1 {
		advicesinfo := models.HisDoctorAdviceInfo{
			ExecutionTime: theTime.Unix(),
			UpdatedTime:   time.Now().Unix(),
		}
		fmt.Println("ids2323232232323", ids)
		var advicehis models.HisDoctorAdviceInfo
		service.ModifyExceDoctorAdviceById(&advicesinfo, ids)
		his_advices, _ := service.FindHisDoctorAdviceByIdOne(adminUserInfo.Org.Id, ids)
		for _, item := range his_advices {
			if item.ExecutionState == 1 {
				advicehis = item
			}
		}
		redis := service.RedisClient()
		keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicehis.PatientId, 10) + ":" + strconv.FormatInt(advicehis.AdviceDate, 10) + ":his_doctor_advice"
		redis.Set(keyThree, "", time.Second)
		recordDate := theTime.Format("2006-01-02")
		keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)

		redis.Set(keyFour, "", time.Second)
		keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicehis.AdviceDate, 10) + ":his_advices_list_all"
		redis.Set(keyFive, "", time.Second)
		defer redis.Close()
		project := models.HisPrescriptionProject{
			ExecutionTime: theTime.Unix(),
			Mtime:         time.Now().Unix(),
		}
		service.ModifyHisPrescriptionProject(&project, ids)

		keyEnd := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicesinfo.PatientId, 10) + ":" + strconv.FormatInt(advicesinfo.AdviceDate, 10) + ":his_doctor_advice"
		redis.Set(keyEnd, "", time.Second)
		keyFours := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)

		redis.Set(keyFours, "", time.Second)
		keyFives := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advicesinfo.AdviceDate, 10) + ":his_advices_list_all"
		redis.Set(keyFives, "", time.Second)
		defer redis.Close()
	}
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
		return
	}
	advice.ExecutionTime = theTime.Unix()
	c.ServeSuccessJSON(map[string]interface{}{
		"msg":    "ok",
		"advice": advice,
		"ids":    ids,
	})
	return

}

func (c *PatientApiController) CheckDoctorAdvice() {
	origin, _ := c.GetInt64("origin", 0)

	if origin != 2 {
		groupno, _ := c.GetInt64("groupno", -1)
		var ids []string
		if groupno == 0 {
			advice_ids := c.GetString("advice_id")
			if advice_ids == "" {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			} else {
				ids = strings.Split(advice_ids, ",")
				if len(ids) <= 0 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
					return
				}
			}
		}
		if groupno < 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetMobileAdminUserInfo()

		var advice models.DoctorAdvice

		if groupno > 0 {
			advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
			for _, item := range advices {
				if item.CheckState == 0 {
					advice = item
				}
			}
			if advice.CheckState == 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
				return
			}
			if advice.ExecutionStaff >= 0 && advice.ExecutionStaff == adminUserInfo.AdminUser.Id {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
				return
			}

		} else {
			advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
			for _, item := range advices {
				if item.CheckState == 0 {
					advice = item

				}
			}
			if advice.CheckState == 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
				return
			}
			if advice.ExecutionStaff >= 0 && advice.ExecutionStaff == adminUserInfo.AdminUser.Id {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
				return
			}
		}

		checker := adminUserInfo.AdminUser.Id
		theTime := time.Now()

		advices := models.DoctorAdvice{
			CheckTime:   theTime.Unix(),
			Checker:     checker,
			UpdatedTime: time.Now().Unix(),
		}
		var err error
		if groupno > 0 {
			err = service.CheckDoctorAdviceByGroupNo(&advices, groupno, adminUserInfo.Org.Id)
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			recordDate := theTime.Format("2006-01-02")
			keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)
			defer redis.Close()
		} else {

			if len(ids[0]) <= 0 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
				return
			} else {
				//t := time.Now().Format("2006-01-02")/**/
				//timeLayout2 := "2006-01-02"
				//loc, _ := time.LoadLocation("Local")
				//theTime, _ := time.ParseInLocation(timeLayout2, t, loc)
				err = service.BatchCheckOldDoctorAdvice(&advices, ids, adminUserInfo.Org.Id, advice.AdviceDate)
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
				redis := service.RedisClient()
				//清空key 值
				redis.Set(key, "", time.Second)
				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
				redis.Set(keyTwo, "", time.Second)
				keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
				redis.Set(keyThree, "", time.Second)
				recordDate := theTime.Format("2006-01-02")
				keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)

				redis.Set(keyFour, "", time.Second)
				keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
				redis.Set(keyFive, "", time.Second)
				defer redis.Close()
			}
		}

		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
			return
		}

		advice.Checker = checker
		advice.CheckTime = theTime.Unix()
		advice.CheckState = 1
		c.ServeSuccessJSON(map[string]interface{}{
			"msg":    "ok",
			"advice": advice,
		})
	} else if origin == 2 {
		adminInfo := c.GetMobileAdminUserInfo()
		var ids []string
		advice_ids := c.GetString("advice_id")
		ids = strings.Split(advice_ids, ",")
		advices, _ := service.FindHisDoctorAdviceByIds(adminInfo.Org.Id, ids)
		var err error
		for _, item := range advices {
			if item.CheckState == 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
				return
			}
			if item.ExecutionStaff >= 0 && item.ExecutionStaff == adminInfo.AdminUser.Id {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
				return
			}
			item.Checker = adminInfo.AdminUser.Id
			item.CheckTime = time.Now().Unix()
			item.CheckState = 1
			err = service.SaveHisDoctorAdvice(item)
			redis := service.RedisClient()
			key := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			theTime := time.Now()

			recordDate := theTime.Format("2006-01-02")
			keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(adminInfo.Org.Id, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminInfo.Org.Id, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)
			defer redis.Close()
		}
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":    "ok",
				"advice": advices,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
			return
		}
	}
	return
}

func (c *PatientApiController) EditAssessmentBeforeDislysis() {
	id, _ := c.GetInt64("patient", 0)
	assessmentDate := c.GetString("assessment_date", "")
	if id <= 0 || len(assessmentDate) != 10 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", assessmentDate+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	theAssessmentDateTime := theTime.Unix()

	adminUserInfo := c.GetMobileAdminUserInfo()
	patient, _ := service.FindPatientById(adminUserInfo.Org.Id, id)
	if patient.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	theEvaluation, getPEErr := service.MobileGetPredialysisEvaluationSeven(adminUserInfo.Org.Id, id, theAssessmentDateTime)
	if getPEErr != nil {
		c.ErrorLog("获取透前评估失败:%v", getPEErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
	//templateInfo,_ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
	var evaluation models.PredialysisEvaluation
	if theEvaluation != nil {
		evaluation = *theEvaluation
	}

	code := predialysisEvaluationFormData(&evaluation, c.Ctx.Input.RequestBody)
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	if theEvaluation == nil {
		evaluation.CreatedTime = time.Now().Unix()
		evaluation.Status = 1
		evaluation.AssessmentDate = theAssessmentDateTime
		evaluation.PatientId = id
		evaluation.UserOrgId = adminUserInfo.Org.Id
		if appRole.UserType == 2 || appRole.UserType == 1 {
			evaluation.AssessmentDoctor = adminUserInfo.AdminUser.Id
			evaluation.AssessmentTime = time.Now().Unix()
		} else {
			evaluation.Creater = adminUserInfo.AdminUser.Id
		}
	} else {
		evaluation.UpdatedTime = time.Now().Unix()
		evaluation.Evaluator = adminUserInfo.AdminUser.Id
		if appRole.UserType == 2 || appRole.UserType == 1 {
			evaluation.AssessmentDoctor = adminUserInfo.AdminUser.Id
			evaluation.AssessmentTime = time.Now().Unix()
		} else {
			evaluation.Modifier = adminUserInfo.AdminUser.Id
			if evaluation.Creater == 0 {
				evaluation.Creater = adminUserInfo.AdminUser.Id
			}
		}
	}

	//新增逻辑

	var dewater_amount float64
	dewater_amount = 0
	if evaluation.DryWeight > 0 {
		dewater_amount = evaluation.WeightBefore - evaluation.DryWeight - evaluation.AdditionalWeight

		if template.TemplateId == 17 || template.TemplateId == 22 || template.TemplateId == 21 || template.TemplateId == 26 || template.TemplateId == 34 || template.TemplateId == 32 {
			dewater_amount = dewater_amount * 1000

		}

		if dewater_amount <= 0 {
			dewater_amount = 0
		}
	} else {
		dewater_amount = 0
	}
	// 计算透析处方的相关超滤量
	schedual, _ := service.MobileGetSchedualDetailSix(adminUserInfo.Org.Id, patient.ID, theAssessmentDateTime)
	var lastDialysisPrescribe *models.DialysisPrescription
	var dialysisSolution *models.DialysisSolution
	var dialysisPrescribe *models.DialysisPrescription
	var system_dialysisPrescribe *models.SystemPrescription

	var mode_id int64

	dialysisPrescribe, _ = service.MobileGetDialysisPrescribe(adminUserInfo.Org.Id, id, theAssessmentDateTime)
	lastDialysisPrescribe, _ = service.MobileGetLastDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
	if schedual != nil {
		// 获取透析模版
		dialysisSolution, _ = service.MobileGetDialysisSolutionByModeIdSix(adminUserInfo.Org.Id, id, schedual.ModeId)
		system_dialysisPrescribe, _ = service.MobileGetSystemDialysisPrescribeByModeIdSix(adminUserInfo.Org.Id, schedual.ModeId)

		mode_id = schedual.ModeId
	} else {
		// 获取透析模版
		dialysisSolution, _ = service.MobileGetDialysisSolution(adminUserInfo.Org.Id, id)

		if dialysisPrescribe == nil && dialysisSolution != nil {
			mode_id = dialysisSolution.ModeId
		}

		if dialysisPrescribe == nil && dialysisSolution == nil {
			mode_id = 0
		}
	}

	// 插入透析处方
	if dialysisPrescribe == nil && dialysisSolution != nil {
		var newprescribe models.DialysisPrescription
		newprescribe.UserOrgId = dialysisSolution.UserOrgId
		newprescribe.PatientId = dialysisSolution.PatientId
		newprescribe.Anticoagulant = dialysisSolution.Anticoagulant
		newprescribe.AnticoagulantShouji = dialysisSolution.AnticoagulantShouji
		newprescribe.AnticoagulantWeichi = dialysisSolution.AnticoagulantWeichi
		newprescribe.AnticoagulantZongliang = dialysisSolution.AnticoagulantZongliang
		newprescribe.AnticoagulantGaimingcheng = dialysisSolution.AnticoagulantGaimingcheng
		newprescribe.AnticoagulantGaijiliang = dialysisSolution.AnticoagulantGaijiliang
		newprescribe.ModeId = dialysisSolution.ModeId
		newprescribe.DialysisDuration = dialysisSolution.DialysisDuration
		newprescribe.ReplacementWay = dialysisSolution.ReplacementWay
		newprescribe.HemodialysisMachine = dialysisSolution.HemodialysisMachine
		newprescribe.BloodFilter = dialysisSolution.BloodFilter
		newprescribe.PerfusionApparatus = dialysisSolution.PerfusionApparatus
		newprescribe.BloodFlowVolume = dialysisSolution.BloodFlowVolume
		newprescribe.DisplaceLiqui = dialysisSolution.DisplaceLiqui
		newprescribe.Glucose = dialysisSolution.Glucose
		newprescribe.DialysateFlow = dialysisSolution.DialysateFlow
		newprescribe.Kalium = dialysisSolution.Kalium
		newprescribe.Sodium = dialysisSolution.Sodium
		newprescribe.Calcium = dialysisSolution.Calcium
		newprescribe.Bicarbonate = dialysisSolution.Bicarbonate
		newprescribe.DialysateTemperature = dialysisSolution.DialysateTemperature
		newprescribe.Conductivity = dialysisSolution.Conductivity
		newprescribe.BodyFluid = dialysisSolution.BodyFluid
		newprescribe.SpecialMedicine = dialysisSolution.SpecialMedicine
		newprescribe.SpecialMedicineOther = dialysisSolution.SpecialMedicineOther
		newprescribe.DisplaceLiquiPart = dialysisSolution.DisplaceLiquiPart
		newprescribe.DisplaceLiquiValue = dialysisSolution.DisplaceLiquiValue
		newprescribe.BloodAccess = dialysisSolution.BloodAccess
		newprescribe.Ultrafiltration = dialysisSolution.Ultrafiltration
		newprescribe.DialysisDurationHour = dialysisSolution.DialysisDurationHour
		newprescribe.DialysisDurationMinute = dialysisSolution.DialysisDurationMinute
		newprescribe.TargetUltrafiltration = dialysisSolution.TargetUltrafiltration
		newprescribe.DialysateFormulation = dialysisSolution.DialysateFormulation
		newprescribe.Dialyzer = dialysisSolution.Dialyzer
		newprescribe.ReplacementTotal = dialysisSolution.ReplacementTotal
		newprescribe.DialyzerPerfusionApparatus = dialysisSolution.DialyzerPerfusionApparatus
		newprescribe.BodyFluidOther = dialysisSolution.BodyFluidOther
		newprescribe.TargetKtv = dialysisSolution.TargetKtv

		newprescribe.CreatedTime = time.Now().Unix()
		newprescribe.UpdatedTime = time.Now().Unix()
		newprescribe.RecordDate = theAssessmentDateTime
		newprescribe.DewaterAmount = dewater_amount
		newprescribe.TargetUltrafiltration = dewater_amount
		newprescribe.Status = 1
		newprescribe.DialysisDialyszers = dialysisSolution.DialysisDialyszers
		newprescribe.DialysisIrrigation = dialysisSolution.DialysisIrrigation
		_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
		newprescribe.ID = dialysisPrescription.ID

		if dialysisPrescription.ID == 0 {
			fmt.Println("处方11111111111")
			err := service.AddSigleRecord(&newprescribe)
			//获取key,清空redis
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
			redis := service.RedisClient()

			//清空key 值
			redis.Set(key, "", time.Second)

			keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
			//清空key 值
			redis.Set(keyOne, "", time.Second)

			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
			//清空key 值
			redis.Set(keyTwo, "", time.Second)

			keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
			redis.Set(keySix, "", time.Second)

			keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
			redis.Set(keySeven, "", time.Second)
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}
		} else {
			err := service.UpDateDialysisPrescription(&newprescribe)
			//获取key,清空redis
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
			redis := service.RedisClient()

			//清空key 值
			redis.Set(key, "", time.Second)

			keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
			//清空key 值
			redis.Set(keyOne, "", time.Second)

			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
			//清空key 值
			redis.Set(keyTwo, "", time.Second)

			keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
			redis.Set(keySix, "", time.Second)

			keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
			redis.Set(keySeven, "", time.Second)
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}
		}

	}

	if dialysisPrescribe == nil && dialysisSolution == nil {
		if lastDialysisPrescribe != nil {
			var newprescribe models.DialysisPrescription
			newprescribe.UserOrgId = lastDialysisPrescribe.UserOrgId
			newprescribe.PatientId = lastDialysisPrescribe.PatientId
			newprescribe.Anticoagulant = lastDialysisPrescribe.Anticoagulant
			newprescribe.AnticoagulantShouji = lastDialysisPrescribe.AnticoagulantShouji
			newprescribe.AnticoagulantWeichi = lastDialysisPrescribe.AnticoagulantWeichi
			newprescribe.AnticoagulantZongliang = lastDialysisPrescribe.AnticoagulantZongliang
			newprescribe.AnticoagulantGaimingcheng = lastDialysisPrescribe.AnticoagulantGaimingcheng
			newprescribe.AnticoagulantGaijiliang = lastDialysisPrescribe.AnticoagulantGaijiliang
			newprescribe.ModeId = lastDialysisPrescribe.ModeId
			newprescribe.DialysisDuration = lastDialysisPrescribe.DialysisDuration
			newprescribe.ReplacementWay = lastDialysisPrescribe.ReplacementWay
			newprescribe.HemodialysisMachine = lastDialysisPrescribe.HemodialysisMachine
			newprescribe.BloodFilter = lastDialysisPrescribe.BloodFilter
			newprescribe.PerfusionApparatus = lastDialysisPrescribe.PerfusionApparatus
			newprescribe.BloodFlowVolume = lastDialysisPrescribe.BloodFlowVolume
			newprescribe.DisplaceLiqui = lastDialysisPrescribe.DisplaceLiqui
			newprescribe.Glucose = lastDialysisPrescribe.Glucose
			newprescribe.DialysateFlow = lastDialysisPrescribe.DialysateFlow
			newprescribe.Kalium = lastDialysisPrescribe.Kalium
			newprescribe.Sodium = lastDialysisPrescribe.Sodium
			newprescribe.Calcium = lastDialysisPrescribe.Calcium
			newprescribe.Bicarbonate = lastDialysisPrescribe.Bicarbonate
			newprescribe.DialysateTemperature = lastDialysisPrescribe.DialysateTemperature
			newprescribe.Conductivity = lastDialysisPrescribe.Conductivity
			newprescribe.BodyFluid = lastDialysisPrescribe.BodyFluid
			newprescribe.SpecialMedicine = lastDialysisPrescribe.SpecialMedicine
			newprescribe.SpecialMedicineOther = lastDialysisPrescribe.SpecialMedicineOther
			newprescribe.DisplaceLiquiPart = lastDialysisPrescribe.DisplaceLiquiPart
			newprescribe.DisplaceLiquiValue = lastDialysisPrescribe.DisplaceLiquiValue
			newprescribe.BloodAccess = lastDialysisPrescribe.BloodAccess
			newprescribe.Ultrafiltration = lastDialysisPrescribe.Ultrafiltration
			newprescribe.DialysisDurationHour = lastDialysisPrescribe.DialysisDurationHour
			newprescribe.DialysisDurationMinute = lastDialysisPrescribe.DialysisDurationMinute
			newprescribe.DialysateFormulation = lastDialysisPrescribe.DialysateFormulation
			newprescribe.Dialyzer = lastDialysisPrescribe.Dialyzer
			newprescribe.ReplacementTotal = lastDialysisPrescribe.ReplacementTotal
			newprescribe.DialyzerPerfusionApparatus = lastDialysisPrescribe.DialyzerPerfusionApparatus
			newprescribe.BodyFluidOther = lastDialysisPrescribe.BodyFluidOther
			newprescribe.TargetKtv = lastDialysisPrescribe.TargetKtv
			newprescribe.CreatedTime = time.Now().Unix()
			newprescribe.UpdatedTime = time.Now().Unix()
			newprescribe.RecordDate = theAssessmentDateTime
			newprescribe.DewaterAmount = dewater_amount
			newprescribe.TargetUltrafiltration = dewater_amount
			newprescribe.Status = 1
			newprescribe.DialysisIrrigation = lastDialysisPrescribe.DialysisIrrigation
			newprescribe.DialysisDialyszers = lastDialysisPrescribe.DialysisDialyszers
			_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
			newprescribe.ID = dialysisPrescription.ID
			if dialysisPrescription.ID == 0 {
				err := service.AddSigleRecord(&newprescribe)
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				fmt.Println("处方2222222222")
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			} else {
				err := service.UpDateDialysisPrescription(&newprescribe)
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			}
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}
		} else if system_dialysisPrescribe != nil {

			var newprescribe models.DialysisPrescription
			newprescribe.UserOrgId = system_dialysisPrescribe.UserOrgId
			newprescribe.PatientId = id
			newprescribe.Anticoagulant = system_dialysisPrescribe.Anticoagulant
			newprescribe.AnticoagulantShouji = system_dialysisPrescribe.AnticoagulantShouji
			newprescribe.AnticoagulantWeichi = system_dialysisPrescribe.AnticoagulantWeichi
			newprescribe.AnticoagulantZongliang = system_dialysisPrescribe.AnticoagulantZongliang
			newprescribe.AnticoagulantGaimingcheng = system_dialysisPrescribe.AnticoagulantGaimingcheng
			newprescribe.AnticoagulantGaijiliang = system_dialysisPrescribe.AnticoagulantGaijiliang
			newprescribe.ModeId = system_dialysisPrescribe.ModeId
			newprescribe.DialysisDuration = system_dialysisPrescribe.DialysisDuration
			newprescribe.ReplacementWay = system_dialysisPrescribe.ReplacementWay
			newprescribe.HemodialysisMachine = system_dialysisPrescribe.HemodialysisMachine
			newprescribe.BloodFilter = system_dialysisPrescribe.BloodFilter
			newprescribe.PerfusionApparatus = system_dialysisPrescribe.PerfusionApparatus
			newprescribe.BloodFlowVolume = system_dialysisPrescribe.BloodFlowVolume
			newprescribe.DisplaceLiqui = system_dialysisPrescribe.DisplaceLiqui
			newprescribe.Glucose = system_dialysisPrescribe.Glucose
			newprescribe.DialysateFlow = system_dialysisPrescribe.DialysateFlow
			newprescribe.Kalium = system_dialysisPrescribe.Kalium
			newprescribe.Sodium = system_dialysisPrescribe.Sodium
			newprescribe.Calcium = system_dialysisPrescribe.Calcium
			newprescribe.Bicarbonate = system_dialysisPrescribe.Bicarbonate
			newprescribe.DialysateTemperature = system_dialysisPrescribe.DialysateTemperature
			newprescribe.Conductivity = system_dialysisPrescribe.Conductivity
			newprescribe.BodyFluid = system_dialysisPrescribe.BodyFluid
			newprescribe.SpecialMedicine = system_dialysisPrescribe.SpecialMedicine
			newprescribe.SpecialMedicineOther = system_dialysisPrescribe.SpecialMedicineOther
			newprescribe.DisplaceLiquiPart = system_dialysisPrescribe.DisplaceLiquiPart
			newprescribe.DisplaceLiquiValue = system_dialysisPrescribe.DisplaceLiquiValue
			newprescribe.BloodAccess = system_dialysisPrescribe.BloodAccess
			newprescribe.Ultrafiltration = system_dialysisPrescribe.Ultrafiltration
			newprescribe.DialysisDurationHour = system_dialysisPrescribe.DialysisDurationHour
			newprescribe.DialysisDurationMinute = system_dialysisPrescribe.DialysisDurationMinute
			newprescribe.DialysateFormulation = system_dialysisPrescribe.DialysateFormulation
			newprescribe.Dialyzer = system_dialysisPrescribe.Dialyzer
			newprescribe.ReplacementTotal = system_dialysisPrescribe.ReplacementTotal
			newprescribe.DialyzerPerfusionApparatus = system_dialysisPrescribe.DialyzerPerfusionApparatus
			newprescribe.BodyFluidOther = system_dialysisPrescribe.BodyFluidOther
			newprescribe.TargetKtv = system_dialysisPrescribe.TargetKtv
			newprescribe.CreatedTime = time.Now().Unix()
			newprescribe.UpdatedTime = time.Now().Unix()
			newprescribe.RecordDate = theAssessmentDateTime
			newprescribe.DewaterAmount = dewater_amount
			newprescribe.TargetUltrafiltration = dewater_amount
			newprescribe.Status = 1
			newprescribe.DialysisDialyszers = system_dialysisPrescribe.DialysisDialyszers
			newprescribe.DialysisIrrigation = system_dialysisPrescribe.DialysisIrrigation
			_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
			newprescribe.ID = dialysisPrescription.ID
			if dialysisPrescription.ID == 0 {
				err := service.AddSigleRecord(&newprescribe)

				fmt.Println("处方2222222222")
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			} else {
				err := service.UpDateDialysisPrescription(&newprescribe)
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			}
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}

		} else {
			var newprescribe models.DialysisPrescription
			newprescribe.UserOrgId = adminUserInfo.Org.Id
			newprescribe.PatientId = id
			newprescribe.ModeId = mode_id
			newprescribe.CreatedTime = time.Now().Unix()
			newprescribe.UpdatedTime = time.Now().Unix()
			newprescribe.RecordDate = theAssessmentDateTime
			newprescribe.DewaterAmount = dewater_amount
			newprescribe.TargetUltrafiltration = dewater_amount
			newprescribe.Status = 1

			_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, theAssessmentDateTime, adminUserInfo.Org.Id)
			newprescribe.ID = dialysisPrescription.ID
			if dialysisPrescription.ID == 0 {
				err := service.AddSigleRecord(&newprescribe)
				fmt.Println("处方44444444444")
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			} else {
				err := service.UpDateDialysisPrescription(&newprescribe)
				//获取key,清空redis
				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
				redis := service.RedisClient()

				//清空key 值
				redis.Set(key, "", time.Second)

				keyOne := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
				//清空key 值
				redis.Set(keyOne, "", time.Second)

				keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
				//清空key 值
				redis.Set(keyTwo, "", time.Second)

				keySix := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":prescriptions_list_all"
				redis.Set(keySix, "", time.Second)

				keySeven := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":dialysis_prescribe_by_mode"
				redis.Set(keySeven, "", time.Second)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			}
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}
		}
	}

	// 手动修改透前评估的时候，如果透析处方已经存在，则不修改对应的透析处方
	// if dialysisPrescribe != nil {
	// 	dialysisPrescribe.UpdatedTime = time.Now().Unix()
	// 	dialysisPrescribe.RecordDate = theAssessmentDateTime
	// 	dialysisPrescribe.DewaterAmount = dewater_amount
	// 	dialysisPrescribe.TargetUltrafiltration = dewater_amount
	// 	dialysisPrescribe.Status = 1
	// 	updateErr := service.UpDateDialysisPrescription(dialysisPrescribe)
	// 	if updateErr != nil {
	// 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
	// 	}
	// }

	err = service.UpadatePredialysisEvaluation(&evaluation)

	key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":assessment_before_dislysis"
	redis := service.RedisClient()
	defer redis.Close()
	//清空key 值
	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":assessment_befores_list_all"
	redis.Set(keyOne, "", time.Second)
	keyTwo := "scheduals_" + assessmentDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
	redis.Set(keyTwo, "", time.Second)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDBUpdate)
		return
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":        "ok",
		"evaluation": evaluation,
	})
	return
}

func defaultSolutionFormData(solution *models.DialysisSolution, data []byte, method string) (code int) {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(data, &dataBody)
	utils.InfoLog(string(data))
	if err != nil {
		utils.ErrorLog(err.Error())
		code = enums.ErrorCodeParamWrong
		return
	}

	// if method == "create" {
	if dataBody["mode"] == nil || reflect.TypeOf(dataBody["mode"]).String() != "float64" {
		utils.ErrorLog("mode")
		code = enums.ErrorCodeParamWrong
		return
	}
	mode := int64(dataBody["mode"].(float64))
	if mode <= 0 {
		utils.ErrorLog("mode <= 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	solution.ModeId = mode

	if dataBody["mode_name"] == nil || reflect.TypeOf(dataBody["mode_name"]).String() != "string" {
		utils.ErrorLog("mode_name")
		code = enums.ErrorCodeParamWrong
		return
	}
	modeName, _ := dataBody["mode_name"].(string)
	if len(modeName) == 0 {
		utils.ErrorLog("len(mode_name) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	solution.ModeName = modeName
	solution.Name = modeName

	// }

	if dataBody["dialysis_duration"] != nil && reflect.TypeOf(dataBody["dialysis_duration"]).String() == "string" {
		dialysisDuration, _ := strconv.ParseFloat(dataBody["dialysis_duration"].(string), 64)
		solution.DialysisDuration = dialysisDuration
	}
	if dataBody["dialysis_duration"] != nil {
		if reflect.TypeOf(dataBody["dialysis_duration"]).String() == "string" {
			dialysisDuration, _ := strconv.ParseFloat(dataBody["dialysis_duration"].(string), 64)
			solution.DialysisDuration = dialysisDuration
		} else if reflect.TypeOf(dataBody["dialysis_duration"]).String() == "float64" {
			dialysisDuration := dataBody["dialysis_duration"].(float64)
			solution.DialysisDuration = dialysisDuration
		}
	}

	if dataBody["dialyzer"] != nil && reflect.TypeOf(dataBody["dialyzer"]).String() == "float64" {
		dialyzer := int64(dataBody["dialyzer"].(float64))
		solution.Dialyzer = dialyzer
	}

	if dataBody["perfusion_apparatus"] != nil && reflect.TypeOf(dataBody["perfusion_apparatus"]).String() == "float64" {
		perfusionApparatus := int64(dataBody["perfusion_apparatus"].(float64))
		solution.PerfusionApparatus = perfusionApparatus
	}

	if dataBody["blood_flow_volume"] != nil {
		if reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "string" {
			bloodFlowVolume, _ := strconv.ParseFloat(dataBody["blood_flow_volume"].(string), 64)
			solution.BloodFlowVolume = bloodFlowVolume
		} else if reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "float64" {
			bloodFlowVolume := dataBody["blood_flow_volume"].(float64)
			solution.BloodFlowVolume = bloodFlowVolume
		}
	}

	if dataBody["hemodialysis_machine"] != nil && reflect.TypeOf(dataBody["hemodialysis_machine"]).String() == "float64" {
		hemodialysisMachine := int64(dataBody["hemodialysis_machine"].(float64))
		solution.HemodialysisMachine = hemodialysisMachine
	}

	if dataBody["dewater"] != nil {
		if reflect.TypeOf(dataBody["dewater"]).String() == "string" {
			dewater, _ := strconv.ParseFloat(dataBody["dewater"].(string), 64)
			solution.Dewater = dewater
		} else if reflect.TypeOf(dataBody["dewater"]).String() == "float64" {
			dewater := dataBody["dewater"].(float64)
			solution.Dewater = dewater
		}
	}

	if dataBody["replacement_total"] != nil {
		if reflect.TypeOf(dataBody["replacement_total"]).String() == "string" {
			replacementTotal, _ := strconv.ParseFloat(dataBody["replacement_total"].(string), 64)
			solution.ReplacementTotal = replacementTotal
		} else if reflect.TypeOf(dataBody["replacement_total"]).String() == "float64" {
			replacementTotal := dataBody["replacement_total"].(float64)
			solution.ReplacementTotal = replacementTotal
		}
	}

	if dataBody["displace_liqui"] != nil {
		if reflect.TypeOf(dataBody["displace_liqui"]).String() == "string" {
			displaceLiqui, _ := strconv.ParseFloat(dataBody["displace_liqui"].(string), 64)
			solution.DisplaceLiqui = displaceLiqui
		} else if reflect.TypeOf(dataBody["displace_liqui"]).String() == "float64" {
			displaceLiqui := dataBody["displace_liqui"].(float64)
			solution.DisplaceLiqui = displaceLiqui
		}
	}

	if dataBody["replacement_way"] != nil && reflect.TypeOf(dataBody["replacement_way"]).String() == "float64" {
		replacementWay := int64(dataBody["replacement_way"].(float64))
		solution.ReplacementWay = replacementWay
	}

	if dataBody["anticoagulant"] != nil && reflect.TypeOf(dataBody["anticoagulant"]).String() == "float64" {
		anticoagulant := int64(dataBody["anticoagulant"].(float64))
		solution.Anticoagulant = anticoagulant
	}

	if dataBody["anticoagulant_shouji"] != nil {
		if reflect.TypeOf(dataBody["anticoagulant_shouji"]).String() == "string" {
			anticoagulantShouji, _ := strconv.ParseFloat(dataBody["anticoagulant_shouji"].(string), 64)
			solution.AnticoagulantShouji = anticoagulantShouji
		} else if reflect.TypeOf(dataBody["anticoagulant_shouji"]).String() == "float64" {
			anticoagulantShouji := dataBody["anticoagulant_shouji"].(float64)
			solution.AnticoagulantShouji = anticoagulantShouji
		}
	}

	if dataBody["anticoagulant_weichi"] != nil {
		if reflect.TypeOf(dataBody["anticoagulant_weichi"]).String() == "string" {
			anticoagulantWeichi, _ := strconv.ParseFloat(dataBody["anticoagulant_weichi"].(string), 64)
			solution.AnticoagulantWeichi = anticoagulantWeichi
		} else if reflect.TypeOf(dataBody["anticoagulant_weichi"]).String() == "float64" {
			anticoagulantWeichi := dataBody["anticoagulant_weichi"].(float64)
			solution.AnticoagulantWeichi = anticoagulantWeichi
		}
	}

	if dataBody["anticoagulant_zongliang"] != nil {
		if reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "string" {
			anticoagulantZongliang, _ := strconv.ParseFloat(dataBody["anticoagulant_zongliang"].(string), 64)
			solution.AnticoagulantZongliang = anticoagulantZongliang
		} else if reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "float64" {
			anticoagulantZongliang := dataBody["anticoagulant_zongliang"].(float64)
			solution.AnticoagulantZongliang = anticoagulantZongliang
		}
	}

	if dataBody["anticoagulant_gaimingcheng"] != nil && reflect.TypeOf(dataBody["anticoagulant_gaimingcheng"]).String() == "string" {
		anticoagulantGaimingcheng, _ := dataBody["anticoagulant_gaimingcheng"].(string)
		solution.AnticoagulantGaimingcheng = anticoagulantGaimingcheng
	}

	if dataBody["anticoagulant_gaijiliang"] != nil && reflect.TypeOf(dataBody["anticoagulant_gaijiliang"]).String() == "string" {
		anticoagulantGaijiliang, _ := dataBody["anticoagulant_gaijiliang"].(string)
		solution.AnticoagulantGaijiliang = anticoagulantGaijiliang
	}

	if dataBody["kalium"] != nil {
		if reflect.TypeOf(dataBody["kalium"]).String() == "string" {
			kalium, _ := strconv.ParseFloat(dataBody["kalium"].(string), 64)
			solution.Kalium = kalium
		} else if reflect.TypeOf(dataBody["kalium"]).String() == "float64" {
			kalium := dataBody["kalium"].(float64)
			solution.Kalium = kalium
		}
	}

	if dataBody["sodium"] != nil {
		if reflect.TypeOf(dataBody["sodium"]).String() == "string" {
			sodium, _ := strconv.ParseFloat(dataBody["sodium"].(string), 64)
			solution.Sodium = sodium
		} else if reflect.TypeOf(dataBody["sodium"]).String() == "float64" {
			sodium := dataBody["sodium"].(float64)
			solution.Sodium = sodium
		}
	}

	if dataBody["calcium"] != nil && reflect.TypeOf(dataBody["calcium"]).String() == "string" {
		if reflect.TypeOf(dataBody["calcium"]).String() == "string" {
			calcium, _ := strconv.ParseFloat(dataBody["calcium"].(string), 64)
			solution.Calcium = calcium
		} else if reflect.TypeOf(dataBody["calcium"]).String() == "float64" {
			calcium := dataBody["calcium"].(float64)
			solution.Calcium = calcium
		}
	}

	if dataBody["bicarbonate"] != nil {
		if reflect.TypeOf(dataBody["bicarbonate"]).String() == "string" {
			bicarbonate, _ := strconv.ParseFloat(dataBody["bicarbonate"].(string), 64)
			solution.Bicarbonate = bicarbonate
		} else if reflect.TypeOf(dataBody["bicarbonate"]).String() == "float64" {
			bicarbonate := dataBody["bicarbonate"].(float64)
			solution.Bicarbonate = bicarbonate
		}
	}

	if dataBody["glucose"] != nil {
		if reflect.TypeOf(dataBody["glucose"]).String() == "string" {
			glucose, _ := strconv.ParseFloat(dataBody["glucose"].(string), 64)
			solution.Glucose = glucose
		} else if reflect.TypeOf(dataBody["glucose"]).String() == "float64" {
			glucose := dataBody["glucose"].(float64)
			solution.Glucose = glucose
		}
	}

	// if dataBody["dry_weight"] != nil {
	// 	if reflect.TypeOf(dataBody["dry_weight"]).String() == "string" {
	// 		dryWeight, _ := strconv.ParseFloat(dataBody["dry_weight"].(string), 64)
	// 		solution.DryWeight = dryWeight
	// 	} else if reflect.TypeOf(dataBody["dry_weight"]).String() == "float64" {
	// 		dryWeight := dataBody["dry_weight"].(float64)
	// 		solution.DryWeight = dryWeight
	// 	}
	// }

	if dataBody["dialysate_flow"] != nil {
		if reflect.TypeOf(dataBody["dialysate_flow"]).String() == "string" {
			dialysateFlow, _ := strconv.ParseFloat(dataBody["dialysate_flow"].(string), 64)
			solution.DialysateFlow = dialysateFlow
		} else if reflect.TypeOf(dataBody["dialysate_flow"]).String() == "float64" {
			dialysateFlow := dataBody["dialysate_flow"].(float64)
			solution.DialysateFlow = dialysateFlow
		}
	}

	if dataBody["dialysate_temperature"] != nil {
		if reflect.TypeOf(dataBody["dialysate_temperature"]).String() == "string" {
			dialysateTemperature, _ := strconv.ParseFloat(dataBody["dialysate_temperature"].(string), 64)
			solution.DialysateTemperature = dialysateTemperature
		} else if reflect.TypeOf(dataBody["dialysate_temperature"]).String() == "float64" {
			dialysateTemperature := dataBody["dialysate_temperature"].(float64)
			solution.DialysateTemperature = dialysateTemperature
		}
	}

	if dataBody["conductivity"] != nil {
		if reflect.TypeOf(dataBody["conductivity"]).String() == "string" {
			conductivity, _ := strconv.ParseFloat(dataBody["conductivity"].(string), 64)
			solution.Conductivity = conductivity
		} else if reflect.TypeOf(dataBody["conductivity"]).String() == "float64" {
			conductivity := dataBody["conductivity"].(float64)
			solution.Conductivity = conductivity
		}
	}

	if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
		remark := dataBody["remark"].(string)
		solution.Remark = remark
	}

	if dataBody["dialysis_duration_hour"] != nil {
		if reflect.TypeOf(dataBody["dialysis_duration_hour"]).String() == "string" {
			dialysisDurationHour, _ := strconv.ParseInt(dataBody["dialysis_duration_hour"].(string), 10, 64)
			solution.DialysisDurationHour = dialysisDurationHour
		} else if reflect.TypeOf(dataBody["dialysis_duration_hour"]).String() == "float64" {
			dialysisDurationHour := dataBody["dialysis_duration_hour"].(float64)
			solution.DialysisDurationHour = int64(dialysisDurationHour)
		}
	}

	if dataBody["dialysis_duration_minute"] != nil {
		if reflect.TypeOf(dataBody["dialysis_duration_minute"]).String() == "string" {
			dialysisDurationMinute, _ := strconv.ParseInt(dataBody["dialysis_duration_minute"].(string), 10, 64)
			solution.DialysisDurationMinute = dialysisDurationMinute
		} else if reflect.TypeOf(dataBody["dialysis_duration_minute"]).String() == "float64" {
			dialysisDurationMinute := dataBody["dialysis_duration_minute"].(float64)
			solution.DialysisDurationMinute = int64(dialysisDurationMinute)
		}
	}
	if dataBody["target_ultrafiltration"] != nil {
		if reflect.TypeOf(dataBody["target_ultrafiltration"]).String() == "string" {
			targetUltrafiltration, _ := strconv.ParseFloat(dataBody["target_ultrafiltration"].(string), 64)
			solution.TargetUltrafiltration = targetUltrafiltration
		} else if reflect.TypeOf(dataBody["target_ultrafiltration"]).String() == "float64" {
			targetUltrafiltration := dataBody["target_ultrafiltration"].(float64)
			solution.TargetUltrafiltration = targetUltrafiltration
		}
	}

	if dataBody["dialysate_formulation"] != nil {
		if reflect.TypeOf(dataBody["dialysate_formulation"]).String() == "string" {
			dialysateFormulation, _ := strconv.ParseInt(dataBody["dialysate_formulation"].(string), 10, 64)
			solution.DialysateFormulation = dialysateFormulation
		} else if reflect.TypeOf(dataBody["dialysate_formulation"]).String() == "float64" {
			dialysateFormulation := dataBody["dialysate_formulation"].(float64)
			solution.DialysateFormulation = int64(dialysateFormulation)
		}
	}

	return
}

func predialysisEvaluationFormData(evaluation *models.PredialysisEvaluation, data []byte) (code int) {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(data, &dataBody)
	utils.InfoLog(string(data))
	if err != nil {
		utils.ErrorLog(err.Error())
		code = enums.ErrorCodeParamWrong
		return
	}

	if dataBody["weight_before"] != nil && reflect.TypeOf(dataBody["weight_before"]).String() == "string" {
		weightVefore, _ := strconv.ParseFloat(dataBody["weight_before"].(string), 64)
		evaluation.WeightBefore = weightVefore
	}
	// fmt.Println(dataBody["dry_weight"])
	// fmt.Println(reflect.TypeOf(dataBody["dry_weight"]).String())

	if dataBody["dry_weight"] != nil && reflect.TypeOf(dataBody["dry_weight"]).String() == "string" {
		additionalWeight, _ := strconv.ParseFloat(dataBody["dry_weight"].(string), 64)
		fmt.Println(additionalWeight)
		evaluation.DryWeight = additionalWeight
	}

	if dataBody["additional_weight"] != nil && reflect.TypeOf(dataBody["additional_weight"]).String() == "string" {
		additionalWeight, _ := strconv.ParseFloat(dataBody["additional_weight"].(string), 64)
		fmt.Println(additionalWeight)
		evaluation.AdditionalWeight = additionalWeight
	}

	if dataBody["temperature"] != nil && reflect.TypeOf(dataBody["temperature"]).String() == "string" {
		Temperature, _ := strconv.ParseFloat(dataBody["temperature"].(string), 64)
		evaluation.Temperature = Temperature
	}

	if dataBody["systolic_blood_pressure"] != nil && reflect.TypeOf(dataBody["systolic_blood_pressure"]).String() == "string" {
		systolicBloodPressure, _ := strconv.ParseFloat(dataBody["systolic_blood_pressure"].(string), 64)
		evaluation.SystolicBloodPressure = systolicBloodPressure
	}

	if dataBody["diastolic_blood_pressure"] != nil && reflect.TypeOf(dataBody["diastolic_blood_pressure"]).String() == "string" {
		diastolicBloodPressure, _ := strconv.ParseFloat(dataBody["diastolic_blood_pressure"].(string), 64)
		evaluation.DiastolicBloodPressure = diastolicBloodPressure
	}

	if dataBody["pulse_frequency"] != nil && reflect.TypeOf(dataBody["pulse_frequency"]).String() == "string" {
		pulseFrequency, _ := strconv.ParseFloat(dataBody["pulse_frequency"].(string), 64)
		evaluation.PulseFrequency = pulseFrequency
	}

	if dataBody["breathing_rate"] != nil && reflect.TypeOf(dataBody["breathing_rate"]).String() == "string" {
		breathingRate, _ := strconv.ParseFloat(dataBody["breathing_rate"].(string), 64)
		evaluation.BreathingRate = breathingRate
	}

	if dataBody["last_post_dialysis"] != nil && reflect.TypeOf(dataBody["last_post_dialysis"]).String() == "string" {
		lastPostDialysis, _ := dataBody["last_post_dialysis"].(string)
		evaluation.LastPostDialysis = lastPostDialysis
	}

	if dataBody["dialysis_interphase"] != nil && reflect.TypeOf(dataBody["dialysis_interphase"]).String() == "string" {
		dialysisInterphase, _ := dataBody["dialysis_interphase"].(string)
		evaluation.DialysisInterphase = dialysisInterphase
	}

	if dataBody["symptom_before_dialysis"] != nil && reflect.TypeOf(dataBody["symptom_before_dialysis"]).String() == "string" {
		symptomBeforeDialysis, _ := dataBody["symptom_before_dialysis"].(string)
		evaluation.SymptomBeforeDialysis = symptomBeforeDialysis
	}

	if dataBody["catheter"] != nil && reflect.TypeOf(dataBody["catheter"]).String() == "string" {
		catheter, _ := dataBody["catheter"].(string)
		evaluation.Catheter = catheter
	}

	if dataBody["catheter_bend"] != nil && reflect.TypeOf(dataBody["catheter_bend"]).String() == "float64" {
		catheter_bend := int(dataBody["catheter_bend"].(float64))
		evaluation.CatheterBend = catheter_bend
	}

	if dataBody["complication"] != nil && reflect.TypeOf(dataBody["complication"]).String() == "string" {
		Complication, _ := dataBody["complication"].(string)
		evaluation.Complication = Complication
	}

	if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
		remark := dataBody["remark"].(string)
		evaluation.Remark = remark
	}

	if dataBody["machine_type"] != nil && reflect.TypeOf(dataBody["machine_type"]).String() == "string" {
		machine_type := dataBody["machine_type"].(string)
		evaluation.MachineType = machine_type
	}

	if dataBody["blood_access_part_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_id"]).String() == "string" {
		blood_access_part_id := dataBody["blood_access_part_id"].(string)
		evaluation.BloodAccessPartId = blood_access_part_id
	}
	//if dataBody["blood_access_part_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_id"]).String() == "float64" {
	//	blood_access_part_id := int64(dataBody["blood_access_part_id"].(float64))
	//	evaluation.BloodAccessPartId = blood_access_part_id
	//}
	if dataBody["blood_access_part_opera_id"] != nil && reflect.TypeOf(dataBody["blood_access_part_opera_id"]).String() == "float64" {
		blood_access_part_opera_id := int64(dataBody["blood_access_part_opera_id"].(float64))
		evaluation.BloodAccessPartOperaId = blood_access_part_opera_id
	}

	if dataBody["internal_fistula"] != nil && reflect.TypeOf(dataBody["internal_fistula"]).String() == "string" {
		internal_fistula, _ := dataBody["internal_fistula"].(string)
		evaluation.InternalFistula = internal_fistula
	}
	if dataBody["internal_fistula_skin"] != nil && reflect.TypeOf(dataBody["internal_fistula_skin"]).String() == "string" {
		internal_fistula_skin := dataBody["internal_fistula_skin"].(string)
		evaluation.InternalFistulaSkin = internal_fistula_skin
	}
	if dataBody["is_hemorrhage"] != nil && reflect.TypeOf(dataBody["is_hemorrhage"]).String() == "string" {
		ishemorrhage, _ := dataBody["is_hemorrhage"].(string)
		is_hemorrhage, _ := strconv.ParseInt(ishemorrhage, 10, 64)
		evaluation.IsHemorrhage = is_hemorrhage

		//if dataBody["is_hemorrhage"] != nil && reflect.TypeOf(dataBody["is_hemorrhage"]).String() == "float64" {
		//	is_hemorrhage := int64(dataBody["is_hemorrhage"].(float64))
		//	fmt.Println("is_hemorrhage2222222222222222",is_hemorrhage)
		if is_hemorrhage != 1 && is_hemorrhage != 2 {
			is_hemorrhage = 0
		}
		evaluation.IsHemorrhage = is_hemorrhage
		if is_hemorrhage == 1 {
			if dataBody["hemorrhage"] != nil && reflect.TypeOf(dataBody["hemorrhage"]).String() == "string" {
				hemorrhage, _ := dataBody["hemorrhage"].(string)
				evaluation.Hemorrhage = hemorrhage
			}
			if dataBody["hemorrhage_other"] != nil && reflect.TypeOf(dataBody["hemorrhage_other"]).String() == "string" {
				hemorrhage_other, _ := dataBody["hemorrhage_other"].(string)
				evaluation.HemorrhageOther = hemorrhage_other
			}
		}
	} else {
		evaluation.IsHemorrhage = 0
	}

	if dataBody["blood_access_internal_fistula"] != nil && reflect.TypeOf(dataBody["blood_access_internal_fistula"]).String() == "string" {
		blood_access_internal_fistula, _ := dataBody["blood_access_internal_fistula"].(string)
		evaluation.BloodAccessInternalFistula = blood_access_internal_fistula
	}

	if dataBody["internal_fistula_other"] != nil && reflect.TypeOf(dataBody["internal_fistula_other"]).String() == "string" {
		internal_fistula_other, _ := dataBody["internal_fistula_other"].(string)
		evaluation.InternalFistulaOther = internal_fistula_other
	}

	if dataBody["blood_access_noise"] != nil && reflect.TypeOf(dataBody["blood_access_noise"]).String() == "float64" {
		blood_access_noise := int64(dataBody["blood_access_noise"].(float64))
		evaluation.BloodAccessNoise = blood_access_noise
	}

	if dataBody["puncture_way"] != nil && reflect.TypeOf(dataBody["puncture_way"]).String() == "string" {
		//puncture_way := int64(dataBody["puncture_way"].(float64))
		puncture_way := dataBody["puncture_way"].(string)
		evaluation.PunctureWay = puncture_way
	}

	if dataBody["venous_catheterization"] != nil && reflect.TypeOf(dataBody["venous_catheterization"]).String() == "float64" {
		venous_catheterization := int64(dataBody["venous_catheterization"].(float64))
		evaluation.VenousCatheterization = venous_catheterization
	}

	if dataBody["venous_catheterization_part"] != nil && reflect.TypeOf(dataBody["venous_catheterization_part"]).String() == "float64" {
		venous_catheterization_part := int64(dataBody["venous_catheterization_part"].(float64))
		evaluation.VenousCatheterizationPart = venous_catheterization_part
	}

	if dataBody["venous_catheterization_part_other"] != nil && reflect.TypeOf(dataBody["venous_catheterization_part_other"]).String() == "string" {
		venous_catheterization_part_other, _ := dataBody["venous_catheterization_part_other"].(string)
		evaluation.VenousCatheterizationPartOther = venous_catheterization_part_other
	}

	if dataBody["ductus_arantii"] != nil && reflect.TypeOf(dataBody["ductus_arantii"]).String() == "string" {
		ductus_arantii, _ := dataBody["ductus_arantii"].(string)
		evaluation.DuctusArantii = ductus_arantii
	}

	if dataBody["emergency_treatment"] != nil && reflect.TypeOf(dataBody["emergency_treatment"]).String() == "float64" {
		emergency_treatment := int64(dataBody["emergency_treatment"].(float64))
		evaluation.EmergencyTreatment = emergency_treatment
	}
	if dataBody["emergency_treatment_other"] != nil && reflect.TypeOf(dataBody["emergency_treatment_other"]).String() == "string" {
		emergency_treatment_other, _ := dataBody["emergency_treatment_other"].(string)
		evaluation.EmergencyTreatmentOther = emergency_treatment_other
	}

	if dataBody["dialysis_count"] != nil && reflect.TypeOf(dataBody["dialysis_count"]).String() == "string" {
		dialysis_count, _ := dataBody["dialysis_count"].(string)
		//count, _ := strconv.ParseInt(dialysis_count, 10, 64)
		evaluation.DialysisCount = dialysis_count
	}

	if dataBody["is_infect"] != nil && reflect.TypeOf(dataBody["is_infect"]).String() == "string" {
		is_infect, _ := dataBody["is_infect"].(string)
		infect, _ := strconv.ParseInt(is_infect, 10, 64)
		evaluation.IsInfect = infect
	}

	if dataBody["exposed"] != nil && reflect.TypeOf(dataBody["exposed"]).String() == "string" {
		exposed, _ := strconv.ParseFloat(dataBody["exposed"].(string), 64)
		evaluation.Exposed = exposed
	}

	if dataBody["skin"] != nil && reflect.TypeOf(dataBody["skin"]).String() == "string" {
		skin, _ := dataBody["skin"].(string)
		//skins, _ := strconv.ParseInt(skin, 10, 64)
		evaluation.Skin = skin
	}

	if dataBody["skin_other"] != nil && reflect.TypeOf(dataBody["skin_other"]).String() == "string" {
		skin_other, _ := dataBody["skin_other"].(string)
		evaluation.SkinOther = skin_other
	}

	if dataBody["infect_other"] != nil && reflect.TypeOf(dataBody["infect_other"]).String() == "string" {
		infect_other, _ := dataBody["infect_other"].(string)
		evaluation.InfectOther = infect_other
	}

	if dataBody["ductus_arantii_other"] != nil && reflect.TypeOf(dataBody["ductus_arantii_other"]).String() == "string" {
		ductus_arantii_other, _ := dataBody["ductus_arantii_other"].(string)
		evaluation.DuctusArantiiOther = ductus_arantii_other
	}

	if dataBody["puncture_needle"] != nil && reflect.TypeOf(dataBody["puncture_needle"]).String() == "string" {
		punctureNeedle, _ := dataBody["puncture_needle"].(string)
		evaluation.PunctureNeedle = punctureNeedle
	}

	if dataBody["humor_excessive_symptom"] != nil && reflect.TypeOf(dataBody["humor_excessive_symptom"]).String() == "string" {

		humor_excessive_symptom, _ := dataBody["humor_excessive_symptom"].(string)

		evaluation.HumorExcessiveSymptom = humor_excessive_symptom
	}

	if dataBody["pinholing"] != nil && reflect.TypeOf(dataBody["pinholing"]).String() == "string" {
		pinholing := dataBody["pinholing"].(string)
		evaluation.Phinholing = pinholing
	}

	if dataBody["catheter_suture"] != nil && reflect.TypeOf(dataBody["catheter_suture"]).String() == "string" {
		catheter_suture := dataBody["catheter_suture"].(string)
		evaluation.CatheterSuture = catheter_suture
	}

	if dataBody["catheter_suture_other"] != nil && reflect.TypeOf(dataBody["catheter_suture_other"]).String() == "string" {
		catheter_suture_other := dataBody["catheter_suture_other"].(string)
		evaluation.CatheterSutureOther = catheter_suture_other
	}

	if dataBody["urine_volume"] != nil && reflect.TypeOf(dataBody["urine_volume"]).String() == "string" {
		urine_volume, _ := strconv.ParseFloat(dataBody["urine_volume"].(string), 64)
		evaluation.UrineVolume = urine_volume
	}

	if dataBody["edema"] != nil && reflect.TypeOf(dataBody["edema"]).String() == "string" {
		edema := dataBody["edema"].(string)
		evaluation.Edema = edema
	}

	if dataBody["special_treatment"] != nil && reflect.TypeOf(dataBody["special_treatment"]).String() == "string" {
		specialTreatment := dataBody["special_treatment"].(string)
		evaluation.SpecialTreatment = specialTreatment
	}

	if dataBody["catheter_maintenance"] != nil && reflect.TypeOf(dataBody["catheter_maintenance"]).String() == "string" {
		catheter_maintenance := dataBody["catheter_maintenance"].(string)
		evaluation.CatheterMaintenance = catheter_maintenance
	}

	if dataBody["thromubus_type"] != nil && reflect.TypeOf(dataBody["thromubus_type"]).String() == "float64" {

		thromubusType := int64(dataBody["thromubus_type"].(float64))

		evaluation.ThromubusType = thromubusType
	}

	if dataBody["thrombus_av"] != nil && reflect.TypeOf(dataBody["thrombus_av"]).String() == "string" {
		thrombus_av := dataBody["thrombus_av"].(string)
		evaluation.ThrombusAv = thrombus_av
	}

	if dataBody["thromubus_a"] != nil && reflect.TypeOf(dataBody["thromubus_a"]).String() == "string" {
		thromubus_a := dataBody["thromubus_a"].(string)
		evaluation.ThromubusA = thromubus_a
	}

	if dataBody["thromubus_v"] != nil && reflect.TypeOf(dataBody["thromubus_v"]).String() == "string" {
		thromubus_v := dataBody["thromubus_v"].(string)
		evaluation.ThromubusV = thromubus_v
	}

	if dataBody["dehydration"] != nil && reflect.TypeOf(dataBody["dehydration"]).String() == "string" {
		dehydration := dataBody["dehydration"].(string)
		evaluation.Dehydration = dehydration
	}

	if dataBody["period"] != nil && reflect.TypeOf(dataBody["period"]).String() == "float64" {
		period := int64(dataBody["period"].(float64))
		evaluation.Period = period
	}

	if dataBody["estimated_food_intake"] != nil && reflect.TypeOf(dataBody["estimated_food_intake"]).String() == "string" {
		estimated_food_intake := dataBody["estimated_food_intake"].(string)
		evaluation.EstimatedFoodIntake = estimated_food_intake
	}

	if dataBody["blood_pressure_during_dialysis"] != nil && reflect.TypeOf(dataBody["blood_pressure_during_dialysis"]).String() == "string" {
		blood_pressure_during_dialysis := dataBody["blood_pressure_during_dialysis"].(string)
		evaluation.BloodPressureDuringDialysis = blood_pressure_during_dialysis
	}

	if dataBody["pre_dialysis_drugs"] != nil && reflect.TypeOf(dataBody["pre_dialysis_drugs"]).String() == "string" {
		pre_dialysis_drugs := dataBody["pre_dialysis_drugs"].(string)
		evaluation.PreDialysisDrugs = pre_dialysis_drugs
	}

	if dataBody["urea_befor"] != nil && reflect.TypeOf(dataBody["urea_befor"]).String() == "string" {
		urea_befor := dataBody["urea_befor"].(string)
		evaluation.UreaBefor = urea_befor
	}

	if dataBody["suction"] != nil && reflect.TypeOf(dataBody["suction"]).String() == "string" {
		suction := dataBody["suction"].(string)

		evaluation.Suction = suction
	}
	return
}

func adviceFormData(advice *models.DoctorAdvice, data []byte, action string) (code int) {
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(data, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		code = enums.ErrorCodeParamWrong
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	isChild := false

	if action == "create" {
		if dataBody["advice_type"] == nil || reflect.TypeOf(dataBody["advice_type"]).String() != "float64" {
			utils.ErrorLog("advice_type")
			code = enums.ErrorCodeParamWrong
			return
		}
		adviceType := int64(dataBody["advice_type"].(float64))
		if adviceType != 1 && adviceType != 2 {
			utils.ErrorLog("advice_type != 1&&2")
			code = enums.ErrorCodeParamWrong
			return
		}
		advice.AdviceType = adviceType

		if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
			utils.ErrorLog("advice_date")
			code = enums.ErrorCodeParamWrong
			return
		}
		adviceDate, _ := dataBody["advice_date"].(string)
		if len(adviceDate) == 0 {
			utils.ErrorLog("len(adviceDate) == 0")
			code = enums.ErrorCodeParamWrong
			return
		}
		theTime, err := time.ParseInLocation(timeLayout, adviceDate, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			code = enums.ErrorCodeParamWrong
			return
		}
		advice.AdviceDate = theTime.Unix()
		advice.RecordDate = theTime.Unix()

		if dataBody["parent_id"] != nil && reflect.TypeOf(dataBody["parent_id"]).String() == "float64" {
			parentId := int64(dataBody["parent_id"].(float64))
			advice.ParentId = parentId
			if parentId > 0 {
				isChild = true
			}
		}

	} else {
		isChild = advice.ParentId > 0
	}

	if !isChild {

		if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
			utils.ErrorLog("start_time")
			code = enums.ErrorCodeParamWrong
			return
		}
		startTime, _ := dataBody["start_time"].(string)
		if len(startTime) == 0 {
			utils.ErrorLog("len(start_time) == 0")
			code = enums.ErrorCodeParamWrong
			return
		}
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			code = enums.ErrorCodeParamWrong
			return
		}
		advice.StartTime = theTime.Unix()

		if dataBody["delivery_way"] != nil && reflect.TypeOf(dataBody["delivery_way"]).String() == "string" {
			deliveryWay, _ := dataBody["delivery_way"].(string)
			advice.DeliveryWay = deliveryWay
		}

		if dataBody["execution_frequency"] != nil && reflect.TypeOf(dataBody["execution_frequency"]).String() == "string" {
			executionFrequency, _ := dataBody["execution_frequency"].(string)
			advice.ExecutionFrequency = executionFrequency
		}
	}

	if dataBody["delivery_way"] != nil && reflect.TypeOf(dataBody["delivery_way"]).String() == "string" {
		deliveryWay, _ := dataBody["delivery_way"].(string)
		advice.DeliveryWay = deliveryWay
	}

	if dataBody["execution_frequency"] != nil && reflect.TypeOf(dataBody["execution_frequency"]).String() == "string" {
		executionFrequency, _ := dataBody["execution_frequency"].(string)
		advice.ExecutionFrequency = executionFrequency
	}

	if dataBody["advice_name"] == nil || reflect.TypeOf(dataBody["advice_name"]).String() != "string" {
		utils.ErrorLog("advice_name")
		code = enums.ErrorCodeParamWrong
		return
	}
	adviceName, _ := dataBody["advice_name"].(string)
	if len(adviceName) == 0 {
		utils.ErrorLog("len(advice_name) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	advice.AdviceName = adviceName

	if dataBody["advice_desc"] != nil && reflect.TypeOf(dataBody["advice_desc"]).String() == "string" {
		adviceDsc, _ := dataBody["advice_desc"].(string)
		advice.AdviceDesc = adviceDsc
	}

	if dataBody["way"] == nil {
		advice.Way = 0

	} else {
		if dataBody["way"] != nil || reflect.TypeOf(dataBody["way"]).String() == "float64" {
			way := int64(dataBody["way"].(float64))
			advice.Way = way
		}

	}

	if dataBody["drug_id"] == nil {
		advice.DrugId = 0
	} else {
		if dataBody["drug_id"] != nil || reflect.TypeOf(dataBody["drug_id"]).String() == "float64" {
			drug_id := int64(dataBody["drug_id"].(float64))
			advice.DrugId = drug_id
		}
	}

	if dataBody["drug_name_id"] == nil {
		advice.DrugNameId = 0
	} else {
		if dataBody["drug_name_id"] != nil || reflect.TypeOf(dataBody["drug_name_id"]).String() == "float64" {
			drug_name_id := int64(dataBody["drug_name_id"].(float64))
			advice.DrugNameId = drug_name_id
			fmt.Println("0000000000", advice.DrugNameId)
		}
	}

	if dataBody["single_dose"] != nil && reflect.TypeOf(dataBody["single_dose"]).String() == "string" {
		singleDose, _ := strconv.ParseFloat(dataBody["single_dose"].(string), 64)
		advice.SingleDose = singleDose
	}

	if dataBody["single_dose_unit"] != nil && reflect.TypeOf(dataBody["single_dose_unit"]).String() == "string" {
		singleDoseUnit, _ := dataBody["single_dose_unit"].(string)
		advice.SingleDoseUnit = singleDoseUnit
	}

	if dataBody["drug_spec"] != nil && reflect.TypeOf(dataBody["drug_spec"]).String() == "string" {
		drugSpec, _ := strconv.ParseFloat(dataBody["drug_spec"].(string), 64)
		advice.DrugSpec = drugSpec
	}

	if dataBody["drug_spec_unit"] != nil && reflect.TypeOf(dataBody["drug_spec_unit"]).String() == "string" {
		drugSpecUnit, _ := dataBody["drug_spec_unit"].(string)
		advice.DrugSpecUnit = drugSpecUnit
	}

	if dataBody["prescribing_number"] != nil && reflect.TypeOf(dataBody["prescribing_number"]).String() == "string" {
		prescribingNumber, _ := strconv.ParseFloat(dataBody["prescribing_number"].(string), 64)
		advice.PrescribingNumber = prescribingNumber
	}

	if dataBody["prescribing_number_unit"] != nil && reflect.TypeOf(dataBody["prescribing_number_unit"]).String() == "string" {
		prescribingNumberUnit, _ := dataBody["prescribing_number_unit"].(string)
		advice.PrescribingNumberUnit = prescribingNumberUnit
	}

	if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
		remark, _ := dataBody["remark"].(string)
		advice.Remark = remark
	}

	return
}

func (c *PatientApiController) GetPatientEducation() {
	patientID, _ := c.GetInt64("patient_id", 0)
	page, _ := c.GetInt64("page", 0)
	limit, _ := c.GetInt64("limit", 0)
	startTime := c.GetString("start_time", "")
	endTime := c.GetString("end_time", "")

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	if patientID <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	var theStartTIme int64
	if len(startTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
		if err != nil {
			theStartTIme = 0
		}
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(endTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
		if err != nil {
			theEndtTIme = 0
		}
		theEndtTIme = theTime.Unix()
	}

	adminUserInfo := c.GetMobileAdminUserInfo()
	edus, total, _ := service.GetPatientTreatmentSummaryList(adminUserInfo.Org.Id, patientID, page, limit, theStartTIme, theEndtTIme)
	c.ServeSuccessJSON(map[string]interface{}{
		"total": total,
		"edus":  edus,
	})
	return

}

func (c *PatientApiController) GetPatientSchedulesList() {
	patientID, _ := c.GetInt64("patient_id", 0)
	page, _ := c.GetInt64("page", 0)
	limit, _ := c.GetInt64("limit", 0)
	if patientID <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminUserInfo := c.GetMobileAdminUserInfo()
	todayTime := time.Now().Format("2006-01-02")

	timeLayout := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")

	var theStartTime int64
	theTime, _ := time.ParseInLocation(timeLayout, todayTime+" 00:00:00", loc)
	theStartTime = theTime.Unix()

	schedules, _ := service.GetPatientScheduleList(adminUserInfo.Org.Id, patientID, page, limit, theStartTime)
	if len(schedules) > 0 {
		for index, item := range schedules {
			_, week := time.Unix(item.ScheduleDate, 0).ISOWeek()
			schedules[index].Week = int64(week)
		}
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"schedules": schedules,
	})
	return
}

func (c *PatientApiController) GetRecords() {

	patientID, _ := c.GetInt64("patient_id", 0)
	page, _ := c.GetInt64("page", 0)
	limit, _ := c.GetInt64("limit", 0)
	startTime := c.GetString("start_time", "")
	endTime := c.GetString("end_time", "")
	mode_id, _ := c.GetInt64("mode_id", 0)

	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}
	if patientID <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	var theStartTIme int64
	if len(startTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
		if err != nil {
			theStartTIme = 0
		}
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(endTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
		if err != nil {
			theEndtTIme = 0
		}
		theEndtTIme = theTime.Unix()
	}

	adminUserInfo := c.GetMobileAdminUserInfo()

	records, total, _ := service.GetPatientDialysisRecord(adminUserInfo.Org.Id, patientID, page, limit, theStartTIme, theEndtTIme, mode_id)

	c.ServeSuccessJSON(map[string]interface{}{
		"total":   total,
		"records": records,
	})
	return
}

func (c *PatientApiController) GetPatientMonitor() {
	partition, _ := c.GetInt64("partition")
	monitorDate := c.GetString("date")
	patient_id, _ := c.GetInt64("patient_id")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	var theStartTime int64
	if len(monitorDate) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", monitorDate+" 00:00:00", loc)
		if err != nil {
			theStartTime = 0
		}
		theStartTime = theTime.Unix()
	}
	adminInfo := c.GetMobileAdminUserInfo()
	orgID := adminInfo.Org.Id
	monitor, err := service.GetMonitorRecord(orgID, theStartTime, partition, patient_id)

	if err != nil {
		c.ErrorLog("获取排班信息失败:%v", err)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	} else {
		if len(monitor) > 0 {
			//获取所有床位
			numberList, _ := service.GetAllDeviceNumberByList(orgID)
			//获取所有分区
			zoneList, _ := service.GetAllZoneByList(orgID)
			//获取透析处方
			prescriptions, _ := service.GetAllPrescriptionByList(orgID, theStartTime)
			//获取透前评估
			assessmentBefores, _ := service.GetAllAssessmentBeforesByListOne(orgID, theStartTime)
			//获取上机
			dialysisOrders, _ := service.GetAllDialysisOrdersByListSix(orgID, theStartTime)
			//获取透后
			AssessmentAfterDislysis, _ := service.GetAllAssessmentAfterDislysisByListOne(orgID, theStartTime)

			//获取透后监测
			monitorlist, _ := service.GetAllMonitorList(orgID, theStartTime)

			//获取所有的患者
			patients, _ := service.GetAllPatientListByListOne(orgID)

			//获取所有透析模式
			treatments, _ := service.GetAllTreatModeByList(orgID)

			for key, item := range monitor {
				// 获取床位信息
				for _, it := range numberList {
					if item.BedId == it.ID {
						monitor[key].DeviceNumber = it
						break
					}
				}

				//获取分区信息
				for _, it := range zoneList {
					if item.PartitionId == it.ID {
						monitor[key].DeviceZone = it
					}
				}

				for _, prescription := range prescriptions {
					if item.PatientId == prescription.PatientId {
						monitor[key].Prescription = prescription
						break
					}
				}

				// 透前评估
				for _, assessmentBefore := range assessmentBefores {
					if item.PatientId == assessmentBefore.PatientId {
						monitor[key].AssessmentBeforeDislysis = assessmentBefore
						break
					}
				}

				// 透析上下机
				for _, dialysisOrder := range dialysisOrders {
					if item.PatientId == dialysisOrder.PatientId {
						monitor[key].DialysisOrder = dialysisOrder
						break
					}
				}

				// 治疗小节
				for _, afterDislysis := range AssessmentAfterDislysis {
					if item.PatientId == afterDislysis.PatientId {
						monitor[key].AssessmentAfterDislysis = afterDislysis
						break
					}
				}

				for _, it := range monitorlist {
					if item.PatientId == it.PatientId {
						monitor[key].MonitoringRecord = append(monitor[key].MonitoringRecord, it)
					}
				}

				for _, patient := range patients {
					if item.PatientId == patient.ID {
						monitor[key].MonitorPatients = patient
						break
					}
				}

				for _, treatment := range treatments {
					if item.ModeId == treatment.ID {
						monitor[key].TreatmentMode = treatment
						break
					}
				}
			}
		}

	}

	//获取患者的透析次数
	count, err := service.GetDialysisCount(orgID, partition)

	patients, err := service.GetAllpatient(orgID)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"monitor":      monitor,
			"patientCount": count,
			"patients":     patients,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
	}
}

// /m/api/monitor/patient [get] 搜索病人的测量记录
// @param keyword:string 病人姓名或透析号
// @param page:int
func (this *PatientApiController) SearchMonitorPatient() {
	keyword := this.GetString("keyword")
	page, _ := this.GetInt("page")
	if page <= 0 {
		page = 1
	}
	if len(keyword) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := this.GetMobileAdminUserInfo()
	monitors, getMonitorErr := service.MobileGetMonitorsWithPatient(adminUserInfo.Org.Id, keyword, page)
	if getMonitorErr != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"monitor": monitors,
		})
	}
}

func (c *PatientApiController) GetPatientDialysisSolutionList() {
	id, _ := c.GetInt64("id", 0)
	page, _ := c.GetInt64("page", 0)
	limit, _ := c.GetInt64("limit", 0)
	if id <= 0 {
		c.ServeSuccessJSON(map[string]interface{}{
			"solutions": nil,
		})
		return
	}
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}

	adminInfo := c.GetMobileAdminUserInfo()

	solutions, total, _ := service.GetPatientDialysisSolutionList(adminInfo.Org.Id, id, page, limit)
	c.ServeSuccessJSON(map[string]interface{}{
		"solutions": solutions,
		"total":     total,
	})
	return
}

//GetDoctorAdvices 医嘱列表
func (c *PatientApiController) GetDoctorAdvices() {
	id, _ := c.GetInt64("id", 0)
	adviceType, _ := c.GetInt64("advice_type", 0)
	stopType, _ := c.GetInt64("stop_state", 0)
	startTime := c.GetString("start_time", "")
	endTime := c.GetString("end_time", "")
	keywords := c.GetString("keywords", "")

	need, _ := c.GetInt64("need_doctor", 0)

	adminUserInfo := c.GetMobileAdminUserInfo()

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	var theStartTIme int64
	if len(startTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", startTime+" 00:00:00", loc)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		theStartTIme = theTime.Unix()
	}
	var theEndtTIme int64
	if len(endTime) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", endTime+" 23:59:59", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		theEndtTIme = theTime.Unix()
	}

	advices, total, _ := service.GetDoctorAdviceList(adminUserInfo.Org.Id, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords)

	if need == 1 {
		users, _ := service.GetAllAdminUsers(adminUserInfo.Org.Id, adminUserInfo.App.Id)
		c.ServeSuccessJSON(map[string]interface{}{
			"advices": advices,
			"total":   total,
			"users":   users,
		})
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"advices": advices,
			"total":   total,
			"users":   []string{},
		})
	}
	return

}

func (c *PatientApiController) GetPrintDialysisOrder() {
	xtno := c.GetString("xtno")
	xtdate := c.GetString("xtdate")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", xtdate+" 00:00:00", loc)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	xttime := theTime.Unix()
	//获取当前日期月份的第一天
	firstmonth := service.GetFirstDateOfMonth(theTime)
	firstMonthDate := firstmonth.Unix()
	operatorIDs := make([]int64, 0)

	adminUserInfo := c.GetMobileAdminUserInfo()

	adminUser, _ := service.GetAllAdminUsers(adminUserInfo.Org.Id, adminUserInfo.App.Id)

	patientInfo, _ := service.FindPatientWithDeviceByNo(adminUserInfo.Org.Id, xtno, xttime)

	//透析单
	dialysisOrder, _ := service.MobileGetSchedualDialysisRecord(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	if dialysisOrder != nil {
		if dialysisOrder.FinishNurse > 0 {
			operatorIDs = append(operatorIDs, dialysisOrder.FinishNurse)
		}
		if dialysisOrder.StartNurse > 0 {
			operatorIDs = append(operatorIDs, dialysisOrder.StartNurse)
		}
	}

	last_order, _ := service.GetLastTimeOrder(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	//透前评估
	PredialysisEvaluation, _ := service.FindPredialysisEvaluationById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	//透后评估
	AssessmentAfterDislysis, _ := service.FindAssessmentAfterDislysisById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	if AssessmentAfterDislysis.Modifier > 0 {
		operatorIDs = append(operatorIDs, AssessmentAfterDislysis.Modifier)
	}
	//透析处方
	dialysisPrescription, _ := service.FindPatientPrescribeWidyDevideById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	if dialysisPrescription.PrescriptionDoctor > 0 {
		operatorIDs = append(operatorIDs, dialysisPrescription.PrescriptionDoctor)
	}

	dialysis_count, _ := service.GetDialysisOrderCount(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	patientInfo.TotalDialysis = dialysis_count

	//临时医嘱
	DoctorAdvice, _ := service.FindDoctorAdviceOrderById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	hisAdvice, err := service.GetHisDoctorPatientById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	config, err := service.GetHisDoctorConfig(adminUserInfo.Org.Id)

	project_config, _ := service.GetHisProjectConfig(adminUserInfo.Org.Id)
	projects, _ := service.FindAllHisProjectById(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	if config.IsOpen == 1 && project_config.IsOpen == 1 && len(projects) > 0 {
		for _, item := range projects {
			cnt, _ := strconv.ParseFloat(item.Count, 64)
			var advice models.HisDoctorAdviceInfo
			advice.ID = item.ID
			advice.Checker = item.Checker
			advice.CheckTime = item.CheckTime
			advice.CheckState = item.CheckState
			advice.ExecutionState = item.ExecutionState
			advice.ExecutionStaff = item.ExecutionStaff
			//advice.PrescribingNumber = float64(item.Count)
			advice.PrescribingNumber = cnt
			advice.PrescribingNumberUnit = item.Unit
			advice.AdviceDoctor = item.Doctor
			if item.Type == 3 {
				advice.AdviceName = item.GoodInfo.GoodName
				advice.PrescribingNumberUnit = item.GoodInfo.PackingUnit
			} else if item.Type == 2 {
				advice.AdviceName = item.HisProject.ProjectName
			}
			advice.StartTime = item.StartTime
			hisAdvice = append(hisAdvice, &advice)
		}

	}

	if len(DoctorAdvice) > 0 {
		for _, item := range DoctorAdvice {
			if item.AdviceDoctor > 0 {
				operatorIDs = append(operatorIDs, item.AdviceDoctor)
			}
			if item.ExecutionStaff > 0 {
				operatorIDs = append(operatorIDs, item.ExecutionStaff)
			}
			if item.Checker > 0 {
				operatorIDs = append(operatorIDs, item.Checker)
			}
		}
	}

	//DoctorAdvice, _ := service.FindDoctorAdviceOrderById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	//透析监测
	Record, _ := service.FindAllMonitorRecord(adminUserInfo.Org.Id, patientInfo.ID, xttime)
	//透析小结
	TreatmentSummary, _ := service.FindTreatmentSummaryById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	//接诊评估
	receiverTreatmentAccess, _ := service.FindReceiverTreatmentAccessRecordById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	//相关操作对应的操作人
	//operators, _ := service.GetAdminUserES(adminUserInfo.Org.Id, adminUserInfo.App.Id, operatorIDs)
	operators, err := service.GetAllStarfEs(adminUserInfo.Org.Id)
	templateInfo, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
	check, _ := service.FindDoubleCheckById(adminUserInfo.Org.Id, patientInfo.ID, xttime)

	dialysiscount, err := service.GetDialysisCountByPatientId(firstMonthDate, xttime, patientInfo.ID, adminUserInfo.Org.Id)

	if config.IsOpen == 1 {
		c.ServeSuccessJSON(map[string]interface{}{
			"users":                   adminUser,
			"patientInfo":             patientInfo,
			"PredialysisEvaluation":   PredialysisEvaluation,
			"AssessmentAfterDislysis": AssessmentAfterDislysis,
			"dialysisPrescription":    dialysisPrescription,
			"advices":                 hisAdvice,
			"monitors":                Record,
			"summary":                 TreatmentSummary,
			"receiverTreatmentAccess": receiverTreatmentAccess,
			"dialysisOrder":           dialysisOrder,
			"operators":               operators,
			"org_template_info":       templateInfo,
			"check":                   check,
			"dialysiscount":           dialysiscount,
			"last_order":              last_order,
			"projects":                projects,
			"project_config":          project_config,
		})
	}

	if config.IsOpen == 0 || config.IsOpen == 2 {
		c.ServeSuccessJSON(map[string]interface{}{
			"users":                   adminUser,
			"patientInfo":             patientInfo,
			"PredialysisEvaluation":   PredialysisEvaluation,
			"AssessmentAfterDislysis": AssessmentAfterDislysis,
			"dialysisPrescription":    dialysisPrescription,
			"advices":                 DoctorAdvice,
			"monitors":                Record,
			"summary":                 TreatmentSummary,
			"receiverTreatmentAccess": receiverTreatmentAccess,
			"dialysisOrder":           dialysisOrder,
			"operators":               operators,
			"org_template_info":       templateInfo,
			"check":                   check,
			"dialysiscount":           dialysiscount,
			"last_order":              last_order,
			"projects":                projects,
			"project_config":          project_config,
		})
	}

}

func (c *PatientApiController) CreateGroupAdvice() {
	is_child, _ := c.GetInt64("is_child", 0)
	if is_child == 1 {
		patient, _ := c.GetInt64("id", 0)
		if patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adminUserInfo := c.GetMobileAdminUserInfo()

		patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
		if patientInfo.ID == 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
			return
		}

		group_no, _ := c.GetInt64("group_no")
		if group_no <= 0 {
			group_no = 0
		}

		dataBody := make(map[string]interface{}, 0)
		err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")

		if dataBody["advice_type"] == nil || reflect.TypeOf(dataBody["advice_type"]).String() != "float64" {
			utils.ErrorLog("advice_type")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adviceType := int64(dataBody["advice_type"].(float64))
		if adviceType != 1 && adviceType != 2 {
			utils.ErrorLog("advice_type != 1&&2")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
			utils.ErrorLog("start_time")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		startTime2, _ := dataBody["start_time"].(string)
		time_arr := strings.Split(startTime2, " ")
		if len(time_arr) > 0 {
			startTime2 = time_arr[0]
		}
		if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
			utils.ErrorLog("advice_date")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adviceDate := startTime2
		if len(adviceDate) == 0 {
			utils.ErrorLog("len(adviceDate) == 0")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		theTime, err := time.ParseInLocation(timeLayout, adviceDate, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		AdviceDate := theTime.Unix()
		RecordDate := theTime.Unix()

		if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
			utils.ErrorLog("start_time")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime, _ := dataBody["start_time"].(string)
		if len(startTime) == 0 {
			utils.ErrorLog("len(start_time) == 0")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		theTime, err = time.ParseInLocation(timeLayout+" 15:04:05", startTime, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		StartTime := theTime.Unix()

		Remark := ""
		if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
			remark, _ := dataBody["remark"].(string)
			Remark = remark
		}

		var advices []*models.GroupAdvice
		// utils.TraceLog("%+v", dataBody["adviceNames"])
		if dataBody["adviceNames"] == nil || reflect.TypeOf(dataBody["adviceNames"]).String() != "[]interface {}" {
			utils.ErrorLog("adviceNames")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adviceNames := dataBody["adviceNames"].([]interface{})
		for _, adviceNameMap := range adviceNames {
			adviceNameM := adviceNameMap.(map[string]interface{})
			var advice models.GroupAdvice
			advice.Remark = Remark
			advice.AdviceType = adviceType
			advice.StartTime = StartTime
			advice.AdviceDate = AdviceDate
			advice.RecordDate = RecordDate
			advice.Status = 1
			advice.CreatedTime = time.Now().Unix()
			advice.UpdatedTime = time.Now().Unix()
			advice.StopState = 2
			advice.ExecutionState = 2
			advice.UserOrgId = adminUserInfo.Org.Id
			advice.PatientId = patientInfo.ID
			advice.AdviceDoctor = adminUserInfo.AdminUser.Id

			//入口
			errcode := c.setAdviceWithJSON(&advice, adviceNameM)
			if errcode > 0 {
				c.ServeFailJSONWithSGJErrorCode(errcode)
				return
			}

			if adviceNameM["subdrugs"] != nil && reflect.TypeOf(adviceNameM["subdrugs"]).String() == "[]interface {}" {
				subdrugs := adviceNameM["subdrugs"].([]interface{})
				if len(subdrugs) > 0 {
					for _, subdrug := range subdrugs {
						var s models.GroupAdvice
						s.Remark = Remark
						s.AdviceType = adviceType
						s.StartTime = StartTime
						s.AdviceDate = AdviceDate
						s.RecordDate = RecordDate
						s.Status = 1
						s.CreatedTime = time.Now().Unix()
						s.UpdatedTime = time.Now().Unix()
						s.StopState = 2
						s.ExecutionState = 2
						s.UserOrgId = adminUserInfo.Org.Id
						s.PatientId = patientInfo.ID
						s.AdviceDoctor = adminUserInfo.AdminUser.Id

						errcode := c.setAdviceWithJSON(&s, subdrug.(map[string]interface{}))
						if errcode > 0 {
							c.ServeFailJSONWithSGJErrorCode(errcode)
							return
						}

						advice.Children = append(advice.Children, &s)
					}
				}
			}

			advices = append(advices, &advice)
		}

		newAdvices, createErr := service.CreateMGroupAdvice(adminUserInfo.Org.Id, advices, group_no)
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":doctor_advices"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
		redis.Set(keyOne, "", time.Second)

		defer redis.Close()
		if createErr != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
			return
		}

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":     "ok",
			"advices": newAdvices,
		})
		return

	} else if is_child == 2 {

		patient, _ := c.GetInt64("id", 0)
		if patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetMobileAdminUserInfo()
		patientInfo, _ := service.FindPatientById(adminUserInfo.Org.Id, patient)
		if patientInfo.ID == 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
			return
		}
		var advice models.DoctorAdvice
		code := adviceFormData(&advice, c.Ctx.Input.RequestBody, "create")
		if code > 0 {
			c.ServeFailJSONWithSGJErrorCode(code)
			return
		}

		if advice.ParentId > 0 {
			old, _ := service.FindDoctorAdvice(adminUserInfo.Org.Id, advice.ParentId)
			if old.ID == 0 || old.PatientId != patient {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
				return
			}

			if old.StopState == 1 || old.ExecutionState == 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
				return
			}

			if old.ParentId > 0 {
				advice.ParentId = old.ParentId
			}
			advice.StartTime = old.StartTime
			advice.AdviceDoctor = old.AdviceDoctor
			advice.DeliveryWay = old.DeliveryWay
			advice.ExecutionFrequency = old.ExecutionFrequency
			advice.GroupNo = old.GroupNo

		}

		advice.Status = 1
		advice.CreatedTime = time.Now().Unix()
		advice.UpdatedTime = time.Now().Unix()
		advice.StopState = 2
		advice.ExecutionState = 2
		advice.UserOrgId = adminUserInfo.Org.Id
		advice.PatientId = patient
		advice.AdviceDoctor = adminUserInfo.AdminUser.Id

		err := service.CreateDoctorAdvice(&advice)
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
		redis.Set(keyOne, "", time.Second)
		fmt.Println("key`2232333332233223233232", key)
		defer redis.Close()
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
			return
		}

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":    "ok",
			"advice": advice,
		})
		return

	}

}

func (c *PatientApiController) setAdviceWithJSON(advice *models.GroupAdvice, json map[string]interface{}) int {

	if json["advice_name"] == nil || reflect.TypeOf(json["advice_name"]).String() != "string" {
		utils.ErrorLog("advice_name")
		return enums.ErrorCodeParamWrong
	}
	adviceName, _ := json["advice_name"].(string)
	if len(adviceName) == 0 {
		utils.ErrorLog("len(advice_name) == 0")
		return enums.ErrorCodeParamWrong
	}
	advice.AdviceName = adviceName

	adviceDesc, _ := json["advice_desc"].(string)
	advice.AdviceDesc = adviceDesc

	if json["drug_spec"] != nil && reflect.TypeOf(json["drug_spec"]).String() == "string" {
		drugSpec, _ := strconv.ParseFloat(json["drug_spec"].(string), 64)
		advice.DrugSpec = drugSpec
	}

	if json["remark"] != nil && reflect.TypeOf(json["remark"]).String() == "string" {
		remark, _ := json["remark"].(string)
		advice.Remark = remark
	}

	//if json["src_type"] != nil || reflect.TypeOf(json["src_type"]).String() == "float64" {
	//	src_type, _ := strconv.ParseInt(json["src_type"].(string),10)
	//	advice.Way = src_type
	//}
	if json["way"] == nil {
		advice.Way = 0

	} else {
		if json["way"] != nil || reflect.TypeOf(json["way"]).String() == "float64" {
			way := int64(json["way"].(float64))
			advice.Way = way
		}

	}

	if json["drug_id"] == nil {
		advice.DrugId = 0
	} else {
		if json["drug_id"] != nil || reflect.TypeOf(json["drug_id"]).String() == "float64" {
			drug_id := int64(json["drug_id"].(float64))
			advice.DrugId = drug_id
		}
	}

	if json["drug_name_id"] == nil {
		advice.DrugNameId = 0
	} else {
		if json["drug_name_id"] != nil || reflect.TypeOf(json["drug_name_id"]).String() == "float64" {
			drug_name_id := int64(json["drug_name_id"].(float64))
			advice.DrugNameId = drug_name_id
		}
	}

	if json["drug_spec_unit"] != nil && reflect.TypeOf(json["drug_spec_unit"]).String() == "string" {
		drugSpecUnit, _ := json["drug_spec_unit"].(string)
		advice.DrugSpecUnit = drugSpecUnit
	}

	if json["single_dose"] != nil && reflect.TypeOf(json["single_dose"]).String() == "string" {
		singleDose, _ := strconv.ParseFloat(json["single_dose"].(string), 64)
		advice.SingleDose = singleDose
	}

	if json["single_dose_unit"] != nil && reflect.TypeOf(json["single_dose_unit"]).String() == "string" {
		singleDoseUnit, _ := json["single_dose_unit"].(string)
		advice.SingleDoseUnit = singleDoseUnit
	}

	if json["prescribing_number"] != nil && reflect.TypeOf(json["prescribing_number"]).String() == "string" {
		prescribingNumber, _ := strconv.ParseFloat(json["prescribing_number"].(string), 64)
		advice.PrescribingNumber = prescribingNumber
	}

	if json["prescribing_number_unit"] != nil && reflect.TypeOf(json["prescribing_number_unit"]).String() == "string" {
		prescribingNumberUnit, _ := json["prescribing_number_unit"].(string)
		advice.PrescribingNumberUnit = prescribingNumberUnit
	}
	if json["delivery_way"] != nil && reflect.TypeOf(json["delivery_way"]).String() == "string" {
		deliveryWay, _ := json["delivery_way"].(string)
		advice.DeliveryWay = deliveryWay
	}

	if json["execution_frequency"] != nil && reflect.TypeOf(json["execution_frequency"]).String() == "string" {
		executionFrequency, _ := json["execution_frequency"].(string)
		advice.ExecutionFrequency = executionFrequency
	}
	return 0
}

func (c *PatientApiController) DelDoctorAdvice() {
	groupno, _ := c.GetInt64("groupno", -1)
	is_sub, _ := c.GetInt64("is_sub", -1) //是否子药
	patient_id, _ := c.GetInt64("patient_id")
	doc_advice_date, _ := c.GetInt64("advice_date")
	redis := service.RedisClient()
	if is_sub == 1 { //是

		advice_id, _ := c.GetInt64("advice_id")
		adminUserInfo := c.GetMobileAdminUserInfo()
		advice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice_id)
		if advice.ID == 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
			return
		}

		advice.Status = 0
		advice.UpdatedTime = time.Now().Unix()
		advice.Modifier = adminUserInfo.AdminUser.Id

		err := service.DeleteDoctorAdvice(&advice)
		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

		redis.Set(key, "", time.Second)

		keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"
		redis.Set(keyTwo, "", time.Second)
		keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
		redis.Set(keyThree, "", time.Second)
		redis.Close()
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
			return
		}

		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "ok",
		})

		return

	} else { //

		var ids []string
		if groupno == 0 {
			advice_id := c.GetString("advice_id")
			ids = strings.Split(advice_id, ",")
			if len(ids) <= 0 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
				return
			}
		}
		if groupno < 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetMobileAdminUserInfo()
		var advice models.DoctorAdvice
		if groupno > 0 {
			advice, _ = service.FindDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
			if advice.ID == 0 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
				return
			}
		} else {
			advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
			for _, item := range advices {
				if item.ID == 0 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
					return
				}
			}
		}

		advice.UpdatedTime = time.Now().Unix()
		advice.Status = 0
		advice.GroupNo = groupno
		advice.Modifier = adminUserInfo.AdminUser.Id

		var err error
		if groupno > 0 {

			err = service.DeleteDoctorAdviceByGroupNo(&advice)
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

			redis.Set(key, "", time.Second)

			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"

			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
		} else {

			err = service.BatchDeleteDoctorAdvice(ids, adminUserInfo.AdminUser.Id)
			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":doctor_advices"

			redis.Set(key, "", time.Second)

			keyTwo := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":advice_list_all"

			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(doc_advice_date, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			redis.Close()
		}

		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
			return
		}

		c.ServeSuccessJSON(map[string]interface{}{
			"msg": "ok",
		})
		return

	}

}

// /m/api/advice/group/modify_starttime [post]
// @param group_no:int
// @param start_time:string yyyy-MM-dd hh:mm:ss
func (this *PatientApiController) ModifyAdviceGroupStartTime() {
	group_no, _ := this.GetInt64("group_no")
	start_time_str := this.GetString("start_time")
	if group_no <= 0 || len(start_time_str) == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	startTime, parseTimeErr := utils.ParseTimeStringToTime("2006-01-02 15:04:05", start_time_str)
	if parseTimeErr != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamFormatWrong)
		return
	}

	adminUserInfo := this.GetMobileAdminUserInfo()
	updateStartTimeErr := service.UpdateAdviceGroupStartTime(adminUserInfo.Org.Id, group_no, startTime.Unix(), adminUserInfo.AdminUser.Id)
	if updateStartTimeErr != nil {
		utils.ErrorLog("修改医嘱分组的开始时间失败：%v", updateStartTimeErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"start_time": startTime.Unix(),
	})
}

func (this *PatientApiController) DelSubDoctorAdvice() {
	advice_id, _ := this.GetInt64("advice_id")
	adminUserInfo := this.GetMobileAdminUserInfo()
	advice, _ := service.FindOldDoctorAdvice(adminUserInfo.Org.Id, advice_id)
	if advice.ID == 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}
	//if !adminUserInfo.AdminUser.IsSuperAdmin && advice.AdviceDoctor != adminUserInfo.AdminUser.Id {
	//	this.ServeFailJSONWithSGJErrorCode(enums. bh)
	//	return
	//}

	advice.Status = 0
	advice.UpdatedTime = time.Now().Unix()
	advice.Modifier = adminUserInfo.AdminUser.Id

	err := service.DeleteDoctorAdvice(&advice)
	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
		return
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	return
}

func (this *PatientApiController) GetAdviceUnReadMessage() {
	//adminUserInfo := this.GetMobileAdminUserInfo()
	//service.FindUnReadDoctorAdviceMessage()

}

func (this *PatientApiController) GetPatientsByKeyWord() {
	keyWord := this.GetString("keyword")
	adminUserInfo := this.GetMobileAdminUserInfo()
	today := utils.ZeroHourTimeOfDay(time.Now())
	patient, err := service.GetSchedualPatientByKeyWord(adminUserInfo.Org.Id, keyWord, today.Unix())
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
}

func (this *PatientApiController) GetSearchPatient() {

	keyWord := this.GetString("keyword")
	adminUserInfo := this.GetMobileAdminUserInfo()
	patient, err := service.GetPatientsByKey(adminUserInfo.Org.Id, keyWord)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
}

func (c *PatientApiController) ExecProject() {
	execution_time := c.GetString("execution_time")
	project_id, _ := c.GetInt64("project_id")
	team_id, _ := c.GetInt64("team_id")
	is_check_team, _ := c.GetInt64("is_check_team")

	if len(execution_time) <= 0 {
		utils.ErrorLog("execution_time")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	timeLayout2 := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")
	theTime, errs := time.ParseInLocation(timeLayout2, execution_time, loc)
	if errs != nil {
		utils.ErrorLog(errs.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminInfo := c.GetMobileAdminUserInfo()

	project, _ := service.FindHisProjectById(adminInfo.Org.Id, project_id)

	if project.Type == 3 {
		good, _ := service.GetGoodInformationByGoodId(project.ProjectId)
		if good.IsUser != 1 {

			//查询开关是否开启
			stockSetting, _ := service.FindStockSettingById(adminInfo.Org.Id)

			//开关已经开启
			if stockSetting.IsType == 1 {
				theTime, _ := time.ParseInLocation(timeLayout2, execution_time, loc)
				scheduleDateStart := theTime.Format("2006-01-02")
				timeLayout3 := "2006-01-02"
				loc, _ := time.LoadLocation("Local")
				execuTime, _ := time.ParseInLocation(timeLayout3, scheduleDateStart, loc)
				//查询该耗材是否已经出库
				auto, _ := service.GetAutoStockOutById(project.ProjectId, execuTime.Unix(), adminInfo.Org.Id, project.PatientId)
				if auto.ID == 0 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStockExced)
					return
				}
			}
		}

		if good.IsUser == 1 && good.IsWarehouse == 1 {

			//查询开关是否开启
			stockSetting, _ := service.FindStockSettingById(adminInfo.Org.Id)

			//开关已经开启
			if stockSetting.IsType == 1 {
				theTime, _ := time.ParseInLocation(timeLayout2, execution_time, loc)
				scheduleDateStart := theTime.Format("2006-01-02")
				timeLayout3 := "2006-01-02"
				loc, _ := time.LoadLocation("Local")
				execuTime, _ := time.ParseInLocation(timeLayout3, scheduleDateStart, loc)
				//查询该耗材是否已经出库
				auto, _ := service.GetAutoStockOutById(project.ProjectId, execuTime.Unix(), adminInfo.Org.Id, project.PatientId)
				if auto.ID == 0 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStockExced)
					return
				}
			}
		}
	}

	if project.ExecutionState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
		return
	}
	if project.Checker >= 0 && project.Checker == adminInfo.AdminUser.Id {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
		return
	}
	project.ExecutionState = 1
	project.ExecutionStaff = adminInfo.AdminUser.Id
	project.ExecutionTime = theTime.Unix()
	if team_id == 0 {

		err := service.SaveHisProject(&project)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"project": project,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
			return

		}
	} else {
		if is_check_team == 2 { //虽然是组套数据，但不是检验项目

			err := service.SaveHisProject(&project)
			if err == nil {
				c.ServeSuccessJSON(map[string]interface{}{
					"project": project,
				})
			} else {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
				return

			}
		} else {
			ps, _ := service.GetCheckTeamProject(team_id, project.PatientId, project.RecordDate, project.UserOrgId)
			var ids []int64
			for _, items := range ps {
				ids = append(ids, items.ID)
			}
			err := service.UpdateTeamProjectExceStatus(ids, adminInfo.AdminUser.Id, theTime.Unix())
			if err == nil {
				c.ServeSuccessJSON(map[string]interface{}{
					"project": project,
				})
			} else {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
				return

			}
		}

	}
}

func (c *PatientApiController) CheckProject() {

	adminInfo := c.GetMobileAdminUserInfo()
	project_id, _ := c.GetInt64("project_id")
	team_id, _ := c.GetInt64("team_id")
	is_check_team, _ := c.GetInt64("is_check_team")

	project, _ := service.FindHisProjectById(adminInfo.Org.Id, project_id)
	if project.CheckState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
		return
	}
	if project.ExecutionStaff >= 0 && project.ExecutionStaff == adminInfo.AdminUser.Id {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeExceAndCheckNotOneUser)
		return
	}

	project.Checker = adminInfo.AdminUser.Id
	project.CheckTime = time.Now().Unix()
	project.CheckState = 1
	if team_id == 0 {
		err := service.SaveHisProject(&project)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":     "ok",
				"project": project,
			})

		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
			return

		}

	} else {
		if is_check_team == 2 { //虽然是组套数据，但不是检验项目
			err := service.SaveHisProject(&project)
			if err == nil {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":     "ok",
					"project": project,
				})

			} else {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
				return

			}

		} else {
			ps, _ := service.GetCheckTeamProject(team_id, project.PatientId, project.RecordDate, project.UserOrgId)
			var ids []int64
			for _, items := range ps {
				ids = append(ids, items.ID)
			}
			err := service.UpdateTeamProjectCheckStatus(ids, project.PatientId, project.RecordDate, project.UserOrgId, adminInfo.AdminUser.Id, time.Now().Unix())
			if err == nil {
				c.ServeSuccessJSON(map[string]interface{}{
					"project": project,
				})
			} else {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
				return

			}
		}

	}

}