XT_New/controllers/patient_api_controller.go

package controllers

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

	//"github.com/jinzhu/gorm"
	"math"
	"math/rand"
	"reflect"
	"regexp"
	"strconv"
	"strings"
	"time"

	"fmt"

	"github.com/astaxie/beego"
)

type PatientApiController struct {
	BaseAuthAPIController
}

func PatientApiRegistRouters() {
	beego.Router("/api/patients", &PatientApiController{}, "get:GetPatientsList")
	beego.Router("/api/patients/all", &PatientApiController{}, "get:GetPatientsAllList")
	beego.Router("/api/patients/generatedialysisno", &PatientApiController{}, "get:GenerateDialysisNo")
	beego.Router("/api/patients/create", &PatientApiController{}, "Post:CreatePatient")
	beego.Router("/api/patients/total", &PatientApiController{}, "Get:GetPatientTotal")
	beego.Router("/api/patients/get", &PatientApiController{}, "Get:GetPatient")
	beego.Router("/api/patients/edit", &PatientApiController{}, "Put:EditPatient")
	beego.Router("/api/patients/dialysissolution/create", &PatientApiController{}, "Post:CreateDialysisSolution")
	beego.Router("/api/patients/dialysissolution/edit", &PatientApiController{}, "Put:UpdateDialysisSolution")
	beego.Router("/api/patients/dialysissolutions", &PatientApiController{}, "get:GetPatientDialysisSolutionList")
	beego.Router("/api/patients/dialysissolution/detail/edit", &PatientApiController{}, "Put:UpdateDialysisSolutionDetail")
	// beego.Router("/api/patients/dialysissolution/delete", &PatientApiController{}, "Delete:DeleteDialysisSolution")

	beego.Router("/api/patients/dryweight/get", &PatientApiController{}, "get:GetDryWeights")
	beego.Router("/api/patients/dryweight/create", &PatientApiController{}, "Post:CreateDryWeights")

	beego.Router("/api/patients/advice/create", &PatientApiController{}, "Post:CreateDoctorAdvice")
	beego.Router("/api/patients/advice/edit", &PatientApiController{}, "Put:UpdateDoctorAdvice")
	beego.Router("/api/patients/advice/exec", &PatientApiController{}, "Post:ExecDoctorAdvice")
	beego.Router("/api/patients/advice/check", &PatientApiController{}, "Post:CheckDoctorAdvice")
	beego.Router("/api/patients/advices", &PatientApiController{}, "Get:GetDoctorAdvices")
	beego.Router("/api/patients/advice/stop", &PatientApiController{}, "Post:StopDoctorAdvice")
	beego.Router("/api/patients/advice/delete", &PatientApiController{}, "Delete:DeleteDoctorAdvice")
	beego.Router("/api/patients/advice/creategroup", &PatientApiController{}, "Post:CreateGroupAdvice")
	beego.Router("/api/patients/advice/deletegroup", &PatientApiController{}, "Delete:DeleteGroupAdvice")
	beego.Router("/api/patients/advice/stopgroup", &PatientApiController{}, "Post:StopGroupAdvice")
	beego.Router("/api/patients/advice/execgroup", &PatientApiController{}, "Post:ExecGroupAdvice")
	beego.Router("/api/patients/advice/checkgroup", &PatientApiController{}, "Post:CheckGroupAdvice")

	beego.Router("/api/patients/schedules", &PatientApiController{}, "Get:GetPatientSchedules")
	beego.Router("/api/patients/dialysisrecords", &PatientApiController{}, "Get:GetPatientDialysisRecords")
	beego.Router("/api/patients/proeducation", &PatientApiController{}, "Get:ProEducation")
	beego.Router("/api/patients/lapseto/edit", &PatientApiController{}, "Post:EditLapseto")

	beego.Router("/api/patients/search", &PatientApiController{}, "Post:GetPatientsByKeyWord")

	beego.Router("/api/patients/querypatientbyId", &PatientApiController{}, "Get:QueryPatientById")

	beego.Router("/api/infectious/remind", &PatientApiController{}, "Get:GetRemindPatientList")

	beego.Router("/api/remind/is_open", &PatientApiController{}, "Post:PostIsOpenRemind")
	beego.Router("/api/patients/advices/getpatientschedules", &PatientApiController{}, "Get:GetPatientScheduleOne")

	beego.Router("/api/patients/export", &PatientApiController{}, "Post:ExportPatients")

	beego.Router("/api/patients/advices/saveditadvices", &PatientApiController{}, "Get:SaveEditAdvices")

	beego.Router("/api/patients/dialysis_no", &PatientApiController{}, "Get:GetMaxDialysisNo")

	beego.Router("/api/patients/banner", &PatientApiController{}, "Get:GetBanner")

	//长期医嘱新接口
	beego.Router("/api/patient/findepatientdialysislongsolutions", &PatientApiController{}, "Get:GetPatientDialysisLongSolution")
	beego.Router("/api/patient/getdialysissolutiondetaillist", &PatientApiController{}, "Get:GetDialysisSolutionDetailList")

	beego.Router("/api/patient/getexportlist", &PatientApiController{}, "Get:GetExportList")

}
func (c *PatientApiController) GetExportList() {
	startTime := c.GetString("start_time")
	endTime := c.GetString("end_time")
	schedulType, _ := c.GetInt64("schedul_type", 0)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")

	adminUserInfo := c.GetAdminUserInfo()
	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()
	}
	timeNowStr := time.Now().Format("2006-01-02")
	timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)
	schedule, _ := service.GetPatientScheudleListTwenty(adminUserInfo.CurrentOrgId, schedulType, theStartTIme, theEndtTIme, timeNewDate.Unix())
	fmt.Println("schedule23333333333333333", schedule)
	patientsList, _ := service.GetAllpatient(adminUserInfo.CurrentOrgId)

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

// GetPatientsList 取患者列表
func (c *PatientApiController) GetPatientsList() {
	var err error
	defer func() {
		if rec := recover(); rec != nil {
			err = fmt.Errorf("程序异常：%v", rec)
		}
		if err != nil {
			service.SaveErrs(c.GetAdminUserInfo().CurrentOrgId, c.Ctx.Input, err)
		}
	}()
	page, _ := c.GetInt64("page", 1)
	limit, _ := c.GetInt64("limit", 10)
	schedulType, _ := c.GetInt64("schedul_type", 0)
	bindingState, _ := c.GetInt64("binding_state", 0)
	lapseto, _ := c.GetInt64("lapseto", 0)
	source, _ := c.GetInt64("source", 0)
	startTime := c.GetString("start_time", "")
	endTime := c.GetString("end_time", "")
	keywords := c.GetString("keywords", "")
	contagion, _ := c.GetInt64("contagion", 0)
	reimbursement_way, _ := c.GetInt64("reimbursement_way", 0)
	isscheduling, _ := c.GetInt64("isscheduling", 0)
	isprescription, _ := c.GetInt64("isprescription", 0)
	patientSoureType, _ := c.GetInt64("patientSoureType")
	nurse, _ := c.GetInt64("nurse")
	if page <= 0 {
		page = 1
	}
	if limit <= 0 {
		limit = 10
	}

	adminUserInfo := c.GetAdminUserInfo()

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

	var isStartTime bool
	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
		}
		isStartTime = true
		theStartTIme = theTime.Unix()
	}
	var isEndTime bool
	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
		}
		isEndTime = true
		theEndtTIme = theTime.Unix()
	}

	var patients []*models.Patients
	var total int64
	patients, total, err = service.GetPatientList(adminUserInfo.CurrentOrgId, keywords, page, limit, schedulType, bindingState, lapseto, source, theStartTIme, theEndtTIme, contagion, reimbursement_way, isscheduling, isprescription, isStartTime, isEndTime, patientSoureType, nurse)

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

}

// GetPatientTotal
func (c *PatientApiController) GetPatientTotal() {
	adminUserInfo := c.GetAdminUserInfo()

	total := service.GetPatientCount(adminUserInfo.CurrentOrgId)

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

func (c *PatientApiController) GetPatientsAllList() {

	adminUserInfo := c.GetAdminUserInfo()

	patients, total, _ := service.GetAllPatientList(adminUserInfo.CurrentOrgId)

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

// GenerateDialysisNo 生成透析号
func (c *PatientApiController) GenerateDialysisNo() {
	adminUserInfo := c.GetAdminUserInfo()

	dialysisNo := service.ChechLastDialysisNo(adminUserInfo.CurrentOrgId)
	if dialysisNo == 0 {
		dialysisNo = 1
	} else {
		dialysisNo++
	}
	no := strconv.FormatInt(dialysisNo, 10)

	rep := 3 - len(no)

	if rep > 0 {
		no = strings.Repeat("0", rep) + no
	}

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

// CreatePatient 创建患者
func (c *PatientApiController) CreatePatient() {
	record_date := c.GetString("record_date")
	is_infectious, _ := c.GetInt64("is_infectious")
	remind_cycle, _ := c.GetInt64("remind_cycle")

	adminUserInfo := c.GetAdminUserInfo()
	//patientTotal := service.GetLapsetoPatientCount(adminUserInfo.CurrentOrgId, 1)

	//subscibes := adminUserInfo.Subscibes[adminUserInfo.CurrentOrgId]
	//if subscibes.State == 2 && patientTotal >= 20 { //免费试用版，不过期，限制患者数20
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientReachLimit)
	//	return
	//} else if subscibes.State == 1 && patientTotal >= 60 { //标准版，不过期，限制患者数60
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientReachLimit)
	//	return
	//}

	var patient models.Patients
	contagions, diseases, code, formItems := patientFormData(&patient, c.Ctx.Input.RequestBody, "create")
	fmt.Println(code)
	fmt.Println(patient)

	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	thisPatient, _ := service.FindPatientByDialysisNo(adminUserInfo.CurrentOrgId, patient.DialysisNo)
	if thisPatient.ID > 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisNoExist)
		return
	}

	thisPatient, _ = service.FindPatientByIdCardNo(adminUserInfo.CurrentOrgId, patient.IdCardNo)
	if thisPatient.ID > 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeIdCardNoExist)
		return
	}

	thisPatient, _ = service.FindPatientByMobile(adminUserInfo.CurrentOrgId, patient.Phone)
	if thisPatient.ID > 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientPhoneUsed)
		return
	}

	patient.RemindCycle = remind_cycle
	patient.IsInfectious = is_infectious
	patient.RegistrarsId = adminUserInfo.AdminUser.Id
	patient.Status = 1
	patient.CreatedTime = time.Now().Unix()
	patient.UserOrgId = adminUserInfo.CurrentOrgId
	patient.UpdatedTime = time.Now().Unix()
	patient.BindingState = 2
	// patient.Lapseto = 1

	err := service.CreatePatient(&patient, contagions, diseases)
	fmt.Println("创建病人失败err")
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreatePatient)
		return
	}

	//获取老表的最后一条数据
	patients, err := service.GetLastPatientData(adminUserInfo.CurrentOrgId)
	patientsNew := models.XtPatientsNew{
		UserOrgId:                    adminUserInfo.CurrentOrgId,
		UserId:                       0,
		Avatar:                       patients.Avatar,
		PatientType:                  patients.PatientType,
		DialysisNo:                   patients.DialysisNo,
		AdmissionNumber:              patients.AdmissionNumber,
		Source:                       patients.Source,
		Lapseto:                      patients.Lapseto,
		PartitionId:                  patients.PartitionId,
		BedId:                        patients.BedId,
		Name:                         patients.Name,
		Alias:                        patients.Alias,
		Gender:                       patients.Gender,
		MaritalStatus:                patients.MaritalStatus,
		IdCardNo:                     patients.IdCardNo,
		Birthday:                     patients.Birthday,
		ReimbursementWayId:           patients.ReimbursementWayId,
		HealthCareType:               patients.HealthCareType,
		HealthCareNo:                 patients.HealthCareNo,
		HealthCareDueDate:            patients.HealthCareDueDate,
		Height:                       patients.Height,
		BloodType:                    patients.BloodType,
		Rh:                           patients.Rh,
		HealthCareDueAlertDate:       patients.HealthCareDueAlertDate,
		EducationLevel:               patients.EducationLevel,
		Profession:                   patients.Profession,
		Phone:                        patients.Phone,
		HomeTelephone:                patients.HomeTelephone,
		RelativePhone:                patients.RelativePhone,
		RelativeRelations:            patients.RelativeRelations,
		HomeAddress:                  patients.HomeAddress,
		WorkUnit:                     patients.WorkUnit,
		UnitAddress:                  patients.UnitAddress,
		Children:                     patients.Children,
		ReceivingDate:                patients.ReceivingDate,
		IsHospitalFirstDialysis:      patients.IsHospitalFirstDialysis,
		FirstDialysisDate:            patients.FirstDialysisDate,
		FirstDialysisHospital:        patients.FirstDialysisHospital,
		PredialysisCondition:         patients.PredialysisCondition,
		PreHospitalDialysisFrequency: patients.PreHospitalDialysisFrequency,
		PreHospitalDialysisTimes:     patients.PreHospitalDialysisTimes,
		HospitalFirstDialysisDate:    patients.HospitalFirstDialysisDate,
		InductionPeriod:              patients.InductionPeriod,
		InitialDialysis:              patients.InitialDialysis,
		TotalDialysis:                patients.TotalDialysis,
		AttendingDoctorId:            patients.AttendingDoctorId,
		HeadNurseId:                  patients.HeadNurseId,
		Evaluate:                     patients.Evaluate,
		Diagnose:                     patients.Diagnose,
		Remark:                       patients.Remark,
		RegistrarsId:                 patients.RegistrarsId,
		Registrars:                   patients.Registrars,
		QrCode:                       patients.QrCode,
		BindingState:                 patients.BindingState,
		PatientComplains:             patients.PatientComplains,
		PresentHistory:               patients.PresentHistory,
		PastHistory:                  patients.PresentHistory,
		Temperature:                  patients.Temperature,
		Pulse:                        patients.Pulse,
		Respiratory:                  patients.Respiratory,
		Sbp:                          patients.SBP,
		Dbp:                          patients.DBP,
		Status:                       patients.Status,
		CreatedTime:                  patients.CreatedTime,
		UpdatedTime:                  patients.UpdatedTime,
		Nation:                       patients.Nation,
		NativePlace:                  patients.NativePlace,
		Age:                          patients.Age,
		InfectiousNextRecordTime:     patients.InfectiousNextRecordTime,
		IsInfectious:                 patients.IsInfectious,
		RemindCycle:                  patients.RemindCycle,
		ResponseResult:               patients.ResponseResult,
		IsOpenRemind:                 patients.IsOpenRemind,
		FirstTreatmentDate:           patients.FirstTreatmentDate,
		DialysisAge:                  patients.DialysisAge,
		ExpenseKind:                  patients.ExpenseKind,
		TellPhone:                    patients.TellPhone,
		ContactName:                  patients.ContactName,
		BloodPatients:                1,
		SlowPatients:                 0,
		MemberPatients:               0,
		EcommerPatients:              "",
		BloodId:                      patients.ID,
		SlowId:                       0,
		MemberId:                     0,
		MemberFistdate:               0,
		MemberPatienttype:            0,
		MemberTreatement:             0,
		EquitmentId:                  "",
		UserSysBeforeCount:           patient.UserSysBeforeCount,
		TrobleShoot:                  patient.TrobleShoot,
		TreatmentPlan:                patient.TreatmentPlan,
		Doctor:                       patient.Doctor,
		RecordNumber:                 patient.RecordNumber,
		PatientSource:                patient.PatientSource,
		PatientEndTime:               patient.PatientEndTime,
		PatientStartTime:             patient.PatientStartTime,
		InfectiousRemark:             patient.InfectiousRemark,
		AllergicHistory:              patient.AllergicHistory,
		PatientAddress:               patient.PatientAddress,
	}

	err = service.CreatePatientsNew(&patientsNew)
	fmt.Print("创建失败", err)

	allergic := models.XtPatientAllergic{
		UserOrgId:      adminUserInfo.CurrentOrgId,
		PatientId:      patient.ID,
		StartTime:      patient.PatientStartTime,
		EndTime:        patient.PatientEndTime,
		PatientSource:  patient.PatientSource,
		PatientAddress: patient.PatientAddress,
		Remake:         patient.Remark,
		Status:         1,
		Ctime:          time.Now().Unix(),
	}

	if len(patient.PatientAddress) > 0 {
		service.CreateAllergic(allergic)
	}

	if len(record_date) > 0 {
		var recordTime int64
		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		recordTime = theTime.Unix()
		inspections := make([]models.Inspection, 0)
		for _, item := range formItems {
			var inspection models.Inspection
			inspection.OrgId = adminUserInfo.CurrentOrgId
			inspection.PatientId = patient.ID
			inspection.ProjectId = item.ProjectId
			inspection.ItemId = item.ItemId
			inspection.ItemName = item.ItemName
			inspection.ProjectName = item.ProjectName
			inspection.InspectType = item.RangeType
			inspection.InspectValue = item.Value
			inspection.InspectDate = recordTime
			inspection.Status = 1
			inspection.CreatedTime = time.Now().Unix()
			inspection.UpdatedTime = time.Now().Unix()
			inspections = append(inspections, inspection)
		}
		err = service.CreatePatientInspection(inspections)

		infectiousRecord, _ := service.FindLastRecordDate(adminUserInfo.CurrentOrgId, patient.ID, 14)
		var record_time int64
		switch remind_cycle {
		case 1: //1个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 1, 0).Unix()

			break
		case 2: //2个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 2, 0).Unix()
			break
		case 3: //3个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 3, 0).Unix()
			break
		case 4: //6个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 6, 0).Unix()
			break
		case 5: //12个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 12, 0).Unix()
			break
		}

		errs := service.UpDateInfectiousRecordTime(adminUserInfo.CurrentOrgId, patient.ID, record_time, remind_cycle)
		if errs != nil {
			utils.ErrorLog("更新日期出错：%v", errs)
		}

	}

	redis := service.RedisClient()
	defer redis.Close()
	redis.SAdd("sgj_patient:new_user_set", patient.UserId)

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

// EditPatient 修改
func (c *PatientApiController) EditPatient() {
	id, _ := c.GetInt64("id", 0)

	record_date := c.GetString("record_date")
	is_infectious, _ := c.GetInt64("is_infectious")
	remind_cycle, _ := c.GetInt64("remind_cycle")

	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()

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

	contagions, diseases, code, formItems := patientFormData(&patient, c.Ctx.Input.RequestBody, "edit")
	if code > 0 {
		c.ServeFailJSONWithSGJErrorCode(code)
		return
	}

	thisPatientother, _ := service.FindPatientByDialysisNo(adminUserInfo.CurrentOrgId, patient.DialysisNo)
	if thisPatientother.ID > 0 && thisPatientother.ID != patient.ID {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisNoExist)
		return
	}

	thisPatient, _ := service.FindPatientByIdCardNo(adminUserInfo.CurrentOrgId, patient.IdCardNo)
	if thisPatient.ID > 0 && thisPatient.ID != patient.ID {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeIdCardNoExist)
		return
	}

	patient.UpdatedTime = time.Now().Unix()
	patient.IsInfectious = is_infectious
	patient.RemindCycle = remind_cycle
	err := service.UpdatePatient(&patient, contagions, diseases)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdatePatient)
		return
	}
	////更新转归状态
	//lapseto := models.PatientLapseto{
	//	LapsetoType: patient.Lapseto,
	//	LapsetoTime: time.Now().Unix(),
	//	UpdatedTime: time.Now().Unix(),
	//}
	//err = service.UpdatePatientLapseto(patient.ID, lapseto)
	//fmt.Println("更新转归失败", err)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdatePatient)
		return
	}
	patientsNew := models.XtPatientsNew{
		UserOrgId:                 patient.UserOrgId,
		UserId:                    patient.UserId,
		Avatar:                    patient.Avatar,
		PatientType:               patient.PatientType,
		DialysisNo:                patient.DialysisNo,
		AdmissionNumber:           patient.AdmissionNumber,
		Source:                    patient.Source,
		PartitionId:               patient.PartitionId,
		BedId:                     patient.BedId,
		Name:                      patient.Name,
		Alias:                     patient.Alias,
		Gender:                    patient.Gender,
		MaritalStatus:             patient.MaritalStatus,
		IdCardNo:                  patient.IdCardNo,
		Birthday:                  patient.Birthday,
		ReimbursementWayId:        patient.ReimbursementWayId,
		HealthCareType:            patient.HealthCareType,
		HealthCareNo:              patient.HealthCareNo,
		HealthCareDueDate:         patient.HealthCareDueDate,
		Height:                    patient.Height,
		BloodType:                 patient.BloodType,
		Rh:                        patient.Rh,
		HealthCareDueAlertDate:    patient.HealthCareDueAlertDate,
		EducationLevel:            patient.EducationLevel,
		Profession:                patient.Profession,
		Phone:                     patient.Phone,
		HomeTelephone:             patient.HomeTelephone,
		RelativePhone:             patient.RelativePhone,
		RelativeRelations:         patient.RelativeRelations,
		HomeAddress:               patient.HomeAddress,
		WorkUnit:                  patient.WorkUnit,
		UnitAddress:               patient.UnitAddress,
		Children:                  patient.Children,
		ReceivingDate:             patient.ReceivingDate,
		IsHospitalFirstDialysis:   patient.IsHospitalFirstDialysis,
		FirstDialysisDate:         patient.FirstDialysisDate,
		FirstDialysisHospital:     patient.FirstDialysisHospital,
		PredialysisCondition:      patient.PredialysisCondition,
		PreHospitalDialysisTimes:  patient.PreHospitalDialysisTimes,
		HospitalFirstDialysisDate: patient.HospitalFirstDialysisDate,
		InductionPeriod:           patient.InductionPeriod,
		InitialDialysis:           patient.InitialDialysis,
		TotalDialysis:             patient.TotalDialysis,
		AttendingDoctorId:         patient.AttendingDoctorId,
		HeadNurseId:               patient.HeadNurseId,
		Evaluate:                  patient.Evaluate,
		Diagnose:                  patient.Diagnose,
		Remark:                    patient.Remark,
		RegistrarsId:              patient.RegistrarsId,
		Registrars:                patient.Registrars,
		QrCode:                    patient.QrCode,
		BindingState:              patient.BindingState,
		PatientComplains:          patient.PatientComplains,
		PresentHistory:            patient.PresentHistory,
		PastHistory:               patient.PastHistory,
		Temperature:               patient.Temperature,
		Pulse:                     patient.Pulse,
		Respiratory:               patient.Respiratory,
		Sbp:                       patient.SBP,
		Dbp:                       patient.DBP,
		Nation:                    patient.Nation,
		NativePlace:               patient.NativePlace,
		Age:                       patient.Age,
		InfectiousNextRecordTime:  patient.InfectiousNextRecordTime,
		IsInfectious:              patient.IsInfectious,
		RemindCycle:               patient.RemindCycle,
		ResponseResult:            patient.ResponseResult,
		IsOpenRemind:              patient.IsOpenRemind,
		FirstTreatmentDate:        patient.FirstTreatmentDate,
		DialysisAge:               patient.DialysisAge,
		ExpenseKind:               patient.ExpenseKind,
		TellPhone:                 patient.TellPhone,
		ContactName:               patient.ContactName,
		UpdatedTime:               time.Now().Unix(),
		BloodPatients:             1,
		Lapseto:                   patient.Lapseto,
		TrobleShoot:               patient.TrobleShoot,
		SchRemark:                 patient.SchRemark,
		TreatmentPlan:             patient.TreatmentPlan,
		RecordNumber:              patient.RecordNumber,
		PatientSource:             patient.PatientSource,
		PatientStartTime:          patient.PatientStartTime,
		PatientEndTime:            patient.PatientEndTime,
		InfectiousRemark:          patient.InfectiousRemark,
		AllergicHistory:           patient.AllergicHistory,
		PatientAddress:            patient.PatientAddress,
	}
	//	//更新病人ID获取新表病人ID
	err = service.UpdatepatientTwo(&patientsNew, id)

	allergic := models.XtPatientAllergic{
		PatientId:      patient.ID,
		UserOrgId:      adminUserInfo.CurrentOrgId,
		StartTime:      patient.PatientStartTime,
		EndTime:        patient.PatientEndTime,
		PatientSource:  patient.PatientSource,
		Status:         1,
		Ctime:          time.Now().Unix(),
		Mtime:          time.Now().Unix(),
		Remake:         patient.Remark,
		PatientAddress: patient.PatientAddress,
	}
	if len(patient.PatientAddress) > 0 {
		service.CreateAllergic(allergic)
	}

	nowTimeUinx := time.Now()
	today := nowTimeUinx.Format("2006-01-02")

	redis := service.RedisClient()
	defer redis.Close()
	key := "scheduals_" + today + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
	redis.Set(key, "", time.Second*60*60*18)

	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(id, 10) + ":patient_info"
	redis.Set(keyOne, "", time.Second*60*60*18)
	if len(record_date) > 0 {
		var recordTime int64
		timeLayout := "2006-01-02"
		loc, _ := time.LoadLocation("Local")
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", record_date+" 00:00:00", loc)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		recordTime = theTime.Unix()
		inspections := make([]models.Inspection, 0)
		for _, item := range formItems {
			var inspection models.Inspection
			inspection.OrgId = adminUserInfo.CurrentOrgId
			inspection.PatientId = patient.ID
			inspection.ProjectId = item.ProjectId
			inspection.ItemId = item.ItemId
			inspection.ItemName = item.ItemName
			inspection.ProjectName = item.ProjectName
			inspection.InspectType = item.RangeType
			inspection.InspectValue = item.Value
			inspection.InspectDate = recordTime
			inspection.Status = 1
			inspection.CreatedTime = time.Now().Unix()
			inspection.UpdatedTime = time.Now().Unix()
			inspections = append(inspections, inspection)
		}
		err = service.CreatePatientInspection(inspections)

		infectiousRecord, _ := service.FindLastRecordDate(adminUserInfo.CurrentOrgId, patient.ID, 14)
		var record_time int64
		switch remind_cycle {
		case 1: //1个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 1, 0).Unix()

			break
		case 2: //2个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 2, 0).Unix()
			break
		case 3: //3个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 3, 0).Unix()
			break
		case 4: //6个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 6, 0).Unix()
			break
		case 5: //12个月
			ts := time.Unix(infectiousRecord.InspectDate, 0)
			record_time = ts.AddDate(0, 12, 0).Unix()
			break
		}

		errs := service.UpDateInfectiousRecordTime(adminUserInfo.CurrentOrgId, patient.ID, record_time, remind_cycle)
		if errs != nil {
			utils.ErrorLog("更新日期出错：%v", errs)
		}
	}

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

}

func (c *PatientApiController) EditLapseto() {
	id, _ := c.GetInt64("id", 0)

	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	start_time := c.GetString("start_time")

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

	var startTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

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

	patient_address := c.GetString("patient_address")

	adminUserInfo := c.GetAdminUserInfo()

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

	patientBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &patientBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
	var lapseto models.PatientLapseto
	lapseto.PatientId = patient.ID

	if patientBody["lapseto_type"] == nil || reflect.TypeOf(patientBody["lapseto_type"]).String() != "float64" {
		utils.ErrorLog("lapseto_type")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	lapsetoType := int64(patientBody["lapseto_type"].(float64))

	lapseto.LapsetoType = lapsetoType

	if patientBody["lapseto_time"] == nil || reflect.TypeOf(patientBody["lapseto_time"]).String() != "string" {
		utils.ErrorLog("lapseto_time")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNotSelectLapsetoType)
		return
	}
	lapsetoTime, _ := patientBody["lapseto_time"].(string)

	//if len(lapsetoTime) == 0 {
	//	utils.ErrorLog("len(lapsetoTime) == 0")
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNotSelectLapsetoTime)
	//	return
	//}

	out_reason, _ := patientBody["out_reason"].(string)

	//if len(out_reason) == 0 {
	//	utils.ErrorLog("len(out_reason) == 0")
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNotSelectLapsetoTime)
	//	return
	//}

	lapsetoTimeUnix, err := time.ParseInLocation(timeLayout, lapsetoTime, loc)

	//if err != nil {
	//	utils.ErrorLog("lapsetoTimeUnix")
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeNotSelectLapsetoTime)
	//	return
	//}
	lapseto.LapsetoTime = lapsetoTimeUnix.Unix()
	lapseto.UpdatedTime = time.Now().Unix()
	lapseto.CreatedTime = time.Now().Unix()
	lapseto.Status = 1
	patient.Lapseto = lapseto.LapsetoType
	patient.OutReason = out_reason
	patient.DeathTime = lapsetoTimeUnix.Unix()

	patient.PatientStartTime = startTime
	patient.PatientEndTime = endTime
	patient.PatientAddress = patient_address

	//if patient.Lapseto == 1 {
	//	patientTotal := service.GetLapsetoPatientCount(adminUserInfo.CurrentOrgId, 1)
	//	subscibes := adminUserInfo.Subscibes[adminUserInfo.CurrentOrgId]
	//	if subscibes.State == 2 && patientTotal >= 100 { //免费试用版，不过期，限制患者数20
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientReachLimit)
	//		return
	//	} else if subscibes.State == 1 && patientTotal >= 200 { //标准版，不过期，限制患者数60
	//		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientReachLimit)
	//		return
	//	}
	//}

	err = service.EditPatientLapseto(&patient, &lapseto)

	if lapseto.LapsetoType == 3 || lapseto.LapsetoType == 2 {
		timeStr := time.Now().Format("2006-01-02")
		timeLayout := "2006-01-02 15:04:05"
		timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
		timenow := timeStringToTime.Unix()
		service.UpdateScheduleByDeathTime(id, timenow)
		service.UpdateScheduleItemByPatientId(id)
	}

	allergic := models.XtPatientAllergic{
		UserOrgId:      adminUserInfo.CurrentOrgId,
		PatientId:      patient.ID,
		StartTime:      patient.PatientStartTime,
		EndTime:        patient.PatientEndTime,
		PatientSource:  patient.Lapseto,
		PatientAddress: patient.PatientAddress,
		Remake:         patient.Remark,
		Status:         1,
		Ctime:          time.Now().Unix(),
	}
	if lapseto.LapsetoType == 2 || lapseto.LapsetoType == 3 {
		allergic.StartTime = lapseto.LapsetoTime
		allergic.EndTime = lapseto.LapsetoTime
	}

	service.CreateAllergic(allergic)

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

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

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

	adminUserInfo := c.GetAdminUserInfo()

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

	infectiousRecord, _ := service.FindLastRecordDate(adminUserInfo.CurrentOrgId, patient.ID, 14)

	infections, _ := service.GetAllInfectionRecord(infectiousRecord.InspectDate, adminUserInfo.CurrentOrgId, patient.ID, infectiousRecord.ProjectId)
	diseases := service.GetPatientDiseases(patient.ID)
	contagions := service.GetPatientContagions(patient.ID)
	c.ServeSuccessJSON(map[string]interface{}{
		"patient":    patient,
		"diseases":   diseases,
		"contagions": contagions,
		"infections": infections,
	})
	return
}

func (c *PatientApiController) CreateDialysisSolution() {

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

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

	var solution models.DialysisSolution

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

	//thisSolution, _ := service.FindPatientDialysisSolutionByMode(adminUserInfo.CurrentOrgId, id, solution.ModeId)
	//if thisSolution.ID > 0 {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionExist)
	//	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.CurrentOrgId
	solution.UpdatedTime = time.Now().Unix()
	solution.SubName = ""
	solution.ParentId = 0
	solution.SolutionStatus = 1

	//records, _ := service.GetAllSchedules()

	schs, _ := service.GetAllSchedulesByPatientInfo(adminUserInfo.CurrentOrgId, id, solution.ModeId)
	for _, sch := range schs {
		var DialysisMachineName string
		if len(solution.DialysisDialyszers) > 0 {
			DialysisMachineName = solution.DialysisDialyszers
		}
		if len(solution.DialyzerPerfusionApparatus) > 0 {
			DialysisMachineName = DialysisMachineName + "," + solution.DialyzerPerfusionApparatus
		}

		if len(solution.DialysisIrrigation) > 0 {
			DialysisMachineName = DialysisMachineName + "," + solution.DialysisIrrigation
		}
		sch.DialysisMachineName = DialysisMachineName
		service.UpdateSch(sch)
	}

	err := service.CreatePatientDialysisSolution(&solution)

	//获取最新1条
	dialysisSolution, _ := service.GetLastPatientDialysisSolution(id, adminUserInfo.CurrentOrgId)

	//更新状态
	service.UpdateDialysisSolutionStatusTwo(dialysisSolution.ID, dialysisSolution.ModeId, dialysisSolution.UserOrgId, dialysisSolution.PatientId)

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

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

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

	adminUserInfo := c.GetAdminUserInfo()

	solution, _ := service.FindPatientDialysisSolution(adminUserInfo.CurrentOrgId, id)
	if solution.ID == 0 || solution.PatientId != patient {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionNotExist)
		return
	}

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

	solution.UpdatedTime = time.Now().Unix()

	err := service.UpdatePatientDialysisSolution(&solution)

	nowTimeUinx := time.Now()
	today := nowTimeUinx.Format("2006-01-02")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	todayTime, err := time.ParseInLocation(timeLayout, today, loc)

	if adminUserInfo.CurrentOrgId == 9538 {
		prescription := models.DialysisPrescription{
			Dialyzer:                   solution.Dialyzer,
			Anticoagulant:              solution.Anticoagulant,
			AnticoagulantShouji:        solution.AnticoagulantShouji,
			AnticoagulantWeichi:        solution.AnticoagulantWeichi,
			AnticoagulantZongliang:     solution.AnticoagulantZongliang,
			ModeId:                     solution.ModeId,
			DialysisDurationHour:       solution.DialysisDurationHour,
			Kalium:                     solution.Kalium,
			Sodium:                     solution.Sodium,
			Calcium:                    solution.Calcium,
			TargetUltrafiltration:      solution.TargetUltrafiltration,
			DialyzerPerfusionApparatus: solution.DialyzerPerfusionApparatus,
			BloodAccess:                solution.BloodAccess,
			DialysateFlow:              solution.DialysateFlow,
			DialysateTemperature:       solution.DialysateTemperature,
			DialysisIrrigation:         solution.DialysisIrrigation,
			DialysisDialyszers:         solution.DialysisDialyszers,
			PlasmaSeparator:            solution.PlasmaSeparator,
			BilirubinAdsorptionColumn:  solution.BilirubinAdsorptionColumn,
			OxygenUptake:               solution.OxygenUptake,
			OxygenFlow:                 solution.OxygenFlow,
			OxygenTime:                 solution.OxygenTime,
			MaxUltrafiltrationRate:     solution.MaxUltrafiltrationRate,
			Amylaceum:                  solution.Amylaceum,
			DialysisStrainer:           solution.DialysisStrainer,
			Chaptalization:             solution.Chaptalization,
			BloodAccessPartId:          solution.BloodAccessPartId,
		}
		service.UpdatePatientDialysisSolutionOne(solution.PatientId, adminUserInfo.CurrentOrgId, &prescription, todayTime.Unix())
	}

	schs, _ := service.GetAllSchedulesByPatientInfo(adminUserInfo.CurrentOrgId, solution.PatientId, solution.ModeId)
	for _, sch := range schs {
		var DialysisMachineName string
		if len(solution.DialysisDialyszers) > 0 {
			DialysisMachineName = solution.DialysisDialyszers
		}
		if len(solution.DialyzerPerfusionApparatus) > 0 {
			DialysisMachineName = DialysisMachineName + "," + solution.DialyzerPerfusionApparatus
		}

		if len(solution.DialysisIrrigation) > 0 {
			DialysisMachineName = DialysisMachineName + "," + solution.DialysisIrrigation
		}
		sch.DialysisMachineName = DialysisMachineName
		service.UpdateSch(sch)
	}

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

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

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

	adminUserInfo := c.GetAdminUserInfo()

	solution, _ := service.FindPatientDialysisSolution(adminUserInfo.CurrentOrgId, id)
	if solution.ID == 0 || solution.PatientId != patient {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionNotExist)
		return
	}

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

	solution.UpdatedTime = time.Now().Unix()
	solution.AffirmState = 1

	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) 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
	}

	adminUserInfo := c.GetAdminUserInfo()

	solutions, total, _ := service.GetPatientDialysisSolutionList(adminUserInfo.CurrentOrgId, id, page, limit)
	stockType, _ := service.GetStockType(adminUserInfo.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"solutions": solutions,
		"total":     total,
		"stockType": stockType,
	})
	return
}
func (c *PatientApiController) DeleteDialysisSolution() {

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

	adminUserInfo := c.GetAdminUserInfo()

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

	if solution.UseState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisSolutionUsed)
		return
	}

	solution.UpdatedTime = time.Now().Unix()
	solution.Status = 0

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

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

// GetDryWeights 取患者干体重调整铺
func (c *PatientApiController) GetDryWeights() {
	page, _ := c.GetInt64("page", 1)
	limit, _ := c.GetInt64("limit", 10)
	id, _ := c.GetInt64("id", 0)
	if id <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()

	weights, total, _ := service.GetPatientDryWeightAdjustList(adminUserInfo.CurrentOrgId, id, page, limit)

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

}

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

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

	var theWeight models.DryWeightAdjust

	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
	}

	if dataBody["weight"] == nil || reflect.TypeOf(dataBody["weight"]).String() != "string" {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	weight, _ := strconv.ParseFloat(dataBody["weight"].(string), 64)
	theWeight.Weight = weight

	// if dataBody["doctor"] == nil || reflect.TypeOf(dataBody["doctor"]).String() != "float64" {
	// 	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	// 	return
	// }
	// doctor := int64(dataBody["doctor"].(float64))
	// theWeight.Doctor = doctor

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

	theWeight.CreatedTime = time.Now().Unix()
	theWeight.UpdatedTime = time.Now().Unix()
	theWeight.Status = 1
	theWeight.RegistrarsId = adminUserInfo.AdminUser.Id
	theWeight.UserOrgId = adminUserInfo.CurrentOrgId
	theWeight.PatientId = patient
	theWeight.Doctor = adminUserInfo.AdminUser.Id

	old, _ := service.FindPatientLastDryWeightAdjust(adminUserInfo.CurrentOrgId, patient)
	if old.ID > 0 {
		theWeight.AdjustedValue = theWeight.Weight - old.Weight
	}

	err = service.CreateDryWeightAdjust(&theWeight)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDryWeightFail)
		return
	}

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

func (c *PatientApiController) CreateGroupAdvice() {
	var err error
	defer func() {
		if rec := recover(); rec != nil {
			err = fmt.Errorf("程序异常：%v", rec)
		}
		if err != nil {
			service.SaveErrs(c.GetAdminUserInfo().CurrentOrgId, c.Ctx.Input, err)
		}
	}()
	patient, _ := c.GetInt64("id", 0)
	groupNo, _ := c.GetInt64("groupno", 0)

	if patient <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()
	var patientInfo models.Patients
	patientInfo, err = service.FindPatientById(adminUserInfo.CurrentOrgId, patient)
	if patientInfo.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	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
	}
	utils.ErrorLog("%v", dataBody)

	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
	if appRole.UserType == 3 {
		headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
		if getPermissionErr != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		} else if headNursePermission == nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateAdvice)
			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 && adviceType != 3 && adviceType != 4 {
		utils.ErrorLog("advice_type != 1&&2")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
		utils.ErrorLog("advice_date")
		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", 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
	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.CurrentOrgId
		advice.PatientId = patientInfo.ID
		advice.AdviceDoctor = adminUserInfo.AdminUser.Id
		advice.IsSettle = 2

		//创建步骤表
		finish := models.XtDialysisFinish{
			IsFinish:   1,
			UserOrgId:  adminUserInfo.CurrentOrgId,
			Status:     1,
			Ctime:      time.Now().Unix(),
			Mtime:      0,
			Module:     4,
			RecordDate: advice.RecordDate,
			Sourse:     1,
			PatientId:  patient,
		}

		dialysisFinish, _ := service.GetDialysisFinish(adminUserInfo.CurrentOrgId, advice.RecordDate, 4, patient)
		if dialysisFinish.ID == 0 {
			service.CreateDialysisFinish(finish)
		}

		// 查询信息规挡的设置天数

		infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
		if infor.ID > 0 && infor.WeekDay > 0 {

			var cha_time int64

			timeNowStr := time.Now().Format("2006-01-02")
			timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

			//今日的日期减去设置的日期
			cha_time = timeNewDate.Unix() - infor.WeekDay*86400

			if cha_time >= advice.AdviceDate {
				//查询审核是否允许
				infor, _ := service.GetDialysisInformationByRecordDate(patient, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
				//申请状态不允许的情况 拒绝修改
				if infor.ApplicationStatus != 1 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
					return
				}

			}
		}

		if adviceNameM["advice_name"] == nil || reflect.TypeOf(adviceNameM["advice_name"]).String() != "string" {
			utils.ErrorLog("advice_name")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		adviceName, _ := adviceNameM["advice_name"].(string)

		if len(adviceName) == 0 {
			utils.ErrorLog("len(advice_name) == 0")
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		advice.AdviceName = adviceName

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

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

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

			template_id, _ := adviceNameM["template_id"].(string)
			advice.TemplateId = template_id
		}

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

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

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

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

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

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

		if adviceNameM["way"] != nil && reflect.TypeOf(adviceNameM["way"]).String() == "string" {
			way, _ := strconv.ParseFloat(adviceNameM["way"].(string), 64)
			advice.Way = int64(way)
		}
		if adviceNameM["way"] != nil || reflect.TypeOf(adviceNameM["way"]).String() == "float64" {
			way := int64(adviceNameM["way"].(float64))
			advice.Way = way
		}

		if adviceNameM["drug_id"] != nil && reflect.TypeOf(adviceNameM["drug_id"]).String() == "string" {
			drug_id, _ := strconv.ParseFloat(adviceNameM["drug_id"].(string), 64)
			advice.DrugId = int64(drug_id)
		}
		if adviceNameM["drug_id"] != nil || reflect.TypeOf(adviceNameM["drug_id"]).String() == "float64" {
			drug_id := int64(adviceNameM["drug_id"].(float64))
			advice.DrugId = drug_id
		}

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

		remark, _ := adviceNameM["remark"].(string)

		advice.Remark = remark

		if adminUserInfo.CurrentOrgId == 3877 || adminUserInfo.CurrentOrgId == 10340 || adminUserInfo.CurrentOrgId == 9671 {
			if advice.PrescribingNumber == 0 {
				advice.PrescribingNumber = 1
			}
			//查询该患者今日有没有双人核对
			check, _ := service.MobileGetDoubleCheckSix(adminUserInfo.CurrentOrgId, patientInfo.ID, advice.AdviceDate)
			fmt.Println("chek", check)
			if check.ID > 0 {
				advice.Checker = check.Modifier
				advice.CheckState = 1
				advice.CheckTime = time.Now().Unix()
			}
		}
		if adviceType == 1 {

			if adviceNameM["frequency_type"] != nil || reflect.TypeOf(adviceNameM["frequency_type"]).String() == "float64" {
				frequency_type := int64(adviceNameM["frequency_type"].(float64))
				advice.FrequencyType = frequency_type
			}

			if adviceNameM["day_count"] != nil || reflect.TypeOf(adviceNameM["day_count"]).String() == "string" {
				day_count, _ := strconv.ParseInt(adviceNameM["day_count"].(string), 10, 64)
				advice.DayCount = day_count
			}

			if adviceNameM["week_days"] != nil && reflect.TypeOf(adviceNameM["week_days"]).String() == "string" {
				week_day, _ := adviceNameM["week_days"].(string)
				advice.WeekDay = week_day
			}

			if adviceNameM["push_start_time"] != nil && reflect.TypeOf(adviceNameM["push_start_time"]).String() == "string" {
				push_start_time, _ := adviceNameM["push_start_time"].(string)
				var startTime int64
				if len(push_start_time) > 0 {
					theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", push_start_time+" 00:00:00", loc)

					startTime = theTime.Unix()
				}
				advice.PushStartTime = startTime
			}

		}

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

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

					if childMap["advice_name"] == nil || reflect.TypeOf(childMap["advice_name"]).String() != "string" {
						utils.ErrorLog("child advice_name")
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					childAdviceName, _ := childMap["advice_name"].(string)
					if len(childAdviceName) == 0 {
						utils.ErrorLog("len(child advice_name) == 0")
						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
						return
					}
					child.AdviceName = childAdviceName

					if childMap["advice_desc"] != nil && reflect.TypeOf(childMap["advice_desc"]).String() == "string" {
						childAdviceDesc, _ := childMap["advice_desc"].(string)
						child.AdviceDesc = childAdviceDesc
					}

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

					if childMap["drug_spec_unit"] != nil && reflect.TypeOf(childMap["drug_spec_unit"]).String() == "string" {
						childDrugSpecUnit, _ := childMap["drug_spec_unit"].(string)
						child.DrugSpecUnit = childDrugSpecUnit
					}

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

					if childMap["single_dose_unit"] != nil && reflect.TypeOf(childMap["single_dose_unit"]).String() == "string" {
						childSingleDoseUnit, _ := childMap["single_dose_unit"].(string)
						child.SingleDoseUnit = childSingleDoseUnit
					}

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

					if childMap["prescribing_number_unit"] != nil && reflect.TypeOf(childMap["prescribing_number_unit"]).String() == "string" {
						childPrescribingNumberUnit, _ := childMap["prescribing_number_unit"].(string)
						child.PrescribingNumberUnit = childPrescribingNumberUnit
					}

					if childMap["drug_id"] != nil && reflect.TypeOf(childMap["drug_id"]).String() == "float64" {
						drug_id := int64(childMap["drug_id"].(float64))
						child.DrugId = drug_id
					}

					if childMap["way"] != nil && reflect.TypeOf(childMap["way"]).String() == "float64" {
						way := int64(childMap["way"].(float64))
						child.Way = way
					}

					if childMap["drug_name_id"] != nil && reflect.TypeOf(childMap["drug_name_id"]).String() == "float64" {
						drug_name_id := int64(childMap["drug_name_id"].(float64))
						child.DrugNameId = drug_name_id
					}

					child.DeliveryWay = advice.DeliveryWay
					child.ExecutionFrequency = advice.ExecutionFrequency

					if adminUserInfo.CurrentOrgId == 3877 || adminUserInfo.CurrentOrgId == 10340 || adminUserInfo.CurrentOrgId == 9671 {
						if child.PrescribingNumber == 0 {
							child.PrescribingNumber = 1
						}
						//查询该患者今日有没有双人核对
						check, _ := service.MobileGetDoubleCheckSix(adminUserInfo.CurrentOrgId, patientInfo.ID, child.AdviceDate)

						if check.ID > 0 {
							child.Checker = check.Modifier
							child.CheckState = 1
							child.CheckTime = time.Now().Unix()
						}
					}
					advice.Children = append(advice.Children, &child)
				}
			}
		}

		advices = append(advices, &advice)
	}

	list, err := service.CreateMGroupAdvice(adminUserInfo.CurrentOrgId, advices, groupNo)

	for _, item := range advices {
		//记录日志
		byterequest, _ := json.Marshal(item)
		adviceLog := models.XtDoctorAdviceLog{
			UserOrgId:   item.UserOrgId,
			PatientId:   item.PatientId,
			AdminUserId: adminUserInfo.AdminUser.Id,
			Module:      1,
			ErrLog:      string(byterequest),
			Status:      1,
			Ctime:       time.Now().Unix(),
			Mtime:       0,
			Source:      "电导端批量插入医嘱",
			RecordDate:  item.AdviceDate,
		}
		service.CreateDoctorAdviceLog(adviceLog)
	}

	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":doctor_advices"

	redis := service.RedisClient()
	defer redis.Close()
	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(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",
		"advices": list,
	})

	return
}

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

	adminUserInfo := c.GetAdminUserInfo()

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

	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)

	if appRole.UserType == 3 {
		headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, adminUserInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
		if getPermissionErr != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		} else if headNursePermission == nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateAdvice)
			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.CurrentOrgId, 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.CurrentOrgId
	advice.PatientId = patient
	advice.AdviceDoctor = adminUserInfo.AdminUser.Id

	// 查询信息规挡的设置天数

	infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
	if infor.ID > 0 && infor.WeekDay > 0 {

		var cha_time int64

		timeNowStr := time.Now().Format("2006-01-02")
		timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

		//今日的日期减去设置的日期
		cha_time = timeNewDate.Unix() - infor.WeekDay*86400

		if cha_time >= advice.AdviceDate {
			//查询审核是否允许
			infor, _ := service.GetDialysisInformationByRecordDate(patient, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
			//申请状态不允许的情况 拒绝修改
			if infor.ApplicationStatus != 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
				return
			}

		}
	}

	if advice.UserOrgId == 3877 || advice.UserOrgId == 10340 || advice.UserOrgId == 9671 {
		if advice.PrescribingNumber == 0 {
			advice.PrescribingNumber = 1
		}
		//查询该患者今日有没有双人核对
		check, _ := service.MobileGetDoubleCheckSix(advice.UserOrgId, patientInfo.ID, advice.AdviceDate)

		if check.ID > 0 {
			advice.Checker = check.Modifier
			advice.CheckState = 1
			advice.CheckTime = time.Now().Unix()
		}
	}
	err := service.CreateDoctorAdvice(&advice)

	//记录日志
	byterequest, _ := json.Marshal(advice)
	adviceLog := models.XtDoctorAdviceLog{
		UserOrgId:   advice.UserOrgId,
		PatientId:   advice.PatientId,
		AdminUserId: adminUserInfo.AdminUser.Id,
		Module:      1,
		ErrLog:      string(byterequest),
		Status:      1,
		Ctime:       time.Now().Unix(),
		Mtime:       0,
		Source:      "电脑新增医嘱",
		RecordDate:  advice.RecordDate,
	}

	service.CreateDoctorAdviceLog(adviceLog)

	//创建步骤表
	finish := models.XtDialysisFinish{
		IsFinish:   1,
		UserOrgId:  adminUserInfo.CurrentOrgId,
		Status:     1,
		Ctime:      time.Now().Unix(),
		Mtime:      0,
		Module:     4,
		RecordDate: advice.AdviceDate,
		Sourse:     1,
		PatientId:  patient,
	}

	dialysisFinish, _ := service.GetDialysisFinish(adminUserInfo.CurrentOrgId, advice.AdviceDate, 4, patient)
	if dialysisFinish.ID == 0 {
		service.CreateDialysisFinish(finish)
	}
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 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) ExecGroupAdvice() {
	groupNo, _ := c.GetInt64("groupno", 0)
	executionTime := c.GetString("execution_time")

	if groupNo <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

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

	adminUserInfo := c.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdviceByGroupNo(adminUserInfo.CurrentOrgId, groupNo)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

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

	executionStaff := adminUserInfo.AdminUser.Id
	// checker := adminUserInfo.AdminUser.Id

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

	theTime, err := time.ParseInLocation(timeLayout, executionTime, loc)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

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

	exceAdvice := models.DoctorAdvice{
		ExecutionStaff: executionStaff,
		ExecutionTime:  theTime.Unix(),
		UpdatedTime:    time.Now().Unix(),
	}
	err = service.ExceDoctorAdviceByGroupNo(&exceAdvice, groupNo, adminUserInfo.CurrentOrgId)

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

	//查询自动扣减是否开启
	_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(adminUserInfo.CurrentOrgId)
	//查询已经执行的医嘱
	advicelist, _ := service.GetExceDoctorAdviceGroupNo(groupNo, adminUserInfo.CurrentOrgId)

	if drugStockConfig.IsOpen == 1 {
		for _, item := range advicelist {
			medical, _ := service.GetBaseDrugMedical(advice.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 {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "1",
					"advice": advice,
				})
				return
			}

			var total int64
			var prescribing_number_total int64

			//查询默认出库仓库
			houseConfig, _ := service.GetAllStoreHouseConfig(advice.UserOrgId)

			//查询该药品在默认仓库是否有库存
			list, _ := service.GetDrugTotalCountTwenty(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
			}

			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

			}

			if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "3",
					"advice": advice,
				})
				return
			}
			if prescribing_number_total > total {
				c.ServeSuccessJSON(map[string]interface{}{
					"msg":    "2",
					"advice": advice,
				})
				return
			}
			if prescribing_number_total <= total {
				pharmacyConfig, _ := service.FindPharmacyConfig(advice.UserOrgId)
				if medical.IsUse == 2 {
					if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
						drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
						if drugOutInfo.ID == 0 {
							service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
						}

					}
					if pharmacyConfig.IsOpen != 1 {
						drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
						if drugOutInfo.ID == 0 {
							service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
						}
					}

					//查询默认仓库
					storeHouseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
					//查询默认仓库剩余多少库存
					var sum_count int64
					stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
					for _, its := range stockInfo {
						if its.MaxUnit == medical.MaxUnit {
							its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
						}
						sum_count += its.StockMaxNumber + its.StockMinNumber
					}

					service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
					break
					c.ServeSuccessJSON(map[string]interface{}{
						"msg":    "1",
						"advice": advice,
					})
					return

				}

				if medical.IsUse == 1 {
					c.ServeSuccessJSON(map[string]interface{}{
						"msg":    "1",
						"advice": advice,
					})
					return
				}

			}

		}
	}

	advice.ExecutionStaff = executionStaff
	advice.ExecutionTime = theTime.Unix()

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

func (c *PatientApiController) ExecDoctorAdvice() {

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

	patient, _ := c.GetInt64("patient", 0)
	id, _ := c.GetInt64("id", 0)
	executionTime := c.GetString("execution_time")

	if origin != 2 {
		if id <= 0 || patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

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

		}

		adminUserInfo := c.GetAdminUserInfo()

		advice, _ := service.FindDoctorAdvice(adminUserInfo.CurrentOrgId, id)

		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
			return
		}

		//医嘱已执行
		if advice.ExecutionState == 1 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
			return
		}

		executionStaff := adminUserInfo.AdminUser.Id

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

		theTime, err := time.ParseInLocation(timeLayout, executionTime, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		if advice.StartTime > theTime.Unix() {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		exceAdvice := models.DoctorAdvice{
			ExecutionStaff: executionStaff,
			ExecutionTime:  theTime.Unix(),
			UpdatedTime:    time.Now().Unix(),
		}

		// 查询信息规挡的设置天数

		infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
		if infor.ID > 0 && infor.WeekDay > 0 {

			var cha_time int64

			timeNowStr := time.Now().Format("2006-01-02")
			timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

			//今日的日期减去设置的日期
			cha_time = timeNewDate.Unix() - infor.WeekDay*86400

			if cha_time >= advice.AdviceDate {
				//查询审核是否允许
				infor, _ := service.GetDialysisInformationByRecordDate(patient, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
				//申请状态不允许的情况 拒绝修改
				if infor.ApplicationStatus != 1 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
					return
				}

			}
		}
		if advice.ParentId > 0 {
			err = service.ExceDoctorAdviceById(&exceAdvice, advice.ParentId, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			doctorAdviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      2,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "电脑端执行医嘱",
				RecordDate:  exceAdvice.RecordDate,
			}
			service.CreateDoctorAdviceLog(doctorAdviceLog)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)

			theTimes := theTime.Format("2006-01-02")

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

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

			defer redis.Close()
		} else {
			err = service.ExceDoctorAdviceById(&exceAdvice, id, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			doctorAdviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      2,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "电脑端执行医嘱",
				RecordDate:  exceAdvice.RecordDate,
			}
			service.CreateDoctorAdviceLog(doctorAdviceLog)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)

			theTimes := theTime.Format("2006-01-02")

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

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.ExecutionStaff = executionStaff
		advice.ExecutionTime = theTime.Unix()

		//处理出库相关逻辑

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

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

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

		storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
		if drugStockConfig.IsOpen == 1 {
			var total int64
			var prescribing_number_total int64
			advices, _ := service.GetExecutionDoctors(adminUserInfo.CurrentOrgId, patient, id)
			for _, item := range advices {
				houseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.CurrentOrgId)
				//查询该药品是否有库存
				list, _ := service.GetDrugTotalCountTwenty(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(advice.PrescribingNumber), 'f', 0, 64)
					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
					total = list.Count*medical.MinNumber + list.StockMinNumber
					prescribing_number_total = count
				}

				if medical.IsUse != 1 {

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

				if medical.IsUse == 1 {
					c.ServeSuccessJSON(map[string]interface{}{
						"msg":    "1",
						"advice": advice,
					})
					return
				}

				if prescribing_number_total <= total {

					//查询是否门诊处方和临时医嘱同步到透析医嘱的开关是否开启

					adviceSetting, _ := service.FindAdviceSettingById(item.UserOrgId)

					if adviceSetting.IsAdviceOpen == 1 {
						//查询是否出库按钮开启
						prescriptionConfig, _ := service.FindPrescriptionConfigById(item.UserOrgId)
						pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)
						if prescriptionConfig.IsOpen == 1 {

							if medical.IsUse == 2 {
								//是通过药房发药
								if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
									//执行出库

									drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
									if drugOutInfo.ID == 0 {
										service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
									}
								}
								//不通过药房发药
								if pharmacyConfig.IsOpen != 1 {
									//执行出库

									drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
									if drugOutInfo.ID == 0 {
										service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
									}
								}

								//查询默认仓库
								storeHouseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
								//查询默认仓库剩余多少库存
								var sum_count int64
								//更新字典里面的库存
								stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
								for _, its := range stockInfo {
									if its.MaxUnit == medical.MaxUnit {
										its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
									}
									sum_count += its.StockMaxNumber + its.StockMinNumber
								}

								service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)

								//剩余库存
								service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
								break
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "1",
									"advice": advice,
								})
								return
							}
							if medical.IsUse == 1 {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "1",
									"advice": advice,
								})
								return
							}
						} else {
							if medical.IsUse == 1 {
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "1",
									"advice": advice,
								})
								return
							}
						}

					} else {
						pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)
						if medical.IsUse == 2 {
							//是通过药房发药
							if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {

								drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
								if drugOutInfo.ID == 0 {
									service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
								}
							}
							//不通过药房发药
							if pharmacyConfig.IsOpen != 1 {

								drugOutInfo, _ := service.GetAdviceIsOut(item.ID, item.UserOrgId, item.PatientId, item.AdviceDate, item.DrugId)
								if drugOutInfo.ID == 0 {
									service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
								}
							}
							//更新字典里面的库存
							var sum_count int64
							stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
							for _, its := range stockInfo {
								if its.MaxUnit == medical.MaxUnit {
									its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
								}
								sum_count += its.StockMaxNumber + its.StockMinNumber
							}
							service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
							//剩余库存
							service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
							break
							c.ServeSuccessJSON(map[string]interface{}{
								"msg":    "1",
								"advice": advice,
							})
							return
						}
						if medical.IsUse == 1 {
							c.ServeSuccessJSON(map[string]interface{}{
								"msg":    "1",
								"advice": advice,
							})
							return
						}
					}
				}
			}
		}

		advices, _ := service.GetExecutionDoctors(adminUserInfo.CurrentOrgId, patient, id)
		for _, item := range advices {

			if item.Way == 2 {
				if privateDrugConfig != nil && privateDrugConfig.DrugStart == 1 {
					if item.ExecutionState == 1 {
						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.CurrentOrgId)

						total = total + 1
						warehousing_out_order := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.DrugId,
							DrugSpec:       item.AdviceDesc,
							OutstoreNumber: count,
							AdminUserId:    adminUserInfo.AdminUser.Id,
							StorckTime:     item.RecordDate,
							UserOrgId:      adminUserInfo.CurrentOrgId,
							CreatedTime:    time.Now().Unix(),
							Status:         1,
							PatientId:      item.PatientId,
							ExitMode:       2,
							MedicId:        item.DrugId,
							StockOutNumber: warehousing_out_order,
						}
						service.CreateOutStock(&outStock)
					}
				}
			}

		}

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

	} else {

		if id <= 0 || patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

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

		}

		adminUserInfo := c.GetAdminUserInfo()

		advice, _ := service.FindHisDoctorAdvice(adminUserInfo.CurrentOrgId, id)

		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
			return
		}

		//医嘱已执行
		if advice.ExecutionState == 1 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExced)
			return
		}

		executionStaff := adminUserInfo.AdminUser.Id

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

		theTime, err := time.ParseInLocation(timeLayout, executionTime, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		if advice.StartTime > theTime.Unix() {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		exceAdvice := models.HisDoctorAdviceInfo{
			ExecutionStaff: executionStaff,
			ExecutionTime:  theTime.Unix(),
			UpdatedTime:    time.Now().Unix(),
		}
		if advice.ParentId > 0 {
			err = service.ExceHidDoctorAdviceById(&exceAdvice, advice.ParentId, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			doctorAdviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      2,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "电脑端执行His医嘱",
				RecordDate:  exceAdvice.RecordDate,
			}
			service.CreateDoctorAdviceLog(doctorAdviceLog)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)

			theTimes := theTime.Format("2006-01-02")

			keyFour := "scheduals_" + theTimes + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)

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

			defer redis.Close()
		} else {
			err = service.ExceHidDoctorAdviceById(&exceAdvice, id, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			doctorAdviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      2,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "电脑端执行His医嘱",
				RecordDate:  exceAdvice.RecordDate,
			}
			service.CreateDoctorAdviceLog(doctorAdviceLog)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)

			theTimes := theTime.Format("2006-01-02")

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

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.ExecutionStaff = executionStaff
		advice.ExecutionTime = theTime.Unix()

		//处理出库相关逻辑

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

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

		if drugStockConfig.IsOpen == 1 {
			//查询已经执行的医嘱
			advices, _ := service.GetHisExecutionDoctorsTwo(adminUserInfo.CurrentOrgId, patient, id)
			for _, item := range advices {
				medical, _ := service.GetBaseDrugMedical(advice.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
				//	}
				//}
				//fmt.Println("total_count23232323232323232wode",total_count)
				//fmt.Println("total_count23232323232323232wode",drug_count)
				//if total_count == drug_count {
				//	c.ServeSuccessJSON(map[string]interface{}{
				//		"msg":    "1",
				//		"advice": advice,
				//	})
				//	return
				//}

				var total int64
				var prescribing_number_total int64
				config, _ := service.GetDrugOpenConfigOne(adminUserInfo.CurrentOrgId)
				if config.IsOpen != 1 {
					//查询默认出库仓库
					houseConfig, _ := service.GetAllStoreHouseConfig(advice.UserOrgId)

					//查询该药品在默认仓库是否有库存
					list, _ := service.GetDrugTotalCountTwenty(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
					}

					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

					}

					if medical.IsUse == 1 {
						drugError := models.XtDrugError{
							UserOrgId:             item.UserOrgId,
							DrugId:                item.DrugId,
							RecordDate:            item.AdviceDate,
							PatientId:             item.PatientId,
							Remark:                "电脑端零用药品",
							Status:                1,
							Ctime:                 time.Now().Unix(),
							Mtime:                 0,
							SumCount:              list.Count*medical.MinNumber + list.StockMinNumber,
							Prescribingnumber:     item.PrescribingNumber,
							PrescribingNumberUnit: item.PrescribingNumberUnit,
						}
						service.CreateDrugError(drugError)
						c.ServeSuccessJSON(map[string]interface{}{
							"msg":    "1",
							"advice": advice,
						})
						return
					}
					if medical.IsUse != 1 {
						if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
							drugError := models.XtDrugError{
								UserOrgId:             item.UserOrgId,
								DrugId:                item.DrugId,
								RecordDate:            item.AdviceDate,
								PatientId:             item.PatientId,
								Remark:                "电脑端药品库存不足",
								Status:                1,
								Ctime:                 time.Now().Unix(),
								Mtime:                 0,
								SumCount:              list.Count*medical.MinNumber + list.StockMinNumber,
								Prescribingnumber:     item.PrescribingNumber,
								PrescribingNumberUnit: item.PrescribingNumberUnit,
							}
							service.CreateDrugError(drugError)
							c.ServeSuccessJSON(map[string]interface{}{
								"msg":    "3",
								"advice": advice,
							})
							return
						}

						if prescribing_number_total > total {
							drugError := models.XtDrugError{
								UserOrgId:             item.UserOrgId,
								DrugId:                item.DrugId,
								RecordDate:            item.AdviceDate,
								PatientId:             item.PatientId,
								Remark:                "电脑端出库数量大于总库存",
								Status:                1,
								Ctime:                 time.Now().Unix(),
								Mtime:                 0,
								SumCount:              list.Count*medical.MinNumber + list.StockMinNumber,
								Prescribingnumber:     item.PrescribingNumber,
								PrescribingNumberUnit: item.PrescribingNumberUnit,
							}
							service.CreateDrugError(drugError)
							c.ServeSuccessJSON(map[string]interface{}{
								"msg":    "2",
								"advice": advice,
							})
							return
						}
					}

					if prescribing_number_total <= total {
						pharmacyConfig, _ := service.FindPharmacyConfig(item.UserOrgId)

						if medical.IsUse == 2 {
							if config.IsOpen != 1 {
								if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
									service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)

									if item.UserOrgId == 3877 || item.UserOrgId == 10265 {
										//查询该药品是否有出库记录
										flowMap, _ := service.GetDrugFLowByAdviceById(item.DrugId, item.PatientId, item.UserOrgId, item.AdviceDate)
										if len(flowMap) == 0 {
											errs := service.UpdateHisAdviceById(item.ID)
											if errs != nil {
												drugError := models.XtDrugError{
													UserOrgId:             item.UserOrgId,
													DrugId:                item.DrugId,
													RecordDate:            item.AdviceDate,
													PatientId:             item.PatientId,
													Remark:                "出库记录为空,更新执行人失败",
													Status:                1,
													Ctime:                 time.Now().Unix(),
													Mtime:                 0,
													SumCount:              list.Count*medical.MinNumber + list.StockMinNumber,
													Prescribingnumber:     item.PrescribingNumber,
													PrescribingNumberUnit: item.PrescribingNumberUnit,
												}
												service.CreateDrugError(drugError)
											}
											c.ServeSuccessJSON(map[string]interface{}{
												"msg":    "6",
												"advice": advice,
											})
											return
										}
									}
								}
								//不通过药房发药
								if pharmacyConfig.IsOpen != 1 {
									service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
									if item.UserOrgId == 3877 || item.UserOrgId == 10265 {
										//查询该药品是否有出库记录
										flowMap, _ := service.GetDrugFLowByAdviceById(item.DrugId, item.PatientId, item.UserOrgId, item.AdviceDate)
										if len(flowMap) == 0 {
											errs := service.UpdateHisAdviceById(item.ID)
											if errs != nil {
												drugError := models.XtDrugError{
													UserOrgId:             item.UserOrgId,
													DrugId:                item.DrugId,
													RecordDate:            item.AdviceDate,
													PatientId:             item.PatientId,
													Remark:                "出库记录为空,更新执行人失败",
													Status:                1,
													Ctime:                 time.Now().Unix(),
													Mtime:                 0,
													SumCount:              list.Count*medical.MinNumber + list.StockMinNumber,
													Prescribingnumber:     item.PrescribingNumber,
													PrescribingNumberUnit: item.PrescribingNumberUnit,
												}
												service.CreateDrugError(drugError)
											}
											c.ServeSuccessJSON(map[string]interface{}{
												"msg":    "6",
												"advice": advice,
											})
											return
										}
									}
								}
								//查询默认仓库
								storeHouseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
								//查询默认仓库剩余多少库存
								var sum_count int64
								stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
								for _, its := range stockInfo {
									if its.MaxUnit == medical.MaxUnit {
										its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
									}
									sum_count += its.StockMaxNumber + its.StockMinNumber
								}
								service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)

								//出库数量累加
								//service.AddDrugCount(item.DrugId,item.UserOrgId,storeHouseConfig.DrugStorehouseOut,prescribing_number_total)
								//剩余库存
								service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
								break
								c.ServeSuccessJSON(map[string]interface{}{
									"msg":    "1",
									"advice": advice,
								})
								return
							}
						}

						if medical.IsUse == 1 {
							c.ServeSuccessJSON(map[string]interface{}{
								"msg":    "1",
								"advice": advice,
							})
							return
						}

					}
				}
			}

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

	}

}

func (c *PatientApiController) CheckGroupAdvice() {
	groupno, _ := c.GetInt64("groupno", 0)

	if groupno <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdviceByGroupNo(adminUserInfo.CurrentOrgId, groupno)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

	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()

	exceAdvice := models.DoctorAdvice{
		Checker:     checker,
		CheckTime:   theTime.Unix(),
		UpdatedTime: time.Now().Unix(),
	}
	var err error
	err = service.CheckDoctorAdviceByGroupNo(&exceAdvice, groupno, adminUserInfo.CurrentOrgId)

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

	advice.Checker = checker
	advice.CheckTime = theTime.Unix()

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

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

	if origin != 2 {
		// executionTime := c.GetString("execution_time")

		if id <= 0 || patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetAdminUserInfo()

		advice, _ := service.FindDoctorAdvice(adminUserInfo.CurrentOrgId, id)
		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
			return
		}

		if advice.CheckState == 1 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceChecked)
			return
		}

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

		// executionStaff := adminUserInfo.AdminUser.Id
		checker := adminUserInfo.AdminUser.Id

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

		// theTime, err := time.ParseInLocation(timeLayout, executionTime, loc)
		// if err != nil {
		// 	utils.ErrorLog(err.Error())
		// 	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		// 	return
		// }

		theTime := time.Now()

		if advice.ExecutionTime > theTime.Unix() {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
			return
		}
		exceAdvice := models.DoctorAdvice{
			Checker:     checker,
			CheckTime:   theTime.Unix(),
			UpdatedTime: time.Now().Unix(),
		}
		var err error
		// 查询信息规挡的设置天数

		infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
		if infor.ID > 0 && infor.WeekDay > 0 {

			var cha_time int64

			timeNowStr := time.Now().Format("2006-01-02")
			timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

			//今日的日期减去设置的日期
			cha_time = timeNewDate.Unix() - infor.WeekDay*86400

			if cha_time >= advice.AdviceDate {
				//查询审核是否允许
				infor, _ := service.GetDialysisInformationByRecordDate(patient, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
				//申请状态不允许的情况 拒绝修改
				if infor.ApplicationStatus != 1 {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
					return
				}

			}
		}
		if advice.ParentId > 0 {
			err = service.CheckDoctorAdviceById(&exceAdvice, advice.ParentId, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			adviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      3,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "核对医嘱",
				RecordDate:  exceAdvice.AdviceDate,
			}

			service.CreateDoctorAdviceLog(adviceLog)

			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)
		} else {
			err = service.CheckDoctorAdviceById(&exceAdvice, id, patient)
			//记录日志
			byterequest, _ := json.Marshal(exceAdvice)
			adviceLog := models.XtDoctorAdviceLog{
				UserOrgId:   exceAdvice.UserOrgId,
				PatientId:   exceAdvice.PatientId,
				AdminUserId: adminUserInfo.AdminUser.Id,
				Module:      3,
				ErrLog:      string(byterequest),
				Status:      1,
				Ctime:       time.Now().Unix(),
				Mtime:       0,
				Source:      "核对医嘱",
				RecordDate:  exceAdvice.AdviceDate,
			}

			service.CreateDoctorAdviceLog(adviceLog)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10)

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

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

		// advice.ExecutionStaff = executionStaff
		// advice.ExecutionTime = theTime.Unix()
		advice.Checker = checker
		advice.CheckTime = theTime.Unix()

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

	} else {

		if id <= 0 || patient <= 0 {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}

		adminUserInfo := c.GetAdminUserInfo()

		advice, _ := service.FindHisDoctorAdvice(adminUserInfo.CurrentOrgId, id)
		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
			return
		}

		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()

		if advice.ExecutionTime > theTime.Unix() {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceExceBeforeStart)
			return
		}
		exceAdvice := models.HisDoctorAdviceInfo{
			Checker:     checker,
			CheckTime:   theTime.Unix(),
			UpdatedTime: time.Now().Unix(),
		}
		var err error
		if advice.ParentId > 0 {
			err = service.CheckHisDoctorAdviceById(&exceAdvice, advice.ParentId, patient)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10)

			redis.Set(keyFour, "", time.Second)
			keyFive := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
			redis.Set(keyFive, "", time.Second)
		} else {
			err = service.CheckHisDoctorAdviceById(&exceAdvice, id, patient)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, 10)

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

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

		// advice.ExecutionStaff = executionStaff
		// advice.ExecutionTime = theTime.Unix()
		advice.Checker = checker
		advice.CheckTime = theTime.Unix()

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

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

	adminUserInfo := c.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdvice(adminUserInfo.CurrentOrgId, id)
	if advice.ID == 0 || advice.PatientId != patient {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

	//if advice.AdviceType == 1 {
	//	c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeLongTimeAdviceNotCanntEdit)
	//	return
	//}
	if advice.StopState == 1 || advice.ExecutionState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
		return
	}

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)

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

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

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

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

	// 查询信息规挡的设置天数

	infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
	if infor.ID > 0 && infor.WeekDay > 0 {

		var cha_time int64

		timeNowStr := time.Now().Format("2006-01-02")
		timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

		//今日的日期减去设置的日期
		cha_time = timeNewDate.Unix() - infor.WeekDay*86400

		if cha_time >= advice.AdviceDate {
			//查询审核是否允许
			infor, _ := service.GetDialysisInformationByRecordDate(patient, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
			//申请状态不允许的情况 拒绝修改
			if infor.ApplicationStatus != 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
				return
			}

		}
	}

	err := service.UpdateDoctorAdvice(&advice)

	//记录日志
	byterequest, _ := json.Marshal(advice)
	doctorAdviceLog := models.XtDoctorAdviceLog{
		UserOrgId:   advice.UserOrgId,
		PatientId:   advice.PatientId,
		AdminUserId: adminUserInfo.AdminUser.Id,
		Module:      1,
		ErrLog:      string(byterequest),
		Status:      1,
		Ctime:       time.Now().Unix(),
		Mtime:       0,
		Source:      "电脑端修改医嘱",
		RecordDate:  advice.AdviceDate,
	}
	service.CreateDoctorAdviceLog(doctorAdviceLog)
	redis := service.RedisClient()

	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"

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

	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
	redis.Set(keyOne, "", time.Second)
	defer redis.Close()
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdateDoctorAdviceFail)
		return
	}

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

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

	adminUserInfo := c.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdviceByGoroupNo(adminUserInfo.CurrentOrgId, groupNo)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}
	if advice.StopState == 1 || advice.ExecutionState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
		return
	}

	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
	}

	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
	}
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	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" {
		stopReason, _ := dataBody["stop_reason"].(string)
		advice.StopReason = stopReason
	}

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

	err = service.StopGroupAdvice(adminUserInfo.CurrentOrgId, groupNo, &advice)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeStopAdviceFail)
		return
	}

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

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

	adminUserInfo := c.GetAdminUserInfo()

	//appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, 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.CurrentOrgId, id)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}
	if advice.StopState == 1 || advice.ExecutionState == 1 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdviceStoped)
		return
	}

	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
	}

	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
	}
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	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" {
		stopReason, _ := dataBody["stop_reason"].(string)
		advice.StopReason = stopReason
	}

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

	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.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdvice(adminUserInfo.CurrentOrgId, 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.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
	//
	//if appRole.UserType == 3 {
	//	headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, 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

	// 查询信息规挡的设置天数

	infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
	if infor.ID > 0 && infor.WeekDay > 0 {

		var cha_time int64

		timeNowStr := time.Now().Format("2006-01-02")
		timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

		//今日的日期减去设置的日期
		cha_time = timeNewDate.Unix() - infor.WeekDay*86400

		if cha_time >= advice.AdviceDate {
			//查询审核是否允许
			infor, _ := service.GetDialysisInformationByRecordDate(advice.PatientId, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
			//申请状态不允许的情况 拒绝修改
			if infor.ApplicationStatus != 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
				return
			}

		}
	}
	err := service.DeleteDoctorAdvice(&advice)

	//记录日志
	byterequest, _ := json.Marshal(advice)
	doctorAdviceLog := models.XtDoctorAdviceLog{
		UserOrgId:   advice.UserOrgId,
		PatientId:   advice.PatientId,
		AdminUserId: adminUserInfo.AdminUser.Id,
		Module:      4,
		ErrLog:      string(byterequest),
		Status:      1,
		Ctime:       time.Now().Unix(),
		Mtime:       0,
		Source:      "电脑端删除医嘱",
		RecordDate:  advice.RecordDate,
	}
	service.CreateDoctorAdviceLog(doctorAdviceLog)
	redis := service.RedisClient()
	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"

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

	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
	redis.Set(key, "", time.Second)
	redis.Close()
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteAdviceFail)
		return
	}

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

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

	adminUserInfo := c.GetAdminUserInfo()

	advice, _ := service.FindDoctorAdviceByGroupNo(adminUserInfo.CurrentOrgId, groupNo)
	if advice.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceNotExist)
		return
	}

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

	// 查询信息规挡的设置天数

	infor, _ := service.GetDialysisInformationSetting(adminUserInfo.CurrentOrgId)
	if infor.ID > 0 && infor.WeekDay > 0 {

		var cha_time int64

		timeNowStr := time.Now().Format("2006-01-02")
		timeNewDate, _ := utils.ParseTimeStringToTime("2006-01-02", timeNowStr)

		//今日的日期减去设置的日期
		cha_time = timeNewDate.Unix() - infor.WeekDay*86400

		if cha_time >= advice.AdviceDate {
			//查询审核是否允许
			infor, _ := service.GetDialysisInformationByRecordDate(advice.PatientId, advice.AdviceDate, adminUserInfo.CurrentOrgId, 4)
			//申请状态不允许的情况 拒绝修改
			if infor.ApplicationStatus != 1 {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeInformationExist)
				return
			}

		}
	}

	err := service.DeleteGroupAdvice(adminUserInfo.CurrentOrgId, groupNo, adminUserInfo.AdminUser.Id)

	byterequest, _ := json.Marshal(advice)
	doctorAdviceLog := models.XtDoctorAdviceLog{
		UserOrgId:   advice.UserOrgId,
		PatientId:   advice.PatientId,
		AdminUserId: adminUserInfo.AdminUser.Id,
		Module:      4,
		ErrLog:      string(byterequest),
		Status:      1,
		Ctime:       time.Now().Unix(),
		Mtime:       0,
		Source:      "电脑端批量删除医嘱",
		RecordDate:  advice.RecordDate,
	}
	service.CreateDoctorAdviceLog(doctorAdviceLog)

	key := strconv.FormatInt(advice.UserOrgId, 10) + ":" + strconv.FormatInt(advice.PatientId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":doctor_advices"
	redis := service.RedisClient()

	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"
	redis.Set(keyOne, "", time.Second)

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

	c.ServeSuccessJSON(map[string]interface{}{
		"msg": "ok",
	})
	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", "")
	page, _ := c.GetInt64("page")
	fmt.Println("page", page)
	limit, _ := c.GetInt64("limit")
	fmt.Println("limit", limit)
	adminUserInfo := c.GetAdminUserInfo()

	operatorIDs := make([]int64, 0)

	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 {
			utils.ErrorLog(err.Error())
			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()
	}

	hisconfig, _ := service.GetHisDoctorConfig(adminUserInfo.CurrentOrgId)

	if hisconfig.IsOpen == 1 {
		advices, total, _ := service.GetDoctorAdviceListThree(adminUserInfo.CurrentOrgId, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords, page, limit)
		advicestwo, _, _ := service.GetDoctorAdviceListFour(adminUserInfo.CurrentOrgId, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords, limit, page)

		if len(advices) > 0 {
			for _, item := range advices {
				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)
				}
				if item.StopDoctor > 0 {
					operatorIDs = append(operatorIDs, item.StopDoctor)
				}
			}
		}

		//相关操作对应的操作人
		operators, _ := service.GetAdminUserES(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, operatorIDs)

		//获取长期医嘱
		longAdvice, _, _ := service.GetLongDoctorAdviceList(adminUserInfo.CurrentOrgId, id, 1, stopType, theStartTIme, theEndtTIme, keywords, page, limit)
		c.ServeSuccessJSON(map[string]interface{}{
			"advices":    advices,
			"operators":  operators,
			"total":      total,
			"advicetwo":  advicestwo,
			"longAdvice": longAdvice,
			"is_open":    hisconfig.IsOpen,
		})
		return
	} else {
		advices, total, _ := service.GetDoctorAdviceListOne(adminUserInfo.CurrentOrgId, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords, page, limit)
		advicestwo, _, _ := service.GetDoctorAdviceListTwo(adminUserInfo.CurrentOrgId, id, adviceType, stopType, theStartTIme, theEndtTIme, keywords, limit, page)

		if len(advices) > 0 {
			for _, item := range advices {
				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)
				}
				if item.StopDoctor > 0 {
					operatorIDs = append(operatorIDs, item.StopDoctor)
				}
			}
		}

		//相关操作对应的操作人
		operators, _ := service.GetAdminUserES(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, operatorIDs)

		c.ServeSuccessJSON(map[string]interface{}{
			"advices":   advices,
			"operators": operators,
			"total":     total,
			"advicetwo": advicestwo,
			"is_open":   hisconfig.IsOpen,
		})
		return
	}

}

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

	adminUserInfo := c.GetAdminUserInfo()
	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.GetPatientScheduleFormToday(adminUserInfo.CurrentOrgId, id, 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) GetPatientDialysisRecords() {
	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()
	}

	adminInfo := c.GetAdminUserInfo()
	records, total, _ := service.GetPatientDialysisRecord(adminInfo.CurrentOrgId, patientID, page, limit, theStartTIme, theEndtTIme, mode_id)

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

func (c *PatientApiController) ProEducation() {
	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()
	}

	adminInfo := c.GetAdminUserInfo()
	edus, total, _ := service.GetPatientTreatmentSummaryList(adminInfo.CurrentOrgId, patientID, page, limit, theStartTIme, theEndtTIme)

	c.ServeSuccessJSON(map[string]interface{}{
		"total": total,
		"edus":  edus,
	})
	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 && adviceType != 3 && adviceType != 4 {
			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
			}
		}
	}

	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", startTime, loc)
		if err != nil {
			utils.ErrorLog(err.Error())
			code = enums.ErrorCodeParamWrong
			return
		}
		advice.StartTime = theTime.Unix()

		// if dataBody["advice_doctor"] == nil || reflect.TypeOf(dataBody["advice_doctor"]).String() != "float64" {
		// 	utils.ErrorLog("advice_doctor")
		// 	code = enums.ErrorCodeParamWrong
		// 	return
		// }
		// adviceDoctor := int64(dataBody["advice_doctor"].(float64))
		// if adviceDoctor <= 0 {
		// 	utils.ErrorLog("advice_doctor <=0")
		// 	code = enums.ErrorCodeParamWrong
		// 	return
		// }
		// advice.AdviceDoctor = adviceDoctor

		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 advice.AdviceType == 1 && advice.ParentId == 0 {

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

			if dataBody["day_count"] != nil || reflect.TypeOf(dataBody["day_count"]).String() == "string" {
				day_count, _ := strconv.ParseInt(dataBody["day_count"].(string), 10, 64)
				advice.DayCount = day_count
			}

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

	}

	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["dialysis_order_id"] != nil && reflect.TypeOf(dataBody["dialysis_order_id"]).String() == "float64" {
		dialysisOrderId, _ := dataBody["dialysis_order_id"].(float64)
		advice.DialysisOrderId = int64(dialysisOrderId)
	}

	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"] != nil && reflect.TypeOf(dataBody["single_dose"]).String() == "float64" {
		singleDose := dataBody["single_dose"].(float64)
		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["single_dose_unit"] != nil && reflect.TypeOf(dataBody["single_dose_unit"]).String() == "float64" {
		tmp := dataBody["single_dose_unit"].(float64)
		singleDoseUnit := service.TypeConversion(tmp)
		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"] != nil && reflect.TypeOf(dataBody["prescribing_number"]).String() == "float64" {
		prescribingNumber := dataBody["prescribing_number"].(float64)
		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
	}

	if dataBody["drug_id"] != nil && reflect.TypeOf(dataBody["drug_id"]).String() == "string" {
		drug_id, _ := dataBody["drug_id"].(string)
		tmpDrugId, _ := strconv.ParseInt(drug_id, 10, 64)
		advice.DrugId = tmpDrugId
	}
	if dataBody["drug_id"] != nil && reflect.TypeOf(dataBody["drug_id"]).String() == "float64" {
		drug_id, _ := dataBody["drug_id"].(float64)
		advice.DrugId = int64(drug_id)
	}

	if dataBody["drug_name_id"] != nil && reflect.TypeOf(dataBody["drug_name_id"]).String() == "float64" {
		drug_name_id, _ := dataBody["drug_name_id"].(float64)
		advice.DrugNameId = int64(drug_name_id)
	}

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

	if dataBody["push_start_time"] != nil && reflect.TypeOf(dataBody["push_start_time"]).String() == "string" {
		push_start_time, _ := dataBody["push_start_time"].(string)
		var startTime int64
		if len(push_start_time) > 0 {
			theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", push_start_time+" 00:00:00", loc)

			startTime = theTime.Unix()
		}
		advice.PushStartTime = startTime
	}

	return
}

func solutionFormData(solution *models.DialysisSolution, 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["dialysis_duration"] != nil && reflect.TypeOf(dataBody["dialysis_duration"]).String() == "string" {
		dialysisDuration, _ := strconv.ParseFloat(dataBody["dialysis_duration"].(string), 64)
		solution.DialysisDuration = dialysisDuration
	}

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

	if dataBody["blood_flow_volume"] != nil && reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "string" {
		bloodFlowVolume, _ := strconv.ParseFloat(dataBody["blood_flow_volume"].(string), 64)
		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["blood_filter"] != nil && reflect.TypeOf(dataBody["blood_filter"]).String() == "float64" {
		bloodFilter := int64(dataBody["blood_filter"].(float64))
		solution.BloodFilter = bloodFilter
	}

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

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

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

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

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

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

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

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

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

	if dataBody["anticoagulant_zongliang"] != nil && reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "string" {
		anticoagulantZongliang, _ := strconv.ParseFloat(dataBody["anticoagulant_zongliang"].(string), 64)
		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
	}

	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["target_ultrafiltration"] != nil && reflect.TypeOf(dataBody["target_ultrafiltration"]).String() == "string" {
		targetUltrafiltration, _ := strconv.ParseFloat(dataBody["target_ultrafiltration"].(string), 64)
		solution.TargetUltrafiltration = targetUltrafiltration
	}

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

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

	if dataBody["dialysis_duration_minute"] != nil && reflect.TypeOf(dataBody["dialysis_duration_minute"]).String() == "string" {
		dialysisDurationMinute, _ := strconv.ParseFloat(dataBody["dialysis_duration_minute"].(string), 64)
		solution.DialysisDurationMinute = int64(dialysisDurationMinute)
	}

	if dataBody["hemodialysis_machine"] != nil && reflect.TypeOf(dataBody["hemodialysis_machine"]).String() == "float64" {
		hemodialysisMachine := int64(dataBody["hemodialysis_machine"].(float64))
		solution.HemodialysisMachine = hemodialysisMachine
	}
	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 && reflect.TypeOf(dataBody["blood_flow_volume"]).String() == "string" {
		bloodFlowVolume, _ := strconv.ParseFloat(dataBody["blood_flow_volume"].(string), 64)
		solution.BloodFlowVolume = bloodFlowVolume
	}

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

	if dataBody["displace_liqui"] != nil && reflect.TypeOf(dataBody["displace_liqui"]).String() == "string" {
		displaceLiqui, _ := strconv.ParseFloat(dataBody["displace_liqui"].(string), 64)
		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 && reflect.TypeOf(dataBody["anticoagulant_shouji"]).String() == "string" {
		anticoagulantShouji, _ := strconv.ParseFloat(dataBody["anticoagulant_shouji"].(string), 64)
		solution.AnticoagulantShouji = anticoagulantShouji
	}

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

	if dataBody["anticoagulant_zongliang"] != nil && reflect.TypeOf(dataBody["anticoagulant_zongliang"]).String() == "string" {
		anticoagulantZongliang, _ := strconv.ParseFloat(dataBody["anticoagulant_zongliang"].(string), 64)
		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 && reflect.TypeOf(dataBody["kalium"]).String() == "string" {
		kalium, _ := strconv.ParseFloat(dataBody["kalium"].(string), 64)
		solution.Kalium = kalium
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if dataBody["displace_liqui_part"] != nil && reflect.TypeOf(dataBody["displace_liqui_part"]).String() == "float64" {
		displace_liqui_part := int64(dataBody["displace_liqui_part"].(float64))
		solution.DisplaceLiquiPart = displace_liqui_part
	}
	if dataBody["displace_liqui_value"] != nil && reflect.TypeOf(dataBody["displace_liqui_value"]).String() == "string" {
		displace_liqui_value, _ := strconv.ParseFloat(dataBody["displace_liqui_value"].(string), 64)
		solution.DisplaceLiquiValue = displace_liqui_value
	}
	if dataBody["blood_access"] != nil && reflect.TypeOf(dataBody["blood_access"]).String() == "float64" {
		blood_access := int64(dataBody["blood_access"].(float64))
		solution.BloodAccess = blood_access
	}

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

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

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

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

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

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

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

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

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

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

		solution.CreatedTime = created_time
	}

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

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

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

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

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

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

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

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

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

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

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

func childSolutionFormData(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["parent_id"] == nil || reflect.TypeOf(dataBody["parent_id"]).String() != "float64" {
			utils.ErrorLog("parent_id")
			code = enums.ErrorCodeParamWrong
			return
		}
		parentID := int64(dataBody["parent_id"].(float64))
		if parentID <= 0 {
			utils.ErrorLog("parentID <= 0")
			code = enums.ErrorCodeParamWrong
			return
		}
		solution.ParentId = parentID

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

	if dataBody["initiate_mode"] == nil || reflect.TypeOf(dataBody["initiate_mode"]).String() != "float64" {
		utils.ErrorLog("initiate_mode")
		code = enums.ErrorCodeParamWrong
		return
	}
	initiateMode := int64(dataBody["initiate_mode"].(float64))
	if initiateMode != 1 && initiateMode != 2 {
		utils.ErrorLog("initiateMode != 1 && initiateMode != 2")
		code = enums.ErrorCodeParamWrong
		return
	}
	solution.InitiateMode = initiateMode

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

	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)
		solution.BloodAccessPartId = blood_access_part_id
	}
	return
}

func patientFormData(patient *models.Patients, data []byte, method string) (contagions []int64, diseases []int64, code int, formItems []*models.FormItem) {
	patientBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(data, &patientBody)

	if err != nil {
		utils.ErrorLog(err.Error())
		code = enums.ErrorCodeParamWrong
		return
	}

	if patientBody["formItem"] != nil && reflect.TypeOf(patientBody["formItem"]).String() == "[]interface {}" {
		formItem, _ := patientBody["formItem"].([]interface{})

		if len(formItem) > 0 {
			for _, item := range formItem {
				items := item.(map[string]interface{})
				project_name, _ := items["project_name"].(string)
				fmt.Println(project_name)

				range_type := int64(items["range_type"].(float64))
				fmt.Println(range_type)

				project_id := int64(items["project_id"].(float64))
				fmt.Println(project_id)

				item_id := int64(items["item_id"].(float64))
				fmt.Println(item_id)

				item, _ := items["item"].(string)

				fmt.Println(items["item"].(string))

				item_name, _ := items["item_name"].(string)
				fmt.Println(item_name)

				value, _ := items["value"].(string)
				fmt.Println(items["value"].(string))

				var form models.FormItem
				form.ProjectName = project_name
				form.RangeType = range_type
				form.ProjectId = project_id
				form.ItemId = item_id
				form.Item = item
				form.ItemName = item_name
				form.Value = value
				formItems = append(formItems, &form)
			}
		}
	}
	if patientBody["avatar"] == nil || reflect.TypeOf(patientBody["avatar"]).String() != "string" {
		utils.ErrorLog("avatar")
		code = enums.ErrorCodeParamWrong
		return
	}
	avatar, _ := patientBody["avatar"].(string)

	if len(avatar) == 0 {
		utils.ErrorLog("len(avatar) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Avatar = avatar

	if patientBody["name"] == nil || reflect.TypeOf(patientBody["name"]).String() != "string" {
		utils.ErrorLog("name")
		code = enums.ErrorCodeParamWrong
		return
	}
	name, _ := patientBody["name"].(string)
	if len(name) == 0 {
		utils.ErrorLog("len(name) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Name = name

	if patientBody["alias"] != nil && reflect.TypeOf(patientBody["alias"]).String() == "string" {
		alias := patientBody["alias"].(string)
		patient.Alias = alias
	}

	if patientBody["nation"] != nil && reflect.TypeOf(patientBody["nation"]).String() == "string" {
		nation := patientBody["nation"].(string)
		patient.Nation = nation
	}
	if patientBody["native_place"] != nil && reflect.TypeOf(patientBody["native_place"]).String() == "string" {
		native_place := patientBody["native_place"].(string)
		patient.NativePlace = native_place
	}

	if patientBody["idCardNo"] == nil || reflect.TypeOf(patientBody["idCardNo"]).String() != "string" {
		utils.ErrorLog("idCardNo")
		code = enums.ErrorCodeParamWrong
		return
	}
	idCardNo, _ := patientBody["idCardNo"].(string)
	if len(idCardNo) == 0 {
		utils.ErrorLog("len(idCardNo) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.IdCardNo = idCardNo

	patient.PatientType = 1

	if patientBody["dialysisNo"] == nil || reflect.TypeOf(patientBody["dialysisNo"]).String() != "string" {
		utils.ErrorLog("dialysisNo")
		code = enums.ErrorCodeParamWrong
		return
	}
	dialysisNo, _ := patientBody["dialysisNo"].(string)
	if len(dialysisNo) == 0 {
		utils.ErrorLog("len(dialysisNo) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.DialysisNo = dialysisNo
	// }

	if patientBody["lapseto"] == nil || reflect.TypeOf(patientBody["lapseto"]).String() != "float64" {
		utils.ErrorLog("lapseto")
		code = enums.ErrorCodeParamWrong
		return
	}
	lapseto := int64(patientBody["lapseto"].(float64))
	if lapseto <= 0 {
		utils.ErrorLog("lapseto == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Lapseto = lapseto

	if patientBody["gender"] == nil || reflect.TypeOf(patientBody["gender"]).String() != "float64" {
		utils.ErrorLog("gender")
		code = enums.ErrorCodeParamWrong
		return
	}
	gender := int64(patientBody["gender"].(float64))
	if gender <= 0 {
		utils.ErrorLog("gender <= 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Gender = gender

	if patientBody["response_result"] != nil && reflect.TypeOf(patientBody["response_result"]).String() == "string" {
		response_result := patientBody["response_result"].(string)
		patient.ResponseResult = response_result
	}

	if patientBody["age"] == nil || reflect.TypeOf(patientBody["age"]).String() != "float64" {
		utils.ErrorLog("age")
		code = enums.ErrorCodeParamWrong
		return
	}
	age := int64(patientBody["age"].(float64))
	patient.Age = age

	if patientBody["user_sys_before_count"] != nil || reflect.TypeOf(patientBody["user_sys_before_count"]).String() == "string" {
		user_sys_before_count := patientBody["user_sys_before_count"].(string)
		count, _ := strconv.ParseInt(user_sys_before_count, 10, 64)
		patient.UserSysBeforeCount = count
	}

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

	if patientBody["birth"] == nil || reflect.TypeOf(patientBody["birth"]).String() != "string" {
		utils.ErrorLog("birth")
		code = enums.ErrorCodeParamWrong
		return
	}
	birth, _ := patientBody["birth"].(string)
	if len(birth) == 0 {
		utils.ErrorLog("len(birth) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	birthTime, err := time.ParseInLocation(timeLayout, birth, loc)
	if err != nil {
		utils.ErrorLog("birthTime")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Birthday = birthTime.Unix()

	if patientBody["height"] != nil && reflect.TypeOf(patientBody["height"]).String() == "string" {
		height, _ := strconv.ParseInt(patientBody["height"].(string), 10, 64)
		patient.Height = height
	}

	if patientBody["maritalStatus"] != nil && reflect.TypeOf(patientBody["maritalStatus"]).String() == "float64" {
		maritalStatus := int64(patientBody["maritalStatus"].(float64))
		patient.MaritalStatus = maritalStatus
	}

	if patientBody["children"] != nil && reflect.TypeOf(patientBody["children"]).String() == "string" {
		children, _ := strconv.ParseInt(patientBody["children"].(string), 10, 64)
		patient.Children = children
	}

	if patientBody["admissionNumber"] != nil && reflect.TypeOf(patientBody["admissionNumber"]).String() == "string" {
		admissionNumber, _ := patientBody["admissionNumber"].(string)
		patient.AdmissionNumber = admissionNumber
	}

	if patientBody["reimbursementWayID"] != nil && reflect.TypeOf(patientBody["reimbursementWayID"]).String() == "float64" {
		reimbursementWayID := int64(patientBody["reimbursementWayID"].(float64))
		patient.ReimbursementWayId = reimbursementWayID
	}

	if patientBody["healthCareNo"] != nil && reflect.TypeOf(patientBody["healthCareNo"]).String() == "string" {
		healthCareNo := patientBody["healthCareNo"].(string)
		patient.HealthCareNo = healthCareNo
	}

	if patientBody["phone"] == nil || reflect.TypeOf(patientBody["phone"]).String() != "string" {
		utils.ErrorLog("phone")
		code = enums.ErrorCodeParamWrong
		return
	}
	phone := patientBody["phone"].(string)
	if len(phone) == 0 {
		utils.ErrorLog("len(phone) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	if !utils.CheckMobile(phone) {
		utils.ErrorLog("!phone")
		code = enums.ErrorCodeMobileFormat
		return
	}
	patient.Phone = phone

	if patientBody["homeTelephone"] != nil && reflect.TypeOf(patientBody["homeTelephone"]).String() == "string" {
		homeTelephone := patientBody["homeTelephone"].(string)
		patient.HomeTelephone = homeTelephone
	}

	if patientBody["relative_phone"] != nil && reflect.TypeOf(patientBody["relative_phone"]).String() == "string" {
		relativePhone := patientBody["relative_phone"].(string)
		patient.RelativePhone = relativePhone
	}

	if patientBody["relative_relations"] != nil && reflect.TypeOf(patientBody["relative_relations"]).String() == "string" {
		relativeRelations := patientBody["relative_relations"].(string)
		patient.RelativeRelations = relativeRelations
	}

	if patientBody["homeAddress"] != nil && reflect.TypeOf(patientBody["homeAddress"]).String() == "string" {
		homeAddress := patientBody["homeAddress"].(string)
		patient.HomeAddress = homeAddress
	}

	if patientBody["work"] != nil && reflect.TypeOf(patientBody["work"]).String() == "string" {
		work := patientBody["work"].(string)
		patient.WorkUnit = work
	}

	if patientBody["unit_address"] != nil && reflect.TypeOf(patientBody["unit_address"]).String() == "string" {
		unitAddress := patientBody["unit_address"].(string)
		patient.UnitAddress = unitAddress
	}

	if patientBody["profession"] != nil && reflect.TypeOf(patientBody["profession"]).String() == "float64" {
		profession := int64(patientBody["profession"].(float64))
		patient.Profession = profession
	}

	if patientBody["education"] != nil && reflect.TypeOf(patientBody["education"]).String() == "float64" {
		education := int64(patientBody["education"].(float64))
		patient.EducationLevel = education
	}

	if patientBody["source"] == nil || reflect.TypeOf(patientBody["source"]).String() != "float64" {
		utils.ErrorLog("source")
		code = enums.ErrorCodeParamWrong
		return
	}
	source := int64(patientBody["source"].(float64))
	if source <= 0 {
		utils.ErrorLog("source <= 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.Source = source

	zb_patient_id := patientBody["zb_patient_id"].(string)
	patient.ZbPatientId = zb_patient_id

	if patientBody["is_hospital_first_dialysis"] != nil && reflect.TypeOf(patientBody["is_hospital_first_dialysis"]).String() == "float64" {
		isHospitalFirstDialysis := int64(patientBody["is_hospital_first_dialysis"].(float64))
		patient.IsHospitalFirstDialysis = isHospitalFirstDialysis
	}

	if patientBody["firstDialysisDate"] != nil && reflect.TypeOf(patientBody["firstDialysisDate"]).String() == "string" {
		firstDialysisDate := patientBody["firstDialysisDate"].(string)
		firstDialysisDateTime, err := time.ParseInLocation(timeLayout, firstDialysisDate, loc)
		if err == nil {
			patient.FirstDialysisDate = firstDialysisDateTime.Unix()
		}
	}

	if patientBody["first_dialysis_hospital"] != nil && reflect.TypeOf(patientBody["first_dialysis_hospital"]).String() == "string" {
		firstDialysisHospital := patientBody["first_dialysis_hospital"].(string)
		patient.FirstDialysisHospital = firstDialysisHospital
	}

	if patientBody["predialysis_condition"] != nil && reflect.TypeOf(patientBody["predialysis_condition"]).String() == "[]interface {}" {
		thePredialysisCondition, _ := patientBody["predialysis_condition"].([]interface{})
		if len(thePredialysisCondition) > 0 {
			conditions := make([]string, 0)
			for _, item := range thePredialysisCondition {
				if reflect.TypeOf(item).String() != "string" {
					continue
				}
				condition := item.(string)
				if len(condition) > 0 {
					conditions = append(conditions, condition)
				}
			}
			patient.PredialysisCondition = strings.Join(conditions, ",")
		}
	}

	if patientBody["pre_hospital_dialysis_frequency"] != nil && reflect.TypeOf(patientBody["pre_hospital_dialysis_frequency"]).String() == "string" {
		preHospitalDialysisFrequency := patientBody["pre_hospital_dialysis_frequency"].(string)
		patient.PreHospitalDialysisFrequency = preHospitalDialysisFrequency
	}

	if patientBody["pre_hospital_dialysis_times"] != nil && reflect.TypeOf(patientBody["pre_hospital_dialysis_times"]).String() == "string" {
		preHospitalDialysisTimes, _ := strconv.ParseInt(patientBody["pre_hospital_dialysis_times"].(string), 10, 64)
		patient.PreHospitalDialysisTimes = preHospitalDialysisTimes
	}
	if patientBody["hospital_first_dialysis_date"] != nil && reflect.TypeOf(patientBody["hospital_first_dialysis_date"]).String() == "string" {
		hospitalFirstDialysisDate := patientBody["hospital_first_dialysis_date"].(string)
		hospitalFirstDialysisDateTime, err := time.ParseInLocation(timeLayout, hospitalFirstDialysisDate, loc)
		if err == nil {
			patient.HospitalFirstDialysisDate = hospitalFirstDialysisDateTime.Unix()
		}
	}

	if patientBody["partition"] != nil && reflect.TypeOf(patientBody["partition"]).String() == "float64" {
		partition := int64(patientBody["partition"].(float64))
		patient.PartitionId = partition
	}
	if patientBody["bed"] != nil && reflect.TypeOf(patientBody["bed"]).String() == "string" {
		bed, _ := strconv.ParseInt(patientBody["bed"].(string), 10, 64)
		patient.BedId = bed
	}

	if patientBody["healthCareDueDate"] != nil && reflect.TypeOf(patientBody["healthCareDueDate"]).String() == "string" {
		healthCareDueDate := patientBody["healthCareDueDate"].(string)
		healthCareDueDateTime, err := time.ParseInLocation(timeLayout, healthCareDueDate, loc)
		if err == nil {
			patient.HealthCareDueDate = healthCareDueDateTime.Unix()
		}
	}

	if patientBody["blood"] != nil && reflect.TypeOf(patientBody["blood"]).String() == "float64" {
		blood := int64(patientBody["blood"].(float64))
		patient.BloodType = blood
	}

	if patientBody["rh"] != nil && reflect.TypeOf(patientBody["rh"]).String() == "float64" {
		rh := int64(patientBody["rh"].(float64))
		patient.Rh = rh
	}

	if patientBody["healthCareDueAlertDate"] != nil && reflect.TypeOf(patientBody["healthCareDueAlertDate"]).String() == "string" {
		healthCareDueAlertDate := patientBody["healthCareDueAlertDate"].(string)
		healthCareDueAlertDateTime, err := time.ParseInLocation(timeLayout, healthCareDueAlertDate, loc)
		if err == nil {
			patient.HealthCareDueAlertDate = healthCareDueAlertDateTime.Unix()
		}
	}

	if patientBody["receivingDate"] != nil && reflect.TypeOf(patientBody["receivingDate"]).String() == "string" {
		receivingDate := patientBody["receivingDate"].(string)
		receivingDateTime, err := time.ParseInLocation(timeLayout, receivingDate, loc)
		if err == nil {
			patient.ReceivingDate = receivingDateTime.Unix()
		}
	}

	if patientBody["induction"] != nil && reflect.TypeOf(patientBody["induction"]).String() == "float64" {
		induction := int64(patientBody["induction"].(float64))
		patient.InductionPeriod = induction
	}

	if patientBody["initial"] != nil && reflect.TypeOf(patientBody["initial"]).String() == "string" {
		initial, _ := strconv.ParseInt(patientBody["initial"].(string), 10, 64)
		patient.InitialDialysis = initial
	}

	if patientBody["dialysisTotal"] != nil && reflect.TypeOf(patientBody["dialysisTotal"]).String() == "string" {
		dialysisTotal, _ := strconv.ParseInt(patientBody["dialysisTotal"].(string), 10, 64)
		patient.TotalDialysis = dialysisTotal
	}

	if patientBody["contagions"] != nil && reflect.TypeOf(patientBody["contagions"]).String() == "[]interface {}" {
		thisContagions, _ := patientBody["contagions"].([]interface{})
		if len(thisContagions) > 0 {
			for _, item := range thisContagions {
				if reflect.TypeOf(item).String() != "float64" {
					continue
				}
				contagion := int64(item.(float64))
				if contagion > 0 {
					contagions = append(contagions, contagion)
				}
			}
		}
	}

	if patientBody["doctor"] != nil && reflect.TypeOf(patientBody["doctor"]).String() == "float64" {
		doctor := int64(patientBody["doctor"].(float64))
		patient.AttendingDoctorId = doctor
	}

	if patientBody["nurse"] != nil && reflect.TypeOf(patientBody["nurse"]).String() == "float64" {
		nurse := int64(patientBody["nurse"].(float64))
		patient.HeadNurseId = nurse
	}

	if patientBody["assessment"] != nil && reflect.TypeOf(patientBody["assessment"]).String() == "string" {
		assessment := patientBody["assessment"].(string)
		patient.Evaluate = assessment
	}

	if patientBody["diseases"] != nil && reflect.TypeOf(patientBody["diseases"]).String() == "[]interface {}" {
		thisDiseases, _ := patientBody["diseases"].([]interface{})
		if len(thisDiseases) > 0 {
			for _, item := range thisDiseases {
				if reflect.TypeOf(item).String() != "float64" {
					continue
				}
				disease := int64(item.(float64))
				if disease > 0 {
					diseases = append(diseases, disease)
				}
			}
		}
	}

	if patientBody["diagnose"] != nil && reflect.TypeOf(patientBody["diagnose"]).String() == "string" {
		diagnose := patientBody["diagnose"].(string)
		patient.Diagnose = diagnose
	}

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

	if patientBody["sch_remark"] != nil && reflect.TypeOf(patientBody["sch_remark"]).String() == "string" {
		sch_remark := patientBody["sch_remark"].(string)
		patient.SchRemark = sch_remark
	}

	if patientBody["patient_complains"] != nil && reflect.TypeOf(patientBody["patient_complains"]).String() == "string" {
		patient_complains := patientBody["patient_complains"].(string)
		patient.PatientComplains = patient_complains
	}

	if patientBody["present_history"] != nil && reflect.TypeOf(patientBody["present_history"]).String() == "string" {
		present_history := patientBody["present_history"].(string)
		patient.PresentHistory = present_history
	}

	if patientBody["past_history"] != nil && reflect.TypeOf(patientBody["past_history"]).String() == "string" {
		past_history := patientBody["past_history"].(string)
		patient.PastHistory = past_history
	}

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

	if patientBody["pulse"] != nil && reflect.TypeOf(patientBody["pulse"]).String() == "string" {
		pulse, _ := strconv.ParseInt(patientBody["pulse"].(string), 10, 64)
		patient.Pulse = pulse
	}

	if patientBody["respiratory"] != nil && reflect.TypeOf(patientBody["respiratory"]).String() == "string" {
		respiratory, _ := strconv.ParseInt(patientBody["respiratory"].(string), 10, 64)
		patient.Respiratory = respiratory
	}

	if patientBody["sbp"] != nil && reflect.TypeOf(patientBody["sbp"]).String() == "string" {
		sbp, _ := strconv.ParseInt(patientBody["sbp"].(string), 10, 64)
		patient.SBP = sbp
	}

	if patientBody["dbp"] != nil && reflect.TypeOf(patientBody["dbp"]).String() == "string" {
		dbp, _ := strconv.ParseInt(patientBody["dbp"].(string), 10, 64)
		patient.DBP = dbp
	}

	if patientBody["dialysis_age"] != nil && reflect.TypeOf(patientBody["dialysis_age"]).String() == "string" {
		dialysis_age, _ := strconv.ParseInt(patientBody["dialysis_age"].(string), 10, 64)
		patient.DialysisAge = dialysis_age
	}
	fmt.Println(patient.DialysisAge)
	if patientBody["first_treatment_date"] != nil && reflect.TypeOf(patientBody["first_treatment_date"]).String() == "string" {
		first_treatment_date := patientBody["first_treatment_date"].(string)
		first_treatment_time, err := time.ParseInLocation(timeLayout, first_treatment_date, loc)
		if err == nil {
			patient.FirstTreatmentDate = first_treatment_time.Unix()
		}
	}
	if patientBody["expense_kind"] != nil && reflect.TypeOf(patientBody["expense_kind"]).String() == "float64" {
		expense_kind := int64(patientBody["expense_kind"].(float64))
		patient.ExpenseKind = expense_kind
	}
	fmt.Println(patient.ExpenseKind)
	if patientBody["tell_phone"] != nil && reflect.TypeOf(patientBody["tell_phone"]).String() == "string" {
		tell_phone := patientBody["tell_phone"].(string)
		patient.TellPhone = tell_phone
	}
	if patientBody["contact_name"] != nil && reflect.TypeOf(patientBody["contact_name"]).String() == "string" {
		contact_name := patientBody["contact_name"].(string)
		patient.ContactName = contact_name
	}
	if patientBody["troble_shoot"] != nil && reflect.TypeOf(patientBody["troble_shoot"]).String() == "float64" {
		troble_shoot := int64(patientBody["troble_shoot"].(float64))
		patient.TrobleShoot = troble_shoot
	}

	if patientBody["treatment_plan"] != nil && reflect.TypeOf(patientBody["treatment_plan"]).String() == "string" {
		treatment_plan := patientBody["treatment_plan"].(string)
		patient.TreatmentPlan = treatment_plan
	}

	if patientBody["doctor"] != nil && reflect.TypeOf(patientBody["doctor"]).String() == "float64" {
		doctor := int64(patientBody["doctor"].(float64))
		patient.Doctor = doctor
	}

	if patientBody["record_number"] != nil && reflect.TypeOf(patientBody["record_number"]).String() == "string" {
		record_number := patientBody["record_number"].(string)
		patient.RecordNumber = record_number
	}

	patient_source := int64(patientBody["patient_source"].(float64))
	if patient_source <= 0 {
		utils.ErrorLog("patient_source <= 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	patient.PatientSource = patient_source

	if patientBody["patient_start_time"] != nil && reflect.TypeOf(patientBody["patient_start_time"]).String() == "string" {
		patient_start_time := patientBody["patient_start_time"].(string)
		var startTime int64
		if len(patient_start_time) > 0 {
			theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", patient_start_time+" 00:00:00", loc)

			startTime = theTime.Unix()
		}
		patient.PatientStartTime = startTime
	}

	if patientBody["patient_end_time"] != nil && reflect.TypeOf(patientBody["patient_end_time"]).String() == "string" {
		patient_end_time := patientBody["patient_end_time"].(string)
		var endTime int64
		if len(patient_end_time) > 0 {
			theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", patient_end_time+" 00:00:00", loc)

			endTime = theTime.Unix()
		}
		patient.PatientEndTime = endTime
	}

	if patientBody["infectious_remark"] != nil && reflect.TypeOf(patientBody["infectious_remark"]).String() == "string" {
		record_number := patientBody["infectious_remark"].(string)
		patient.InfectiousRemark = record_number
	}

	if patientBody["allergic_history"] != nil && reflect.TypeOf(patientBody["allergic_history"]).String() == "string" {
		allergic_history := patientBody["allergic_history"].(string)
		patient.AllergicHistory = allergic_history
	}

	if patientBody["patient_address"] != nil && reflect.TypeOf(patientBody["patient_address"]).String() == "string" {
		patient_address := patientBody["patient_address"].(string)
		patient.PatientAddress = patient_address
	}

	return

}

func (c *PatientApiController) GetPatientsByKeyWord() {
	keyWord := c.GetString("keyword")
	adminUserInfo := c.GetAdminUserInfo()
	patient, err := service.GetPatientByKeyWord(adminUserInfo.CurrentOrgId, keyWord)
	if err != nil {
		utils.ErrorLog(err.Error())
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"patient": patient,
	})
}

func (c *PatientApiController) QueryPatientById() {
	id, _ := c.GetInt64("id")
	fmt.Println(id)
	patientInfo := service.QueryPatientById(id)
	c.ServeSuccessJSON(map[string]interface{}{
		"patient": patientInfo,
	})
	return
}

func (c *PatientApiController) GetRemindPatientList() {
	page, _ := c.GetInt64("page", 1)
	limit, _ := c.GetInt64("limit", 10)
	adminUserInfo := c.GetAdminUserInfo()
	total, patients, _ := service.GetAllWaitRemindPatient(adminUserInfo.CurrentOrgId, page, limit)
	_, errcode := service.GetOrgFollowIsExist(c.GetAdminUserInfo().CurrentOrgId)
	if errcode == gorm.ErrRecordNotFound {
		information, err := service.GetAdminUserRoleInformation(0)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"total":       total,
			"patients":    patients,
			"information": information,
		})
	} else if errcode == nil {
		information, err := service.GetAdminUserRoleInformation(c.GetAdminUserInfo().CurrentOrgId)
		if err != nil {
			utils.ErrorLog(err.Error())
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"total":       total,
			"patients":    patients,
			"information": information,
		})
	}
}

func (c *PatientApiController) PostIsOpenRemind() {
	patient_id, _ := c.GetInt64("id", 1)
	is_open_remind, _ := c.GetInt64("is_open_remind", 1)
	adminUserInfo := c.GetAdminUserInfo()

	err := service.UpdatePatientRemindStatus(patient_id, is_open_remind, adminUserInfo.CurrentOrgId)

	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"msg":            "成功",
			"is_open_remind": is_open_remind,
		})
	} else if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	}
}

func (c *PatientApiController) GetPatientScheduleOne() {
	id, _ := c.GetInt64("id")
	//查询该病人是否当天是排班
	nowDateTime := time.Now()
	nowDate := nowDateTime.Format("2006-01-02")
	nowDate += " 00:00:00"
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", nowDate, loc)
	nowdate := theTime.Unix()
	fmt.Println("nowdate", nowdate)
	adminUser := c.GetAdminUserInfo()
	orgId := adminUser.CurrentOrgId
	fmt.Println("orgid", orgId)
	scheduls, err := service.GetPatientScheduleOne(id, nowdate, orgId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"scheduls": scheduls,
	})
}

func (c *PatientApiController) ExportPatients() {
	dataBody := make(map[string]interface{}, 0)

	all_patient, _, _ := service.GetAllPatientList(c.GetAdminUserInfo().CurrentOrgId)

	//all_patient, _,_ := service.GetAllPatientList(c.GetAdminUserInfo().CurrentOrgId )

	org, _ := service.GetOrgById(c.GetAdminUserInfo().CurrentOrgId)

	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		return
	}
	utils.ErrorLog("%v", dataBody)
	export_time := time.Now().Unix()
	var patients []*models.Patients
	var total_patients []interface{}
	if dataBody["patients"] != nil || reflect.TypeOf(dataBody["patients"]).String() == "[]interface {}" {
		tempPatients := dataBody["patients"].([]interface{})
		total_patients = tempPatients
		for index, patientMap := range tempPatients {
			patientNameM := patientMap.(map[string]interface{})
			var patient models.Patients

			if patientNameM["name"] == nil || reflect.TypeOf(patientNameM["name"]).String() != "string" {
				utils.ErrorLog("name")
				return
			}
			name, _ := patientNameM["name"].(string)
			if len(name) == 0 { //名字为空则生成一条导入错误日志
				err_log := models.ExportErrLog{
					LogType:    1,
					UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
					ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的姓名不能为空",
					Status:     1,
					CreateTime: time.Now().Unix(),
					UpdateTime: time.Now().Unix(),
					ExportTime: export_time,
				}
				service.CreateExportErrLog(&err_log)
				continue
			}
			patient.Name = name

			if patientNameM["gender"] != nil || reflect.TypeOf(patientNameM["gender"]).String() == "string" {
				gender, _ := strconv.ParseInt(patientNameM["gender"].(string), 10, 64)
				if gender == 0 { //性别不符合要求则生成一条导入错误日志
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的性别不符合要求",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue
				} else {
					patient.Gender = gender
				}
			}

			if patientNameM["phone"] != nil || reflect.TypeOf(patientNameM["phone"]).String() == "string" {
				phone, _ := patientNameM["phone"].(string)
				if utils.CellPhoneRegexp().MatchString(phone) == false { //手机号码不符合要求则生成一条导入错误日志
					if len(phone) == 0 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的手机号码不能为空",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue
					} else {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的手机号码格式不符合要求",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue
					}

				} else {
					//var tempPatient *models.Patients
					//for _, item := range all_patient {
					//	if item.Phone == phone {
					//		tempPatient = item
					//	}
					//}

					//需要判断该号码是否已经在系统内存在了，存在了则生成一条导入错误日志
					count := service.FindPatientPhoneIsExist(phone, c.GetAdminUserInfo().CurrentOrgId)
					if count >= 1 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的手机号码在系统中已经存在",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue
					}
					patient.Phone = phone
				}
			}

			if patientNameM["id_card_no"] != nil || reflect.TypeOf(patientNameM["id_card_no"]).String() == "string" {
				id_card_no, _ := patientNameM["id_card_no"].(string)

				if IsIdCard(id_card_no) == false { //身份证号码不符合要求则生成一条导入错误日志

					if len(id_card_no) == 0 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的身份证号码不能为空",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue

					} else {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的身份证号码格式不符合要求",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue

					}

				} else {
					//var tempPatient *models.Patients
					//for _, item := range all_patient {
					//	if item.IdCardNo == id_card_no {
					//		tempPatient = item
					//	}
					//}
					count := service.FindPatientIdCardNoIsExist(id_card_no, c.GetAdminUserInfo().CurrentOrgId)
					if count >= 1 {
						//if tempPatient != nil && tempPatient.ID > 0 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的身份证号码在系统中已经存在",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue
					}
					//}
					patient.IdCardNo = id_card_no
					//patient.Birthday = GetBirthDay(id_card_no).Unix()
					if GetBirthDay(id_card_no) == nil {
						patient.Birthday = 0
					} else {
						patient.Birthday = GetBirthDay(id_card_no).Unix()

					}
				}
			}

			fmt.Println("111112222")
			if patientNameM["first_treatment_date"] != nil || reflect.TypeOf(patientNameM["first_treatment_date"]).String() == "string" {
				first_treatment_date, _ := patientNameM["first_treatment_date"].(string)
				timeLayout := "2006/01/02"
				loc, _ := time.LoadLocation("Local")
				first_dialysis_date, err := time.ParseInLocation(timeLayout, first_treatment_date, loc)

				if err != nil { //首次肾脏治疗时间不符合要求则生成一条导入错误日志
					if len(first_treatment_date) == 0 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的首次肾脏治疗时间不能为空",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue

					} else {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的首次肾脏治疗时间格式不符合要求",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue

					}

				} else {
					if len(first_treatment_date) == 0 {
						err_log := models.ExportErrLog{
							LogType:    1,
							UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
							ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的首次肾脏治疗时间不能为空",
							Status:     1,
							CreateTime: time.Now().Unix(),
							UpdateTime: time.Now().Unix(),
							ExportTime: export_time,
						}
						service.CreateExportErrLog(&err_log)
						continue
					} else {

						if first_dialysis_date.Unix() == 0 { //首次肾脏治疗时间不符合要求则生成一条导入错误日志
							err_log := models.ExportErrLog{
								LogType:    1,
								UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
								ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的首次肾脏治疗时间格式不符合要求",
								Status:     1,
								CreateTime: time.Now().Unix(),
								UpdateTime: time.Now().Unix(),
								ExportTime: export_time,
							}
							service.CreateExportErrLog(&err_log)
							continue
						} else {
							patient.FirstDialysisDate = first_dialysis_date.Unix()
						}

					}

				}
			}

			if patientNameM["source"] != nil || reflect.TypeOf(patientNameM["source"]).String() == "string" {
				source, _ := strconv.ParseInt(patientNameM["source"].(string), 10, 64)
				if source == 0 { //患者来源不符合要求则生成一条导入错误日志
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的患者来源不符合要求",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue
				} else if source == 3 {
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的患者来源不能为空",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue

				} else {
					patient.Source = source
				}
			}

			if patientNameM["lapseto"] != nil || reflect.TypeOf(patientNameM["lapseto"]).String() == "string" {
				lapseto, _ := strconv.ParseInt(patientNameM["lapseto"].(string), 10, 64)
				if lapseto == 0 { //治疗状态不符合要求则生成一条导入错误日志
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的治疗状态不符合要求",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue
				} else if lapseto == 3 {
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的治疗状态不能为空",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue

				} else {
					patient.Lapseto = lapseto
				}
			}

			if patientNameM["is_infectious"] != nil || reflect.TypeOf(patientNameM["is_infectious"]).String() == "string" {
				is_infectious, _ := strconv.ParseInt(patientNameM["is_infectious"].(string), 10, 64)
				if is_infectious == 0 { //传染病不符合要求则生成一条导入错误日志
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的传染病状态不符合要求",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue
				} else if is_infectious == 3 {
					err_log := models.ExportErrLog{
						LogType:    1,
						UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
						ErrMsg:     "第" + strconv.Itoa(index+3) + "行" + "的传染病状态不能为空",
						Status:     1,
						CreateTime: time.Now().Unix(),
						UpdateTime: time.Now().Unix(),
						ExportTime: export_time,
					}
					service.CreateExportErrLog(&err_log)
					continue

				} else {
					patient.IsInfectious = is_infectious
				}
			}

			if patientNameM["contagions"] != nil && reflect.TypeOf(patientNameM["contagions"]).String() == "[]interface {}" {
				var contagions []int64
				thisContagions, _ := patientNameM["contagions"].([]interface{})
				if len(thisContagions) > 0 {
					for _, item := range thisContagions {
						if reflect.TypeOf(item).String() != "float64" {
							continue
						}
						contagion := int64(item.(float64))
						if contagion > 0 {
							contagions = append(contagions, contagion)
						}
					}
				}
				patient.ContagionIds = contagions
			}

			if patientNameM["diagnose"] != nil || reflect.TypeOf(patientNameM["diagnose"]).String() == "string" {
				diagnose, _ := patientNameM["diagnose"].(string)
				patient.Diagnose = diagnose

			}

			if patientNameM["dialysis_no"] != nil || reflect.TypeOf(patientNameM["dialysis_no"]).String() == "string" {
				dialysis_no, _ := patientNameM["dialysis_no"].(string)
				var tempPatient *models.Patients
				for _, item := range all_patient {
					if item.DialysisNo == dialysis_no {
						tempPatient = item
					}
				}
				if tempPatient != nil && tempPatient.ID > 0 {
					patient.DialysisNo = GenerateDialysisNoTwo(patients)
				} else {
					patient.DialysisNo = dialysis_no
				}
			}

			if patientNameM["height"] != nil || reflect.TypeOf(patientNameM["height"]).String() == "string" {
				height, _ := patientNameM["height"].(string)
				heights, _ := strconv.ParseFloat(height, 64)
				patient.Height = int64(heights)
			}

			if patientNameM["home_address"] != nil || reflect.TypeOf(patientNameM["home_address"]).String() == "string" {
				home_address, _ := patientNameM["home_address"].(string)
				patient.HomeAddress = home_address
			}
			if patientNameM["dry_weight"] != nil || reflect.TypeOf(patientNameM["dry_weight"]).String() == "string" {
				dry_weight, _ := patientNameM["dry_weight"].(string)
				dry_weights, _ := strconv.ParseFloat(dry_weight, 64)
				patient.DryWeight = dry_weights

			}
			patient.CreatedTime = time.Now().Unix()
			patient.UpdatedTime = time.Now().Unix()
			patient.Status = 1
			patient.Avatar = "https://images.shengws.com/201809182128111.png"
			patient.UserOrgId = c.GetAdminUserInfo().CurrentOrgId
			patient.IsExcelExport = 1
			patient.PatientType = 1
			patients = append(patients, &patient)
		}
	}
	errLogs, _ := service.FindPatientExportLog(c.GetAdminUserInfo().CurrentOrgId, export_time)

	if len(patients) > 0 {
		for _, item := range patients {
			service.CreateExportPatient(item, item.ContagionIds, org.Creator)
		}

		log := models.ExportLog{
			LogType:    1,
			UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
			TotalNum:   int64(len(total_patients)),
			FailNum:    int64(len(errLogs)),
			SuccessNum: int64(len(patients)),
			CreateTime: time.Now().Unix(),
			UpdateTime: time.Now().Unix(),
			ExportTime: export_time,
			Status:     1,
		}
		service.CreateExportLog(&log)

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":         "导入成功",
			"total_num":   len(total_patients),
			"success_num": len(patients),
			"fail_num":    int64(len(errLogs)),
		})
	} else {
		log := models.ExportLog{
			LogType:    1,
			UserOrgId:  c.GetAdminUserInfo().CurrentOrgId,
			TotalNum:   int64(len(total_patients)),
			FailNum:    int64(len(errLogs)),
			SuccessNum: int64(len(patients)),
			CreateTime: time.Now().Unix(),
			UpdateTime: time.Now().Unix(),
			ExportTime: export_time,
			Status:     1,
		}
		service.CreateExportLog(&log)

		c.ServeSuccessJSON(map[string]interface{}{
			"msg":         "导入成功",
			"total_num":   len(total_patients),
			"success_num": len(patients),
			"fail_num":    int64(len(errLogs)),
		})
	}
}

func GetBirthDay(IDCardNo string) *time.Time {
	dayStr := IDCardNo[6:14]
	birthDay, err := time.Parse("20060102", dayStr)
	if err != nil {
		fmt.Println(err)
		return nil
	}
	return &birthDay
}

func IsIdCard(id string) (res bool) {
	id = strings.ToUpper(id)
	if len(id) != 15 && len(id) != 18 {
		fmt.Println("1111111")
		return false
	}
	r := regexp.MustCompile("(\\d{15})|(\\d{17}([0-9]|X))")
	if !r.MatchString(id) {
		fmt.Println("222222")

		return false
	}
	if len(id) == 15 {
		tm2, _ := time.Parse("01/02/2006", string([]byte(id)[8:10])+"/"+string([]byte(id)[10:12])+"/"+"19"+string([]byte(id)[6:8]))
		if tm2.Unix() == 0 {
			fmt.Println("44444443333")

			return false
		}
		return true
	} else {
		tm2, _ := time.Parse("01/02/2006", string([]byte(id)[10:12])+"/"+string([]byte(id)[12:14])+"/"+string([]byte(id)[6:10]))
		fmt.Println(string([]byte(id)[10:12]) + "/" + string([]byte(id)[12:14]) + "/" + string([]byte(id)[6:10]))
		fmt.Println(tm2.Unix())

		if tm2.Unix() == 0 {

			fmt.Println("44445555555")

			return false
		}
		//检验18位身份证的校验码是否正确。
		//校验位按照ISO 7064:1983.MOD 11-2的规定生成，X可以认为是数字10。
		arr_int := []int{7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2}
		arr_ch := []string{"1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"}
		sign := 0
		for k, v := range arr_int {
			int_temp, _ := strconv.Atoi(string([]byte(id)[k : k+1]))
			sign += int_temp * v
		}
		n := sign % 11
		val_num := arr_ch[n]
		if val_num != string([]byte(id)[17:18]) {
			fmt.Println("5556666666")

			return false
		}
		return true
	}
}

func (c *PatientApiController) SaveEditAdvices() {
	adminInfo := c.GetAdminUserInfo()
	orgid := adminInfo.CurrentOrgId
	startTime := c.GetString("start_time")

	theTime, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", startTime)

	groupno, _ := c.GetInt64("groupno")
	fmt.Println("组", groupno)
	date, _ := c.GetInt64("date")
	fmt.Println("date", date)
	patient_id, _ := c.GetInt64("patient_id")
	fmt.Println("paitent_id", patient_id)
	advice := models.XtDoctorAdvice{
		StartTime: theTime.Unix(),
	}
	err := service.UpdateDoctorEditAdvice(advice, orgid, groupno, date, patient_id)
	key := strconv.FormatInt(orgid, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(date, 10) + ":doctor_advices"
	redis := service.RedisClient()

	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(orgid, 10) + ":" + strconv.FormatInt(date, 10) + ":advice_list_all"
	redis.Set(keyOne, "", time.Second)

	scheduleTime := theTime.Format("2006-01-02")
	keyFour := "scheduals_" + scheduleTime + "_" + strconv.FormatInt(orgid, 10)
	fmt.Println("keyFour323223323232323232", keyFour)
	redis.Set(keyFour, "", time.Second)

	defer redis.Close()
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"advice": advice,
	})
}

func (c *PatientApiController) GetMaxDialysisNo() {
	dialysisNo := service.ChechLastDialysisNo(c.GetAdminUserInfo().CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"dialysis_no": dialysisNo,
	})

}

func GenerateDialysisNoTwo(patients []*models.Patients) string {
	dialysisNo2 := fmt.Sprintf("%06v", rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(1000000))
	var tempPatient *models.Patients
	for _, item := range patients {
		if item.DialysisNo == dialysisNo2 {
			tempPatient = item
		}
	}
	if tempPatient == nil || tempPatient.ID == 0 {
		return dialysisNo2
	}
	return GenerateDialysisNoTwo(patients)
}

func (c *PatientApiController) GetBanner() {

	orgId := c.GetAdminUserInfo().CurrentOrgId

	_, errcodes := service.GetOrgFollowIsExist(orgId)

	if errcodes == gorm.ErrRecordNotFound {
		information, err := service.GetAdminUserRoleInformation(0)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"information": information,
		})
	} else if errcodes == nil {
		information, err := service.GetAdminUserRoleInformation(orgId)
		if err != nil {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"information": information,
		})
	}
}

func (c *PatientApiController) GetPatientDialysisLongSolution() {

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

	adminUserInfo := c.GetAdminUserInfo()

	//获取该患者分组的透析模式
	list, _ := service.GetPatientSolutionGroupList(patient_id, adminUserInfo.CurrentOrgId)

	for _, item := range list {
		//获取该模式最新的1条数据
		solution, _ := service.GetNewPatientSolutionByModeId(patient_id, item.ModeId, adminUserInfo.CurrentOrgId)
		//更新状态值
		service.UpdateDialysisSolutionStatus(solution.ID, item.ModeId, adminUserInfo.CurrentOrgId, patient_id)
	}

	solution, total, err := service.GetPatientDialysisLongSolution(patient_id, page, limit, adminUserInfo.CurrentOrgId)
	stockType, _ := service.GetStockType(adminUserInfo.CurrentOrgId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"solutions": solution,
		"total":     total,
		"stockType": stockType,
	})
}

func (c *PatientApiController) GetDialysisSolutionDetailList() {

	patient_id, _ := c.GetInt64("patient_id")
	mode_id, _ := c.GetInt64("mode_id")
	page, _ := c.GetInt64("page")
	limit, _ := c.GetInt64("limit")
	orgId := c.GetAdminUserInfo().CurrentOrgId
	list, total, err := service.GetDialysisSolutionDetailList(orgId, patient_id, mode_id, page, limit)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"list":  list,
		"total": total,
	})
}