XT_New/controllers/dialysis_api_controller.go

package controllers

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

	//"strings"
	"time"

	"XT_New/enums"

	"github.com/astaxie/beego"
)

type DialysisApiController struct {
	BaseAuthAPIController
}

func DialysisApiRegistRouters() {
	beego.Router("/api/dialysis/device", &DialysisApiController{}, "get:GetDeviceList")
	beego.Router("/api/dialysis/patients", &DialysisApiController{}, "get:GetDialysisWatch")
	beego.Router("/api/dialysis/zone", &DialysisApiController{}, "get:GetAllDeviceZone")
	beego.Router("/api/dialysis/info", &DialysisApiController{}, "get:GetSchedualPatientsInfo")
	beego.Router("/api/dialysis/advice/create", &DialysisApiController{}, "Post:CreateDoctorAdvice")
	beego.Router("/api/dialysis/advice/get", &DialysisApiController{}, "Get:GetDoctorAdvice")
	beego.Router("/api/dialysis/advice/edit", &DialysisApiController{}, "put:EditDoctorAdvice")
	beego.Router("/api/dialysis/monitor/create", &DialysisApiController{}, "Post:CreateMonitor")
	beego.Router("/api/dialysis/monitor/del", &DialysisApiController{}, "Post:DelMonitor")
	beego.Router("/api/dialysis/dialysisorder", &DialysisApiController{}, "Get:GetDialysisOrder")
	beego.Router("/api/dialysis/prescription", &DialysisApiController{}, "Post:PostPrescription")
	beego.Router("/api/dialysis/soulution", &DialysisApiController{}, "Post:PostSoulution")
	beego.Router("/api/dialysis/dobule", &DialysisApiController{}, "Post:PostDouleCheck")
	beego.Router("/api/dialysis/accepts", &DialysisApiController{}, "Post:PostReceiveTreatmentAsses")
	beego.Router("/api/dialysis/assessmentbeforedislysis", &DialysisApiController{}, "Post:PostAssessmentBeforeDislysis")
	beego.Router("/api/dialysis/assessmentafterdislysis", &DialysisApiController{}, "Post:PostAssessmentAfterDislysis")
	beego.Router("/api/dialysis/treatmentsummary", &DialysisApiController{}, "Post:PostTreatmentSummary")

	beego.Router("/api/dialysis/advice_remind", &DialysisApiController{}, "Get:GetLongAdvice")
	beego.Router("/api/dialysis/advice_remind/one", &DialysisApiController{}, "Get:GetLongAdviceOne")
	beego.Router("/api/dialysis/advice_remind/two", &DialysisApiController{}, "Get:GetLongAdviceTwo")
	beego.Router("/api/advice_remind/create", &DialysisApiController{}, "Post:CreateRemindDoctorAdvice")

	beego.Router("/api/solution/get", &DialysisApiController{}, "Get:GetSolution")

	beego.Router("/api/schedule/get", &DialysisApiController{}, "Get:GetSchedule")

	beego.Router("/api/today_monitor/get", &DialysisApiController{}, "Get:GetTodayMonitor")

	beego.Router("/api/dryweight/commit", &DialysisApiController{}, "Post:UploadDryWeight")

	beego.Router("/api/func_per/get", &DialysisApiController{}, "Get:GetFuncPurview")

	beego.Router("/api/doctoradvice/get", &DialysisApiController{}, "Get:GetLastOrNextDoctorAdvice")

	beego.Router("/api/dialysisgoods/get", &DialysisApiController{}, "Get:GetDialysisGoods")
	beego.Router("/api/goodstatistics/get", &DialysisApiController{}, "Get:GetDialysisGoodsStatistics")
	beego.Router("/api/queue/get", &DialysisApiController{}, "Get:GetQueueCall")
	beego.Router("/api/queue/update", &DialysisApiController{}, "Get:UpdateQueueCall")

	beego.Router("/api/get/getrolelist", &DialysisApiController{}, "Get:GetRoleList")

	beego.Router("/api/getinitprintdata", &DialysisApiController{}, "Get:GetInitPrintData")

	beego.Router("/api/schedule/getorderdoctoradvice", &DialysisApiController{}, "Get:GetOrderDoctorAdvice")

	beego.Router("/api/getinitprintdateone", &DialysisApiController{}, "Get:GetInitPrintDataOne")

	//新接口
	beego.Router("/api/patient/getpatientdialysissolutiongrouplist", &DialysisApiController{}, "Get:GetPatientDialysisSolutionGroupList")

	beego.Router("/api/patient/getdialysisadvicetemplatelist", &DialysisApiController{}, "Get:GetDialysisAdviceTemplateList")

	beego.Router("/api/patient/savedialysissetting", &DialysisApiController{}, "Get:SaveDialysisSetting")

	beego.Router("/api/patient/getdialysissetting", &DialysisApiController{}, "Get:GetDialysisSetting")

	beego.Router("/api/patient/getdialysisparameter", &DialysisApiController{}, "Get:GetDialysisParameterList")

	beego.Router("/api/patient/getdialysisgoodtotalcount", &DialysisApiController{}, "Get:GetDialysisGoodTotalCount")

	beego.Router("/api/patient/getdialysisadvicescheduelist", &DialysisApiController{}, "Get:GetDialysisAdviceSchedulist")

	beego.Router("/api/patient/getdialysisparametergoodlist", &DialysisApiController{}, "Get:GetDialysisParameterGoodList")

	beego.Router("/api/patient/savehisdialysis", &DialysisApiController{}, "Get:SaveHisDialysis")

	beego.Router("/api/patient/gethisdialysisgoodcount", &DialysisApiController{}, "Get:GetHisDialysisGoodCount")

	beego.Router("/api/schedule/getpatientshedule", &DialysisApiController{}, "Get:GetPatientSchedule")

	beego.Router("/api/patient/getscheduleprintlist", &DialysisApiController{}, "Get:GetSchedulePrintList")

	beego.Router("/api/patient/getsolutionlistbyorgid", &DialysisApiController{}, "Get:GetSolutionListByOrgId")

	beego.Router("/api/schedule/excutiondoctoradvice", &DialysisApiController{}, "Get:ExcutionDoctorAdvice")

	beego.Router("/api/schedule/checknewdoctoradvice", &DialysisApiController{}, "Get:CheckNewDoctorAdvice")

	beego.Router("/api/schedule/settlenewdoctoradvice", &DialysisApiController{}, "Get:SettleNewDoctorAdvice")

	beego.Router("/api/schedule/excutiondoctoradvicebyid", &DialysisApiController{}, "Get:ExcutionDoctorAdviceById")
}

func (c *DialysisApiController) GetQueueCall() {
	adminUserInfo := c.GetAdminUserInfo()
	queueConfig, _ := service.FindQueueCallInfo(adminUserInfo.CurrentOrgId)

	if queueConfig.ID <= 0 {
		queueConfig.OrgId = adminUserInfo.CurrentOrgId
		queueConfig.Qhsj = 10
		queueConfig.Jzdcbbcs = 3
		queueConfig.Jzbbsy = 1
		queueConfig.Jzjhyc = 0
		queueConfig.Sjdcbbcs = 3
		queueConfig.Sjbbsy = 0
		queueConfig.Sjjhyc = 0
		queueConfig.Txxqyxs = 0
		queueConfig.Txglsyxs = 0
	}

	c.ServeSuccessJSON(map[string]interface{}{
		"queue_config": queueConfig,
	})
}

func (c *DialysisApiController) UpdateQueueCall() {
	adminUserInfo := c.GetAdminUserInfo()
	queueConfig, _ := service.FindQueueCallInfo(adminUserInfo.CurrentOrgId)

	if queueConfig.ID <= 0 {
		queueConfig.OrgId = adminUserInfo.CurrentOrgId
		queueConfig.Qhsj = 10
		queueConfig.Jzdcbbcs = 3
		queueConfig.Jzbbsy = 1
		queueConfig.Jzjhyc = 0
		queueConfig.Sjdcbbcs = 3
		queueConfig.Sjbbsy = 0
		queueConfig.Sjjhyc = 0
		queueConfig.Txxqyxs = 0
		queueConfig.Txglsyxs = 0
		queueConfig.CreateTime = time.Now().Unix()
		queueConfig.UpdateTime = time.Now().Unix()
	}

	qhsj, _ := c.GetInt64("qhsj", 0)
	if qhsj > 0 {
		queueConfig.Qhsj = qhsj
	}

	jzdcbbcs, _ := c.GetInt64("jzdcbbcs", 0)
	if jzdcbbcs > 0 {
		queueConfig.Jzdcbbcs = jzdcbbcs
	}

	jzbbsy, _ := c.GetInt64("jzbbsy", 0)
	if jzbbsy > 0 {
		queueConfig.Jzbbsy = jzbbsy
	}

	jzjhyc, _ := c.GetInt64("jzjhyc", 0)
	queueConfig.Jzjhyc = jzjhyc

	sjdcbbcs, _ := c.GetInt64("sjdcbbcs", 0)
	if sjdcbbcs > 0 {
		queueConfig.Sjdcbbcs = sjdcbbcs
	}

	sjbbsy, _ := c.GetInt64("sjbbsy", 0)
	if sjbbsy > 0 {
		queueConfig.Sjbbsy = sjbbsy
	}

	sjjhyc, _ := c.GetInt64("sjjhyc", 0)
	queueConfig.Sjjhyc = sjjhyc

	txxqyxs, _ := c.GetInt64("txxqyxs", 0)
	queueConfig.Txxqyxs = txxqyxs

	txglsyxs, _ := c.GetInt64("txglsyxs", 0)
	queueConfig.Txglsyxs = txglsyxs

	queueConfig.UpdateTime = time.Now().Unix()

	service.UpDateQueueCallInfo(queueConfig)

	c.ServeSuccessJSON(map[string]interface{}{
		"queue_config": queueConfig,
	})
}

func (c *DialysisApiController) PostPrescription() {
	patient, _ := c.GetInt64("patient_id", 0)
	recordDateStr := c.GetString("record_date")

	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
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	mode_id, _ := c.GetInt64("mode_id", 0)
	dialysis_duration, _ := c.GetFloat("dialysis_duration", 0)
	dialyzer, _ := c.GetInt64("dialyzer", 0)
	dialyzerPerfusionApparatus := c.GetString("dialyzer_perfusion_apparatus")
	perfusion_apparatus, _ := c.GetInt64("perfusion_apparatus", 0)
	blood_flow_volume, _ := c.GetFloat("blood_flow_volume", 0)
	dewater_amount, _ := c.GetFloat("dewater_amount", 0)
	displace_liqui, _ := c.GetFloat("displace_liqui", 0)
	replacement_way, _ := c.GetInt64("replacement_way", 0)
	anticoagulant, _ := c.GetInt64("anticoagulant", 0)
	anticoagulant_shouji, _ := c.GetFloat("anticoagulant_shouji", 0)
	anticoagulant_weichi, _ := c.GetFloat("anticoagulant_weichi", 0)
	anticoagulant_zongliang, _ := c.GetFloat("anticoagulant_zongliang", 0)
	anticoagulant_gaimingcheng := c.GetString("anticoagulant_gaimingcheng")
	anticoagulant_gaijiliang := c.GetString("anticoagulant_gaijiliang")
	kalium, _ := c.GetFloat("kalium", 0)
	sodium, _ := c.GetFloat("sodium", 0)
	replacement_total, _ := c.GetFloat("replacement_total", 0)

	calcium, _ := c.GetFloat("calcium", 0)
	bicarbonate, _ := c.GetFloat("bicarbonate", 0)
	glucose, _ := c.GetFloat("glucose", 0)
	// dry_weight, _ := c.GetFloat("dry_weight", 0)
	dialysate_flow, _ := c.GetFloat("dialysate_flow", 0)
	dialysate_temperature, _ := c.GetFloat("dialysate_temperature", 0)
	conductivity, _ := c.GetFloat("conductivity", 0)
	remark := c.GetString("remark")
	dialysisDurationHour, _ := c.GetInt64("dialysis_duration_hour", 0)
	dialysisDurationMinute, _ := c.GetInt64("dialysis_duration_minute", 0)
	targetUltrafiltration, _ := c.GetFloat("target_ultrafiltration", 0)
	dialysateFormulation, _ := c.GetInt64("dialysate_formulation", 0)
	body_fluid, _ := c.GetInt64("body_fluid", 0)
	special_medicine, _ := c.GetInt64("special_medicine", 0)
	special_medicine_other := c.GetString("special_medicine_other")
	displace_liqui_part, _ := c.GetInt64("displace_liqui_part", 0)
	displace_liqui_value, _ := c.GetFloat("displace_liqui_value", 0)
	blood_access, _ := c.GetInt64("blood_access", 0)
	ultrafiltration, _ := c.GetFloat("ultrafiltration", 0)
	body_fluid_other := c.GetString("body_fluid_other")
	target_ktv, _ := c.GetFloat("target_ktv", 0)

	niprocart, _ := c.GetInt64("niprocart", 0)
	jms, _ := c.GetInt64("jms", 0)
	fistula_needle_set, _ := c.GetInt64("fistula_needle_set", 0)
	fistula_needle_set_16, _ := c.GetInt64("fistula_needle_set_16", 0)
	hemoperfusion, _ := c.GetInt64("hemoperfusion", 0)
	dialyser_sterilised, _ := c.GetInt64("dialyser_sterilised", 0)
	filtryzer, _ := c.GetInt64("filtryzer", 0)

	dialyzers, _ := c.GetInt64("dialyzers", 0)
	injector, _ := c.GetInt64("injector", 0)
	bloodlines, _ := c.GetInt64("bloodlines", 0)
	tubing_hemodialysis, _ := c.GetInt64("tubing_hemodialysis", 0)
	safe_package, _ := c.GetInt64("package", 0)
	a_liquid, _ := c.GetInt64("a_liquid", 0)
	preImpules, _ := c.GetFloat("pre_impulse", 0)
	fmt.Println("", preImpules)

	anticoagulant_stop_time_hour, _ := c.GetInt64("anticoagulant_stop_time_hour", 0)
	anticoagulant_stop_time_min, _ := c.GetInt64("anticoagulant_stop_time_min", 0)

	//heparin_sodium := c.GetString("heparin_sodium")
	//fmt.Println("肝素钠",heparin_sodium)
	//nucleoprotamine := c.GetString("nucleoprotamine")
	//fmt.Println("鱼精蛋白",nucleoprotamine)
	//push_the_protamine := c.GetString("push_the_protamine")
	//fmt.Println("下机前推注鱼精蛋白",push_the_protamine)
	// var prescription_doctor int64
	blood := c.GetString("blood")
	dialysis_dialyszers := c.GetString("dialysis_dialyszers")

	dialysis_irrigation := c.GetString("dialysis_irrigation")
	antioxidant_commodity_name := c.GetString("antioxidant_commodity_name")
	displace_speed := c.GetString("displace_speed")
	illness, _ := c.GetInt64("illness")
	amylaceum := c.GetString("amylaceum")
	single_time := c.GetString("single_time")
	single_water := c.GetString("single_water")
	replacement_flow := c.GetString("replacement_flow")
	plasma_separator := c.GetString("plasma_separator")
	bilirubin_adsorption_column := c.GetString("bilirubin_adsorption_column")
	oxygen_uptake, _ := c.GetInt64("oxygen_uptake")
	oxygen_flow := c.GetString("oxygen_flow")
	oxygen_time := c.GetString("oxygen_time")

	hemodialysis_pipelines := c.GetString("hemodialysis_pipelines")
	hemodialysis_pipelines_count, _ := c.GetFloat("hemodialysis_pipelines_count", 0)

	puncture_needle := c.GetString("puncture_needle")
	puncture_needle_count, _ := c.GetFloat("puncture_needle_count", 0)

	epo := c.GetString("epo")
	epo_count, _ := c.GetFloat("epo_count", 0)
	max_ultrafiltration_rate, _ := c.GetFloat("max_ultrafiltration_rate")
	admin_user_id, _ := c.GetInt64("admin_user_id")
	is_water, _ := c.GetInt64("is_water")
	drhy_water := c.GetString("drhy_water")
	dry_water_hour := c.GetString("dry_water_hour")
	water_machine := c.GetString("water_machine")
	add_amount, _ := c.GetFloat("add_amount")
	reduce_amount, _ := c.GetFloat("reduce_amount")
	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
	//template, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)

	//if template.TemplateId == 2 || template.TemplateId == 6 {
	//	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
	//		}
	//	}
	//}

	prescription := models.DialysisPrescription{
		UserOrgId:                 adminUserInfo.CurrentOrgId,
		PatientId:                 patient,
		RecordDate:                recordDate.Unix(),
		ModeId:                    mode_id,
		DialysisDuration:          dialysis_duration,
		Dialyzer:                  dialyzer,
		ReplacementTotal:          replacement_total,
		PerfusionApparatus:        perfusion_apparatus,
		BloodFlowVolume:           blood_flow_volume,
		DewaterAmount:             dewater_amount,
		DisplaceLiqui:             displace_liqui,
		ReplacementWay:            replacement_way,
		Anticoagulant:             anticoagulant,
		AnticoagulantShouji:       anticoagulant_shouji,
		AnticoagulantWeichi:       anticoagulant_weichi,
		AnticoagulantZongliang:    anticoagulant_zongliang,
		AnticoagulantGaimingcheng: anticoagulant_gaimingcheng,
		AnticoagulantGaijiliang:   anticoagulant_gaijiliang,
		Kalium:                    kalium,
		Sodium:                    sodium,
		Calcium:                   calcium,
		Bicarbonate:               bicarbonate,
		Glucose:                   glucose,
		// DryWeight:                 dry_weight,
		DialysateFlow:              dialysate_flow,
		DialysateTemperature:       dialysate_temperature,
		Conductivity:               conductivity,
		Remark:                     remark,
		Status:                     1,
		CreatedTime:                time.Now().Unix(),
		UpdatedTime:                time.Now().Unix(),
		DialysisDurationMinute:     dialysisDurationMinute,
		DialysisDurationHour:       dialysisDurationHour,
		TargetUltrafiltration:      targetUltrafiltration,
		DialysateFormulation:       dialysateFormulation,
		DialyzerPerfusionApparatus: dialyzerPerfusionApparatus,
		BodyFluid:                  body_fluid,
		SpecialMedicine:            special_medicine,
		SpecialMedicineOther:       special_medicine_other,
		DisplaceLiquiPart:          displace_liqui_part,
		DisplaceLiquiValue:         displace_liqui_value,
		BloodAccess:                blood_access,
		Ultrafiltration:            ultrafiltration,
		BodyFluidOther:             body_fluid_other,
		TargetKtv:                  target_ktv,
		Niprocart:                  niprocart,
		Jms:                        jms,
		FistulaNeedleSet:           fistula_needle_set,
		FistulaNeedleSet16:         fistula_needle_set_16,
		Hemoperfusion:              hemoperfusion,
		DialyserSterilised:         dialyser_sterilised,
		Filtryzer:                  filtryzer,
		Dialyzers:                  dialyzers,
		Injector:                   injector,
		Bloodlines:                 bloodlines,
		TubingHemodialysis:         tubing_hemodialysis,
		Package:                    safe_package,
		ALiquid:                    a_liquid,
		PreImpulse:                 preImpules,
		AnticoagulantStopTimeHour:  anticoagulant_stop_time_hour,
		AnticoagulantStopTimeMin:   anticoagulant_stop_time_min,
		Blood:                      blood,
		DialysisDialyszers:         dialysis_dialyszers,
		DialysisIrrigation:         dialysis_irrigation,
		AntioxidantCommodityName:   antioxidant_commodity_name,
		DisplaceSpeed:              displace_speed,
		Illness:                    illness,
		Amylaceum:                  amylaceum,
		SingleTime:                 single_time,
		SingleWater:                single_water,
		ReplacementFlow:            replacement_flow,
		PlasmaSeparator:            plasma_separator,
		BilirubinAdsorptionColumn:  bilirubin_adsorption_column,
		OxygenFlow:                 oxygen_flow,
		OxygenUptake:               oxygen_uptake,
		OxygenTime:                 oxygen_time,
		HemodialysisPipelines:      hemodialysis_pipelines,
		HemodialysisPipelinesCount: hemodialysis_pipelines_count,
		PunctureNeedle:             puncture_needle,
		PunctureNeedleCount:        puncture_needle_count,
		Epo:                        epo,
		EpoCount:                   epo_count,
		MaxUltrafiltrationRate:     max_ultrafiltration_rate,
		AdminUserId:                admin_user_id,
		IsWater:                    is_water,
		DrhyWater:                  drhy_water,
		DryWaterHour:               dry_water_hour,
		WaterMachine:               water_machine,
		AddAmount:                  add_amount,
		ReduceAmount:               reduce_amount,
	}

	if appRole.UserType == 2 || appRole.UserType == 1 {
		prescription.PrescriptionDoctor = appRole.AdminUserId
	}

	_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	if dialysisPrescription.ID == 0 { //新增
		if mode_id > 0 {
			service.ModifyScheduleMode(mode_id, patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
		}

		prescription.Creater = adminUserInfo.AdminUser.Id

		//针对河间咸得
		if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {

			if prescription.ModeId != 2 && prescription.ModeId != 5 && prescription.ModeId != 12 {

				prescription.DisplaceLiquiPart = 0
				prescription.DisplaceLiquiValue = 0
			}
		}

		err := service.AddSigleRecord(&prescription)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		keyTwo := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":prescriptions_list_all"
		redis.Set(keyTwo, "", time.Second)
		keyThree := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyThree, "", time.Second)
		defer redis.Close()
		if err == nil {
			updateErr := service.UpdateScheduleModeId(patient, adminUserInfo.CurrentOrgId, recordDate.Unix(), mode_id)
			if updateErr != nil {
				utils.ErrorLog("%v", updateErr)
			}

			c.ServeSuccessJSON(map[string]interface{}{
				"prescription": &prescription,
			})

		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}

	} else { //修改
		if mode_id > 0 {
			service.ModifyScheduleMode(mode_id, patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
		}

		//template, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)
		//if template.TemplateId == 1 {
		//	if dialysisPrescription.Creater > 0 && dialysisPrescription.Creater != adminUserInfo.AdminUser.Id {
		//		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 appRole.UserType == 2 || appRole.UserType == 1 {
			prescription_doctor := adminUserInfo.AdminUser.Id
			prescription.PrescriptionDoctor = prescription_doctor

		}

		if dialysisPrescription.Creater == 0 { //体重称
			prescription.Creater = adminUserInfo.AdminUser.Id

		} else {
			prescription.Creater = dialysisPrescription.Creater
		}

		prescription.CreatedTime = dialysisPrescription.CreatedTime
		prescription.UpdatedTime = time.Now().Unix()
		prescription.Modifier = adminUserInfo.AdminUser.Id
		prescription.ID = dialysisPrescription.ID

		updateErr := service.UpDateDialysisPrescription(&prescription)

		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
		redis := service.RedisClient()
		defer redis.Close()
		//清空key 值
		redis.Set(key, "", time.Second)

		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":prescriptions_list_all"
		redis.Set(keyOne, "", time.Second)
		keyThree := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyThree, "", time.Second)
		if updateErr == nil {
			updateErr := service.UpdateScheduleModeId(patient, adminUserInfo.CurrentOrgId, recordDate.Unix(), mode_id)
			if updateErr != nil {
				utils.ErrorLog("%v", updateErr)
			}
			c.ServeSuccessJSON(map[string]interface{}{
				"prescription": &prescription,
			})

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

	}

}
func (c *DialysisApiController) PostSoulution() {
	patient, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")

	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
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	mode_id, _ := c.GetInt64("mode_id", 0)
	dialysis_duration, _ := c.GetFloat("dialysis_duration", 0)
	dialyzer, _ := c.GetInt64("dialyzer", 0)
	perfusion_apparatus, _ := c.GetInt64("perfusion_apparatus", 0)
	blood_flow_volume, _ := c.GetFloat("blood_flow_volume", 0)
	replacement_total, _ := c.GetFloat("replacement_total", 0)
	dialyzerPerfusionApparatus := c.GetString("dialyzer_perfusion_apparatus")

	dewater_amount, _ := c.GetFloat("dewater_amount", 0)
	displace_liqui, _ := c.GetFloat("displace_liqui", 0)
	replacement_way, _ := c.GetInt64("replacement_way", 0)
	anticoagulant, _ := c.GetInt64("anticoagulant", 0)
	anticoagulant_shouji, _ := c.GetFloat("anticoagulant_shouji", 0)
	anticoagulant_weichi, _ := c.GetFloat("anticoagulant_weichi", 0)
	anticoagulant_zongliang, _ := c.GetFloat("anticoagulant_zongliang", 0)
	anticoagulant_gaimingcheng := c.GetString("anticoagulant_gaimingcheng")
	anticoagulant_gaijiliang := c.GetString("anticoagulant_gaijiliang")
	kalium, _ := c.GetFloat("kalium", 0)
	sodium, _ := c.GetFloat("sodium", 0)
	calcium, _ := c.GetFloat("calcium", 0)
	bicarbonate, _ := c.GetFloat("bicarbonate", 0)
	glucose, _ := c.GetFloat("glucose", 0)
	// dry_weight, _ := c.GetFloat("dry_weight", 0)
	dialysate_flow, _ := c.GetFloat("dialysate_flow", 0)
	dialysate_temperature, _ := c.GetFloat("dialysate_temperature", 0)
	conductivity, _ := c.GetFloat("conductivity", 0)
	remark := c.GetString("remark")
	dialysisDurationHour, _ := c.GetInt64("dialysis_duration_hour", 0)
	dialysisDurationMinute, _ := c.GetInt64("dialysis_duration_minute", 0)
	targetUltrafiltration, _ := c.GetFloat("target_ultrafiltration", 0)
	dialysateFormulation, _ := c.GetInt64("dialysate_formulation", 0)
	body_fluid, _ := c.GetInt64("body_fluid", 0)
	special_medicine, _ := c.GetInt64("special_medicine", 0)
	special_medicine_other := c.GetString("special_medicine_other")
	displace_liqui_part, _ := c.GetInt64("displace_liqui_part", 0)
	displace_liqui_value, _ := c.GetFloat("displace_liqui_value", 0)
	blood_access, _ := c.GetInt64("blood_access", 0)
	ultrafiltration, _ := c.GetFloat("ultrafiltration", 0)
	body_fluid_other := c.GetString("body_fluid_other")
	target_ktv, _ := c.GetFloat("target_ktv", 0)

	niprocart, _ := c.GetInt64("niprocart", 0)
	jms, _ := c.GetInt64("jms", 0)
	fistula_needle_set, _ := c.GetInt64("fistula_needle_set", 0)
	fistula_needle_set_16, _ := c.GetInt64("fistula_needle_set_16", 0)
	hemoperfusion, _ := c.GetInt64("hemoperfusion", 0)
	dialyser_sterilised, _ := c.GetInt64("dialyser_sterilised", 0)
	filtryzer, _ := c.GetInt64("filtryzer", 0)

	dialyzers, _ := c.GetInt64("dialyzers", 0)
	injector, _ := c.GetInt64("injector", 0)
	bloodlines, _ := c.GetInt64("bloodlines", 0)
	tubing_hemodialysis, _ := c.GetInt64("tubing_hemodialysis", 0)
	safe_package, _ := c.GetInt64("package", 0)
	a_liquid, _ := c.GetInt64("a_liquid", 0)

	anticoagulant_stop_time_hour, _ := c.GetInt64("anticoagulant_stop_time_hour", 0)
	anticoagulant_stop_time_min, _ := c.GetInt64("anticoagulant_stop_time_min", 0)
	blood := c.GetString("blood")
	dialysis_dialyszers := c.GetString("dialysis_dialyszers")
	dialysis_irrigation := c.GetString("dialysis_irrigation")
	antioxidant_commodity_name := c.GetString("antioxidant_commodity_name")
	displace_speed := c.GetString("displace_speed")
	illness, _ := c.GetInt64("illness")
	amylaceum := c.GetString("amylaceum")
	single_time := c.GetString("single_time")
	single_water := c.GetString("single_water")
	replacement_flow := c.GetString("replacement_flow")
	plasma_separator := c.GetString("plasma_separator")
	bilirubin_adsorption_column := c.GetString("bilirubin_adsorption_column")
	oxygen_uptake, _ := c.GetInt64("oxygen_uptake")
	oxygen_flow := c.GetString("oxygen_flow")
	oxygen_time := c.GetString("oxygen_time")

	hemodialysis_pipelines := c.GetString("hemodialysis_pipelines")
	hemodialysis_pipelines_count, _ := c.GetFloat("hemodialysis_pipelines_count", 0)

	puncture_needle := c.GetString("puncture_needle")
	puncture_needle_count, _ := c.GetFloat("puncture_needle_count", 0)

	epo := c.GetString("epo")
	epo_count, _ := c.GetFloat("epo_count", 0)
	max_ultrafiltration_rate, _ := c.GetFloat("max_ultrafiltration_rate")
	impulse := c.GetString("impulse")
	preImpules, parseDateErr := strconv.ParseFloat(impulse, 64)
	admin_user_id, _ := c.GetInt64("admin_user_id")
	fmt.Println("", preImpules)
	is_water, _ := c.GetInt64("is_water")
	dry_water_hour := c.GetString("dry_water_hour")
	drhy_water := c.GetString("drhy_water")
	water_machine := c.GetString("water_machine")
	add_amount, _ := c.GetFloat("add_amount")
	reduce_amount, _ := c.GetFloat("reduce_amount")
	var prescription_doctor int64
	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentAppId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)

	if appRole.UserType == 2 || appRole.UserType == 1 {
		prescription_doctor = appRole.AdminUserId
	}

	if mode_id > 0 {
		service.ModifyScheduleMode(mode_id, patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	}

	//template, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)
	//
	//if template.TemplateId == 2 || template.TemplateId == 6 {
	//	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
	//		}
	//	}
	//}

	prescription := models.DialysisPrescription{
		UserOrgId:                 adminUserInfo.CurrentOrgId,
		PatientId:                 patient,
		RecordDate:                recordDate.Unix(),
		ModeId:                    mode_id,
		DialysisDuration:          dialysis_duration,
		Dialyzer:                  dialyzer,
		PerfusionApparatus:        perfusion_apparatus,
		BloodFlowVolume:           blood_flow_volume,
		DewaterAmount:             dewater_amount,
		DisplaceLiqui:             displace_liqui,
		ReplacementWay:            replacement_way,
		Anticoagulant:             anticoagulant,
		AnticoagulantShouji:       anticoagulant_shouji,
		AnticoagulantWeichi:       anticoagulant_weichi,
		AnticoagulantZongliang:    anticoagulant_zongliang,
		AnticoagulantGaimingcheng: anticoagulant_gaimingcheng,
		AnticoagulantGaijiliang:   anticoagulant_gaijiliang,
		Kalium:                    kalium,
		Sodium:                    sodium,
		Calcium:                   calcium,
		Bicarbonate:               bicarbonate,
		Glucose:                   glucose,
		// DryWeight:                 dry_weight,
		DialysateFlow:              dialysate_flow,
		DialysateTemperature:       dialysate_temperature,
		Conductivity:               conductivity,
		Remark:                     remark,
		PrescriptionDoctor:         prescription_doctor,
		Status:                     1,
		CreatedTime:                time.Now().Unix(),
		UpdatedTime:                time.Now().Unix(),
		DialysisDurationMinute:     dialysisDurationMinute,
		DialysisDurationHour:       dialysisDurationHour,
		TargetUltrafiltration:      targetUltrafiltration,
		DialysateFormulation:       dialysateFormulation,
		ReplacementTotal:           replacement_total,
		DialyzerPerfusionApparatus: dialyzerPerfusionApparatus,
		BodyFluid:                  body_fluid,
		SpecialMedicine:            special_medicine,
		SpecialMedicineOther:       special_medicine_other,
		DisplaceLiquiPart:          displace_liqui_part,
		DisplaceLiquiValue:         displace_liqui_value,
		BloodAccess:                blood_access,
		Ultrafiltration:            ultrafiltration,
		BodyFluidOther:             body_fluid_other,
		TargetKtv:                  target_ktv,
		Niprocart:                  niprocart,
		Jms:                        jms,
		FistulaNeedleSet:           fistula_needle_set,
		FistulaNeedleSet16:         fistula_needle_set_16,
		Hemoperfusion:              hemoperfusion,
		DialyserSterilised:         dialyser_sterilised,
		Filtryzer:                  filtryzer,
		Dialyzers:                  dialyzers,
		Injector:                   injector,
		Bloodlines:                 bloodlines,
		TubingHemodialysis:         tubing_hemodialysis,
		Package:                    safe_package,
		ALiquid:                    a_liquid,

		AnticoagulantStopTimeHour:  anticoagulant_stop_time_hour,
		AnticoagulantStopTimeMin:   anticoagulant_stop_time_min,
		Blood:                      blood,
		DialysisIrrigation:         dialysis_irrigation,
		DialysisDialyszers:         dialysis_dialyszers,
		AntioxidantCommodityName:   antioxidant_commodity_name,
		DisplaceSpeed:              displace_speed,
		Illness:                    illness,
		Amylaceum:                  amylaceum,
		SingleTime:                 single_time,
		SingleWater:                single_water,
		ReplacementFlow:            replacement_flow,
		PlasmaSeparator:            plasma_separator,
		BilirubinAdsorptionColumn:  bilirubin_adsorption_column,
		OxygenTime:                 oxygen_time,
		OxygenUptake:               oxygen_uptake,
		OxygenFlow:                 oxygen_flow,
		HemodialysisPipelines:      hemodialysis_pipelines,
		HemodialysisPipelinesCount: hemodialysis_pipelines_count,
		PunctureNeedle:             puncture_needle,
		PunctureNeedleCount:        puncture_needle_count,
		Epo:                        epo,
		EpoCount:                   epo_count,
		MaxUltrafiltrationRate:     max_ultrafiltration_rate,
		PreImpulse:                 preImpules,
		AdminUserId:                admin_user_id,
		IsWater:                    is_water,
		DryWaterHour:               dry_water_hour,
		DrhyWater:                  drhy_water,
		WaterMachine:               water_machine,
		AddAmount:                  add_amount,
		ReduceAmount:               reduce_amount,
	}

	//查询最近透析准备表里是否存在 透析器 灌流器

	//splitStr := strings.Split(dialysis_dialyszers, ",")
	//
	//splitIrrigation := strings.Split(dialysis_irrigation, ",")
	//
	//mation, _ := service.GetGoodInfoMation(adminUserInfo.CurrentOrgId)
	//if len(mation)>0{
	//  for _, item := range splitStr {
	//    for _,it := range mation{
	//      if(item == it.SpecificationName){
	//
	//        //查询最近一次的透析器
	//        _, errcode := service.GetDialysisBeforePrepare(it.GoodTypeId, it.ID, adminUserInfo.CurrentOrgId,patient)
	//
	//        if errcode == gorm.ErrRecordNotFound{
	//          //插入数据
	//          prepare := models.DialysisBeforePrepare{
	//            UserOrgId:  adminUserInfo.CurrentOrgId,
	//            PatientId:  patient,
	//            RecordDate: recordDate.Unix(),
	//            GoodTypeId: it.GoodTypeId,
	//            GoodId:     it.ID,
	//            Count:      1,
	//            Ctime:      time.Now().Unix(),
	//            Creater:    adminUserInfo.AdminUser.Id,
	//            Status:1,
	//
	//          }
	//          errcode := service.CreateDialysisBeforePrepareOne(&prepare)
	//          fmt.Println("",errcode)
	//        }
	//      }
	//    }
	//
	//  }
	//
	//  for _, item := range splitIrrigation {
	//    for _,it := range mation{
	//      if(item == it.SpecificationName){
	//        //查询最近一次的透析器
	//        _, errcode := service.GetDialysisBeforePrepare(it.GoodTypeId, it.ID, adminUserInfo.CurrentOrgId,patient)
	//        if errcode == gorm.ErrRecordNotFound{
	//          //插入数据
	//          prepare := models.DialysisBeforePrepare{
	//            UserOrgId:  adminUserInfo.CurrentOrgId,
	//            PatientId:  patient,
	//            RecordDate: recordDate.Unix(),
	//            GoodTypeId: it.GoodTypeId,
	//            GoodId:     it.ID,
	//            Count:      1,
	//            Ctime:      time.Now().Unix(),
	//            Creater:    adminUserInfo.AdminUser.Id,
	//            Status:1,
	//
	//          }
	//          errcode := service.CreateDialysisBeforePrepareOne(&prepare)
	//          fmt.Println(errcode)
	//        }
	//      }
	//    }
	//  }
	//}

	_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	if dialysisPrescription.ID == 0 { //新增
		if appRole.UserType == 2 || appRole.UserType == 1 {
			prescription.PrescriptionDoctor = adminUserInfo.AdminUser.Id
		}

		prescription.Creater = adminUserInfo.AdminUser.Id

	} else { //修改

		//template, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)
		//if template.TemplateId == 1 {
		//	if dialysisPrescription.Creater != adminUserInfo.AdminUser.Id && dialysisPrescription.Creater != 0 {
		//		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 appRole.UserType == 2 || appRole.UserType == 1 {
			prescription_doctor := adminUserInfo.AdminUser.Id
			prescription.PrescriptionDoctor = prescription_doctor
		} else {
			prescription.PrescriptionDoctor = dialysisPrescription.PrescriptionDoctor
		}

		if dialysisPrescription.Creater == 0 {
			prescription.Creater = adminUserInfo.AdminUser.Id
		} else {
			prescription.Creater = dialysisPrescription.Creater
		}

		prescription.CreatedTime = dialysisPrescription.CreatedTime
		prescription.UpdatedTime = time.Now().Unix()
		prescription.Modifier = adminUserInfo.AdminUser.Id

		prescription.ID = dialysisPrescription.ID

	}

	solution := models.DialysisSolution{
		RegistrarsId:              adminUserInfo.AdminUser.Id,
		UserOrgId:                 adminUserInfo.CurrentOrgId,
		Doctor:                    prescription_doctor,
		PatientId:                 patient,
		ModeId:                    mode_id,
		DialysisDuration:          dialysis_duration,
		PerfusionApparatus:        perfusion_apparatus,
		BloodFlowVolume:           blood_flow_volume,
		Dewater:                   dewater_amount,
		DisplaceLiqui:             displace_liqui,
		ReplacementWay:            replacement_way,
		Anticoagulant:             anticoagulant,
		AnticoagulantShouji:       anticoagulant_shouji,
		AnticoagulantWeichi:       anticoagulant_weichi,
		AnticoagulantZongliang:    anticoagulant_zongliang,
		AnticoagulantGaimingcheng: anticoagulant_gaimingcheng,
		AnticoagulantGaijiliang:   anticoagulant_gaijiliang,
		Kalium:                    kalium,
		Sodium:                    sodium,
		Calcium:                   calcium,
		Bicarbonate:               bicarbonate,
		Glucose:                   glucose,
		// DryWeight:                 dry_weight,
		DialysateFlow:              dialysate_flow,
		DialysateTemperature:       dialysate_temperature,
		Conductivity:               conductivity,
		Remark:                     remark,
		Status:                     1,
		CreatedTime:                time.Now().Unix(),
		UpdatedTime:                time.Now().Unix(),
		DialysisDurationMinute:     dialysisDurationMinute,
		DialysisDurationHour:       dialysisDurationHour,
		TargetUltrafiltration:      targetUltrafiltration,
		DialysateFormulation:       dialysateFormulation,
		DialyzerPerfusionApparatus: dialyzerPerfusionApparatus,
		BodyFluid:                  body_fluid,
		SpecialMedicine:            special_medicine,
		SpecialMedicineOther:       special_medicine_other,
		DisplaceLiquiPart:          displace_liqui_part,
		DisplaceLiquiValue:         displace_liqui_value,
		BloodAccess:                blood_access,
		Ultrafiltration:            ultrafiltration,
		BodyFluidOther:             body_fluid_other,
		ReplacementTotal:           replacement_total,
		TargetKtv:                  target_ktv,
		DialysisIrrigation:         dialysis_irrigation,
		DialysisDialyszers:         dialysis_dialyszers,
		HemodialysisPipelines:      hemodialysis_pipelines,
		HemodialysisPipelinesCount: hemodialysis_pipelines_count,
		PunctureNeedle:             puncture_needle,
		PunctureNeedleCount:        puncture_needle_count,
		Epo:                        epo,
		EpoCount:                   epo_count,
		MaxUltrafiltrationRate:     max_ultrafiltration_rate,
		OxygenUptake:               oxygen_uptake,
		OxygenFlow:                 oxygen_flow,
		OxygenTime:                 oxygen_time,
		PreImpulse:                 preImpules,
		SolutionStatus:             1,
	}

	//针对河间咸得
	if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {

		if prescription.ModeId != 2 && prescription.ModeId != 5 && prescription.ModeId != 12 {

			prescription.DisplaceLiquiPart = 0
			prescription.DisplaceLiquiValue = 0
		}
	}

	if adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10090 || adminUserInfo.CurrentOrgId == 3877 {

		if solution.ModeId != 2 && solution.ModeId != 5 && solution.ModeId != 12 {

			solution.DisplaceLiquiPart = 0
			solution.DisplaceLiquiValue = 0
		}
	}

	err := service.SavePrescriptionAndCreateSolution(&solution, &prescription)

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

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

	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
	redis := service.RedisClient()

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

	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
	//清空key 值
	redis.Set(keyOne, "", time.Second)

	keyTwo := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":prescriptions_list_all"
	redis.Set(keyTwo, "", time.Second)

	keyThree := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
	redis.Set(keyThree, "", time.Second)
	defer redis.Close()
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"solution":     &solution,
			"prescription": &prescription,
		})
	} else {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
	}

}
func (c *DialysisApiController) PostDouleCheck() {

	id, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")
	checkTimeStr := c.GetString("check_time")
	firstCheckTimeStr := c.GetString("first_check_time")
	creater, _ := c.GetInt64("creater", 0)
	modifier, _ := c.GetInt64("modifier", 0)

	dialysis_item_check, _ := c.GetInt64("dialysis_item_check", 0)
	dialysis_parameter_check, _ := c.GetInt64("dialysis_parameter_check", 0)
	vascular_access_verification, _ := c.GetInt64("vascular_access_verification", 0)
	pipeline_connection_check, _ := c.GetInt64("pipeline_connection_check", 0)
	dialysis_item_desc := c.GetString("dialysis_item_desc")
	dialysis_parameter_desc := c.GetString("dialysis_parameter_desc")
	vascular_access_desc := c.GetString("vascular_access_desc")
	pipeline_connection_desc := c.GetString("pipeline_connection_desc")
	collator, _ := c.GetInt64("collator", 0)
	employee_number := c.GetString("employee_number")
	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
	}

	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	var checkDate int64

	if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10340 {
		list, _ := service.GetRoleList(adminUserInfo.CurrentOrgId, modifier)

		if employee_number != list.JobNumber {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorEmployeeNumber)
			return
		}
	}

	if len(checkTimeStr) == 0 {
		//checkTimeStr = time.Now().Format("2006-01-02 15:04")
		checkDate = 0
	} else {
		checkDateUnix, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", checkTimeStr)
		checkDate = checkDateUnix.Unix()
	}

	var firstCheckTimeDate int64

	if len(firstCheckTimeStr) == 0 {
		//firstCheckTimeStr = time.Now().Format("2006-01-02 15:04")
		firstCheckTimeDate = 0
	} else {
		firstCheckTimeDateUnix, _ := utils.ParseTimeStringToTime("2006-01-02 15:04", firstCheckTimeStr)

		firstCheckTimeDate = firstCheckTimeDateUnix.Unix()

	}

	doubleCheck := models.DoubleCheck{
		UserOrgId:                  adminUserInfo.CurrentOrgId,
		PatientId:                  id,
		DialysisItemCheck:          dialysis_item_check,
		DialysisParameterCheck:     dialysis_parameter_check,
		VascularAccessVerification: vascular_access_verification,
		PipelineConnectionCheck:    pipeline_connection_check,
		DialysisItemDesc:           dialysis_item_desc,
		DialysisParameterDesc:      dialysis_parameter_desc,
		VascularAccessDesc:         vascular_access_desc,
		PipelineConnectionDesc:     pipeline_connection_desc,
		Collator:                   collator,
		Status:                     1,
		CreatedTime:                time.Now().Unix(),
		UpdatedTime:                time.Now().Unix(),
		CheckDate:                  recordDate.Unix(),
		EmployeeNumber:             employee_number,
	}

	_, check := service.FindDoubleCheckByReordDate(id, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	if check.ID == 0 { //新增
		doubleCheck.FirstCheckTime = firstCheckTimeDate
		doubleCheck.CheckTime = checkDate
		doubleCheck.Creater = creater
		doubleCheck.Modifier = modifier

		err := service.AddSigleDoubleCheck(&doubleCheck)
		redis := service.RedisClient()
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":double_check"

		//清空key 值
		redis.Set(key, "", time.Second)
		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)

		redis.Set(keyTwo, "", time.Second)
		keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + ":prescriptions_list_all"
		redis.Set(keyThree, "", time.Second)
		defer redis.Close()
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"doubleCheck": doubleCheck,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}
	} else { //修改
		doubleCheck.FirstCheckTime = firstCheckTimeDate
		doubleCheck.CheckTime = checkDate
		doubleCheck.Creater = creater
		doubleCheck.Modifier = modifier
		doubleCheck.CreatedTime = check.CreatedTime
		doubleCheck.UpdatedTime = time.Now().Unix()
		doubleCheck.ID = check.ID
		redis := service.RedisClient()
		err := service.UpdateDoubleCheck(&doubleCheck)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":double_check"

		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyTwo, "", time.Second)

		//清空key 值
		redis.Set(key, "", time.Second)
		keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + ":prescriptions_list_all"
		redis.Set(keyThree, "", time.Second)
		defer redis.Close()
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"doubleCheck": doubleCheck,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
		}

	}

}
func (c *DialysisApiController) PostReceiveTreatmentAsses() {
	id, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")
	way, _ := c.GetInt64("way", 0)
	consciousness, _ := c.GetInt64("consciousness", 0)
	appetite, _ := c.GetInt64("appetite", 0)
	condition, _ := c.GetInt64("condition", 0)
	posture, _ := c.GetInt64("posture")
	score := c.GetString("score")

	sick_condition, _ := c.GetInt64("sick_condition", 0)
	danger_level, _ := c.GetInt64("danger_level", 0)
	intake, _ := c.GetInt64("intake", 0)
	nutrition, _ := c.GetInt64("nutrition", 0)
	psychological_assessment, _ := c.GetInt64("psychological_assessment", 0)
	psychological_assessment_other := c.GetString("psychological_assessment_other")
	sick_condition_other := c.GetString("sick_condition_other")

	//precaution, _ := c.GetInt64("precaution", 0)
	precaution := c.GetString("precaution")
	precaution_other := c.GetString("precaution_other")
	psychological_other := c.GetString("psychological_other")
	admission_number := c.GetString("admission_number")
	tumble, _ := c.GetInt64("tumble")
	his_department := c.GetString("his_department")
	his_bed := c.GetString("his_bed")
	diacrisis := c.GetString("diacrisis")
	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
	}

	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	_, receiveTreatment := service.FindReceiveTreatmentAssesByReordDate(id, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	receiveTreatmentAsses := models.ReceiveTreatmentAsses{
		UserOrgId:                    adminUserInfo.CurrentOrgId,
		PatientId:                    id,
		RecordDate:                   recordDate.Unix(),
		Way:                          way,
		Consciousness:                consciousness,
		Appetite:                     appetite,
		Condition:                    condition,
		SickCondition:                sick_condition,
		DangerLevel:                  danger_level,
		Intake:                       intake,
		Nutrition:                    nutrition,
		PsychologicalAssessment:      psychological_assessment,
		PsychologicalAssessmentOther: psychological_assessment_other,
		SickConditionOther:           sick_condition_other,
		Posture:                      posture,
		CreatedTime:                  time.Now().Unix(),
		UpdateTime:                   time.Now().Unix(),
		Status:                       1,
		Score:                        score,
		Precaution:                   precaution,
		PrecautionOther:              precaution_other,
		PsychologicalOther:           psychological_other,
		AdmissionNumber:              admission_number,
		Tumble:                       tumble,
		HisDepartment:                his_department,
		HisBed:                       his_bed,
		Diacrisis:                    diacrisis,
	}

	if receiveTreatment.ID == 0 { //新增
		receiveTreatmentAsses.Creater = adminUserInfo.AdminUser.Id
		err := service.AddSigleReceiveTreatmentAssesRecord(&receiveTreatmentAsses)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":receive_treatment_asses"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		defer redis.Close()
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"receiveTreatmentAsses": receiveTreatmentAsses,
			})
		} else {

			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}

	} else { //修改
		//if receiveTreatment.Creater != adminUserInfo.AdminUser.Id {
		//	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
		//	}
		//}

		receiveTreatmentAsses.Creater = receiveTreatment.Creater
		receiveTreatmentAsses.CreatedTime = receiveTreatment.CreatedTime
		receiveTreatmentAsses.UpdateTime = time.Now().Unix()
		receiveTreatmentAsses.Modifier = adminUserInfo.AdminUser.Id
		receiveTreatmentAsses.ID = receiveTreatment.ID
		err := service.UpadateReceiveTreatmentAsses(&receiveTreatmentAsses)
		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":receive_treatment_asses"
		redis := service.RedisClient()
		defer redis.Close()
		redis.Set(keyOne, "", time.Second*60*60*18)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"receiveTreatmentAsses": receiveTreatmentAsses,
			})
		} else {

			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}
	}

}

func (c *DialysisApiController) PostAssessmentAfterDislysis() {

	patient, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")
	fmt.Println(recordDateStr)
	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
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)

	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	// data := make(map[string]interface{}, 0)
	var data models.AssessmentAfterDislysis
	var err error
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &data)
	fmt.Println(err)
	if err != nil {
		c.ErrorLog("数据解析错误：%v", err)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	assessment, _ := service.FindAssessmentAfterDislysisById(adminUserInfo.CurrentOrgId, patient, recordDate.Unix())
	assessment.DialysisOrderId = data.DialysisOrderId
	assessment.Evaluator = adminUserInfo.AdminUser.Id
	assessment.Status = 1
	assessment.WeightAfter = data.WeightAfter
	assessment.WeightLoss = data.WeightLoss
	assessment.Temperature = data.Temperature
	assessment.SystolicBloodPressure = data.SystolicBloodPressure
	assessment.DiastolicBloodPressure = data.DiastolicBloodPressure
	assessment.PulseFrequency = data.PulseFrequency
	assessment.ActualUltrafiltration = data.ActualUltrafiltration
	assessment.ActualDisplacement = data.ActualDisplacement
	assessment.ActualTreatmentHour = data.ActualTreatmentHour
	assessment.ActualTreatmentMinute = data.ActualTreatmentMinute
	assessment.Cruor = data.Cruor
	assessment.SymptomAfterDialysis = data.SymptomAfterDialysis
	assessment.DialysisIntakes = data.DialysisIntakes
	assessment.InternalFistula = data.InternalFistula
	assessment.BloodAccessPartId = data.BloodAccessPartId
	assessment.BloodAccessPartOperaId = data.BloodAccessPartOperaId
	assessment.Catheter = data.Catheter
	assessment.Complication = data.Complication
	assessment.PuncturePointOozingBlood = data.PuncturePointOozingBlood
	assessment.PuncturePointHaematoma = data.PuncturePointHaematoma
	assessment.InternalFistulaTremorAc = data.InternalFistulaTremorAc
	assessment.PatientGose = data.PatientGose
	assessment.InpatientDepartment = data.InpatientDepartment
	assessment.ObservationContent = data.ObservationContent
	assessment.ObservationContentOther = data.ObservationContentOther
	assessment.Remark = data.Remark
	assessment.BreathingRate = data.BreathingRate
	assessment.DialysisProcess = data.DialysisProcess
	assessment.InAdvanceMinute = data.InAdvanceMinute
	assessment.InAdvanceReasonOther = data.InAdvanceReasonOther
	assessment.InAdvanceReason = data.InAdvanceReason
	assessment.HemostasisOpera = data.HemostasisOpera
	assessment.HemostasisMinute = data.HemostasisMinute
	assessment.TremorNoise = data.TremorNoise
	assessment.DisequilibriumSyndrome = data.DisequilibriumSyndrome
	assessment.DisequilibriumSyndromeOption = data.DisequilibriumSyndromeOption
	assessment.ArterialTube = data.ArterialTube
	assessment.IntravenousTube = data.IntravenousTube
	assessment.DialysisIntakesUnit = data.DialysisIntakesUnit
	assessment.Dialyzer = data.Dialyzer
	assessment.IsEat = data.IsEat
	assessment.CvcA = data.CvcA
	assessment.CvcV = data.CvcV
	assessment.Channel = data.Channel
	assessment.ReturnBlood = data.ReturnBlood
	assessment.RehydrationVolume = data.RehydrationVolume
	assessment.DialysisDuring = data.DialysisDuring
	assessment.StrokeVolume = data.StrokeVolume
	assessment.BloodFlow = data.BloodFlow
	assessment.SealingFluidDispose = data.SealingFluidDispose
	assessment.SealingFluidSpecial = data.SealingFluidSpecial
	assessment.DosageOfAnticoagulants = data.DosageOfAnticoagulants
	assessment.SupineSystolicBloodPressure = data.SupineSystolicBloodPressure
	assessment.SettingPressure = data.SettingPressure
	assessment.SupineDiastolicBloodPressure = data.SupineDiastolicBloodPressure
	assessment.DiastolicPressure = data.DiastolicPressure
	assessment.AdditionalWeight = data.AdditionalWeight
	assessment.OtherComplication = data.OtherComplication
	assessment.Ktv = data.Ktv

	assessment.Urr = data.Urr
	assessment.Hypertenison = data.Hypertenison
	assessment.Hypopiesia = data.Hypopiesia
	assessment.LeaveOfficeMethod = data.LeaveOfficeMethod
	assessment.Lapse = data.Lapse
	assessment.Consciousness = data.Consciousness
	assessment.Fallrisk = data.Fallrisk
	assessment.MachineRun = data.MachineRun
	assessment.AfterUrea = data.AfterUrea
	assessment.PipCoagulation = data.PipCoagulation
	assessment.AccumulatedBloodVolume = data.AccumulatedBloodVolume
	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)

	if assessment.ID > 0 {

		if appRole.UserType == 2 || appRole.UserType == 1 {
			assessment.AssessmentDoctor = adminUserInfo.AdminUser.Id
			assessment.AssessmentTime = time.Now().Unix()
		} else {
			if assessment.Creater == 0 {
				assessment.Modifier = adminUserInfo.AdminUser.Id
				assessment.Creater = adminUserInfo.AdminUser.Id
			} else {
				assessment.Modifier = adminUserInfo.AdminUser.Id
			}
		}

		assessment.UpdatedTime = time.Now().Unix()
		err = service.UpdateAssessmentAfterDislysisRecord(&assessment)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_after_dislysis"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_after_dislysis_list_all"
		redis.Set(keyThree, "", time.Second)
		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyTwo, "", time.Second)
		defer redis.Close()
	} else {
		if appRole.UserType == 2 || appRole.UserType == 1 {
			assessment.AssessmentDoctor = adminUserInfo.AdminUser.Id
			assessment.AssessmentTime = time.Now().Unix()
		} else {
			assessment.Creater = adminUserInfo.AdminUser.Id
		}
		assessment.CreatedTime = time.Now().Unix()
		assessment.UpdatedTime = time.Now().Unix()
		assessment.UserOrgId = adminUserInfo.CurrentOrgId
		assessment.PatientId = patient
		assessment.AssessmentDate = recordDate.Unix()

		err = service.AddSigleAssessmentAfterDislysisRecord(&assessment)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_after_dislysis"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)
		keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_after_dislysis_list_all"
		redis.Set(keyThree, "", time.Second)
		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyTwo, "", time.Second)
		defer redis.Close()
	}

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

	c.ServeSuccessJSON(map[string]interface{}{
		"AssessmentAfterDislysis": &assessment,
	})

}

func (c *DialysisApiController) PostAssessmentBeforeDislysis() {
	patient, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")
	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
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	weight_before, _ := c.GetFloat("weight_before", 0)
	dry_weight, _ := c.GetFloat("dry_weight", 0)
	additional_weight, _ := c.GetFloat("additional_weight", 0)
	temperature, _ := c.GetFloat("temperature", 0)
	pulse_frequency, _ := c.GetFloat("pulse_frequency", 0)
	systolic_blood_pressure, _ := c.GetFloat("systolic_blood_pressure", 0)
	diastolic_blood_pressure, _ := c.GetFloat("diastolic_blood_pressure", 0)
	last_post_dialysis := c.GetString("last_post_dialysis")
	dialysis_interphase := c.GetString("dialysis_interphase")
	symptom_before_dialysis := c.GetString("symptom_before_dialysis")
	bloodAccessPartOperaId, _ := c.GetInt64("blood_access_part_opera_id", 0)
	//bloodAccessPartId, _ := c.GetInt64("blood_access_part_id", 0)
	bloodAccessPartId := c.GetString("blood_access_part_id")
	internalFistula := c.GetString("internal_fistula")
	internal_fistula_skin := c.GetString("internal_fistula_skin")
	catheter := c.GetString("catheter")
	catheter_bend, _ := c.GetInt("catheter_bend")
	complication := c.GetString("complication")
	is_hemorrhage, _ := c.GetInt64("is_hemorrhage", 0)
	hemorrhage := c.GetString("hemorrhage")
	hemorrhage_other := c.GetString("hemorrhage_other")
	remark := c.GetString("remark")
	puncture_method := c.GetString("puncture_method")

	dialysis_count := c.GetString("dialysis_count")

	emergency_treatment, _ := c.GetInt64("emergency_treatment", 0)
	emergency_treatment_other := c.GetString("emergency_treatment_other")
	ductus_arantii := c.GetString("ductus_arantii")
	venous_catheterization_part_other := c.GetString("venous_catheterization_part_other")
	venous_catheterization_part, _ := c.GetInt64("venous_catheterization_part", 0)
	venous_catheterization, _ := c.GetInt64("venous_catheterization", 0)
	//puncture_way, _ := c.GetInt64("puncture_way", 0)
	puncture_way := c.GetString("puncture_way")
	blood_access_noise, _ := c.GetInt64("blood_access_noise", 0)
	internal_fistula_other := c.GetString("internal_fistula_other")
	blood_access_internal_fistula := c.GetString("blood_access_internal_fistula")
	breathing_rate := c.GetString("breathing_rate")
	is_infect, _ := c.GetInt64("is_infect", 0)
	exposed, _ := c.GetFloat("exposed", 0)
	skin := c.GetString("skin")
	skin_other := c.GetString("skin_other")
	infect_other := c.GetString("infect_other")
	ductus_arantii_other := c.GetString("ductus_arantii_other")
	machine_type := c.GetString("machine_type")
	puncture_needle := c.GetString("puncture_needle")
	//humor_excessive_symptom, _ := c.GetInt64("humor_excessive_symptom", 0)

	humor_excessive_symptom := c.GetString("humor_excessive_symptom")
	phinholing := c.GetString("pinholing")

	catheter_suture := c.GetString("catheter_suture")
	catheter_suture_other := c.GetString("catheter_suture_other")
	edema := c.GetString("edema")
	urine_volume, _ := c.GetFloat("urine_volume", 0)
	special_treatment := c.GetString("special_treatment")
	catheter_maintenance := c.GetString("catheter_maintenance")
	thrombusType := c.GetString("thromubus_type")
	thrombusInt, _ := strconv.ParseInt(thrombusType, 10, 64)
	thrombus_a := c.GetString("thromubus_a")
	thrombus_av := c.GetString("thrombus_av")
	thrombus_v := c.GetString("thromubus_v")
	dehydration := c.GetString("dehydration")
	pre_dialysis_drugs := c.GetString("pre_dialysis_drugs")
	period, _ := c.GetInt64("period")
	estimated_food_intake := c.GetString("estimated_food_intake")
	blood_pressure_during_dialysis := c.GetString("blood_pressure_during_dialysis")
	urea_befor := c.GetString("urea_befor")
	suction := c.GetString("suction")
	weight_befor_remake := c.GetString("weight_befor_remake")
	height := c.GetString("height")
	age := c.GetString("age")
	his_department := c.GetString("his_department")
	his_bed := c.GetString("his_bed")
	assessmentBeforeDislysis := models.PredialysisEvaluation{
		DialysisCount:                  dialysis_count,
		EmergencyTreatment:             emergency_treatment,
		EmergencyTreatmentOther:        emergency_treatment_other,
		DuctusArantii:                  ductus_arantii,
		VenousCatheterization:          venous_catheterization,
		VenousCatheterizationPart:      venous_catheterization_part,
		VenousCatheterizationPartOther: venous_catheterization_part_other,
		PunctureWay:                    puncture_way,
		BloodAccessInternalFistula:     blood_access_internal_fistula,
		BloodAccessNoise:               blood_access_noise,
		InternalFistulaOther:           internal_fistula_other,
		Evaluator:                      adminUserInfo.AdminUser.Id,
		UserOrgId:                      adminUserInfo.CurrentOrgId,
		PatientId:                      patient,
		AssessmentDate:                 recordDate.Unix(),
		Temperature:                    temperature,
		PulseFrequency:                 pulse_frequency,
		SystolicBloodPressure:          systolic_blood_pressure,
		DiastolicBloodPressure:         diastolic_blood_pressure,
		WeightBefore:                   weight_before,
		DryWeight:                      dry_weight,
		AdditionalWeight:               additional_weight,
		DialysisInterphase:             dialysis_interphase,
		LastPostDialysis:               last_post_dialysis,
		SymptomBeforeDialysis:          symptom_before_dialysis,
		InternalFistula:                internalFistula,
		InternalFistulaSkin:            internal_fistula_skin,
		Catheter:                       catheter,
		CatheterBend:                   catheter_bend,
		Complication:                   complication,
		CreatedTime:                    time.Now().Unix(),
		Status:                         1,
		Remark:                         remark,
		IsHemorrhage:                   is_hemorrhage,
		Hemorrhage:                     hemorrhage,
		HemorrhageOther:                hemorrhage_other,
		BloodAccessPartId:              bloodAccessPartId,
		BloodAccessPartOperaId:         bloodAccessPartOperaId,
		PunctureMethod:                 puncture_method,
		BreathingRate:                  breathing_rate,
		IsInfect:                       is_infect,
		Exposed:                        exposed,
		Skin:                           skin,
		SkinOther:                      skin_other,
		InfectOther:                    infect_other,
		DuctusArantiiOther:             ductus_arantii_other,
		MachineType:                    machine_type,
		PunctureNeedle:                 puncture_needle,
		HumorExcessiveSymptom:          humor_excessive_symptom,
		Phinholing:                     phinholing,
		CatheterSuture:                 catheter_suture,
		CatheterSutureOther:            catheter_suture_other,
		Edema:                          edema,
		UrineVolume:                    urine_volume,
		SpecialTreatment:               special_treatment,
		CatheterMaintenance:            catheter_maintenance,
		ThromubusType:                  thrombusInt,
		ThrombusAv:                     thrombus_av,
		ThromubusA:                     thrombus_a,
		ThromubusV:                     thrombus_v,
		Dehydration:                    dehydration,
		PreDialysisDrugs:               pre_dialysis_drugs,
		Period:                         period,
		EstimatedFoodIntake:            estimated_food_intake,
		BloodPressureDuringDialysis:    blood_pressure_during_dialysis,
		UreaBefor:                      urea_befor,
		Suction:                        suction,
		WeightBeforRemake:              weight_befor_remake,
		Height:                         height,
		Age:                            age,
		HisDepartment:                  his_department,
		HisBed:                         his_bed,
	}

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

	_, evaluation := service.FindPredialysisEvaluationByReordDate(patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	if evaluation.ID == 0 { //新增
		if appRole.UserType == 2 || appRole.UserType == 1 {
			assessmentBeforeDislysis.AssessmentDoctor = adminUserInfo.AdminUser.Id
			assessmentBeforeDislysis.AssessmentTime = time.Now().Unix()
		} else {
			assessmentBeforeDislysis.Creater = adminUserInfo.AdminUser.Id

		}

		err := service.AddSigleAssessmentBeforeDislysisRecord(&assessmentBeforeDislysis)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"
		redis := service.RedisClient()

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

		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_befores_list_all"
		redis.Set(keyOne, "", time.Second)

		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyTwo, "", time.Second)
		defer redis.Close()
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"assessmentBeforeDislysis": &assessmentBeforeDislysis,
			})
		} else {
			//c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}
	} else { //修改
		//if appRole.UserType == 3 {
		//	if evaluation.Creater != adminUserInfo.AdminUser.Id && evaluation.Creater != 0 {
		//		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 appRole.UserType == 2 || appRole.UserType == 1 {
			assessmentBeforeDislysis.AssessmentDoctor = adminUserInfo.AdminUser.Id
			assessmentBeforeDislysis.AssessmentTime = time.Now().Unix()
		} else {
			if evaluation.Creater == 0 {
				assessmentBeforeDislysis.Modifier = adminUserInfo.AdminUser.Id
				assessmentBeforeDislysis.Creater = adminUserInfo.AdminUser.Id
			} else {
				assessmentBeforeDislysis.Modifier = adminUserInfo.AdminUser.Id
			}
		}

		assessmentBeforeDislysis.UpdatedTime = time.Now().Unix()
		assessmentBeforeDislysis.ID = evaluation.ID
		assessmentBeforeDislysis.CreatedTime = evaluation.CreatedTime
		//

		//新增逻辑
		templateInfo, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)

		var dewater_amount float64
		dewater_amount = 0
		if evaluation.DryWeight > 0 {
			dewater_amount = evaluation.WeightBefore - evaluation.DryWeight - evaluation.AdditionalWeight
			if templateInfo.TemplateId == 17 || templateInfo.TemplateId == 22 || templateInfo.TemplateId == 21 || templateInfo.TemplateId == 34 {
				dewater_amount = dewater_amount * 1000
			}
			if dewater_amount <= 0 {
				dewater_amount = 0
			}
		} else {
			dewater_amount = 0
		}
		// 计算透析处方的相关超滤量
		schedual, _ := service.MobileGetSchedualDetailSix(adminUserInfo.CurrentOrgId, patient, recordDate.Unix())
		var lastDialysisPrescribe *models.DialysisPrescription
		var dialysisSolution *models.DialysisSolution
		var dialysisPrescribe *models.DialysisPrescription
		var mode_id int64
		if schedual != nil {
			dialysisPrescribe, _ = service.MobileGetDialysisPrescribeByModeIdSix(adminUserInfo.CurrentOrgId, patient, recordDate.Unix(), schedual.ModeId)
			if dialysisPrescribe == nil {
				dialysisPrescribe, _ = service.MobileGetDialysisPrescribe(adminUserInfo.CurrentOrgId, patient, recordDate.Unix())
			}
			lastDialysisPrescribe, _ = service.MobileGetLastDialysisPrescribeByModeIdSix(adminUserInfo.CurrentOrgId, patient, schedual.ModeId)
			// 获取透析模版
			dialysisSolution, _ = service.MobileGetDialysisSolutionByModeIdSix(adminUserInfo.CurrentOrgId, patient, schedual.ModeId)
			mode_id = schedual.ModeId
		} else {
			//lastDialysisPrescribe, _ = service.MobileGetLastDialysisPrescribe(adminUserInfo.Org.Id, id,schedual.ModeId)
			// 获取透析模版
			dialysisPrescribe, _ = service.MobileGetDialysisPrescribe(adminUserInfo.CurrentOrgId, patient, recordDate.Unix())
			dialysisSolution, _ = service.MobileGetDialysisSolution(adminUserInfo.CurrentOrgId, patient)

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

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

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

			newprescribe.CreatedTime = time.Now().Unix()
			newprescribe.UpdatedTime = time.Now().Unix()
			newprescribe.RecordDate = recordDate.Unix()
			newprescribe.DewaterAmount = dewater_amount
			newprescribe.TargetUltrafiltration = dewater_amount
			newprescribe.Status = 1

			err := service.AddSigleRecord(&newprescribe)
			if err != nil {
				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
			}
		}

		if dialysisPrescribe == nil && dialysisSolution == nil {
			if lastDialysisPrescribe != nil {
				var newprescribe models.DialysisPrescription
				newprescribe.UserOrgId = lastDialysisPrescribe.UserOrgId
				newprescribe.PatientId = lastDialysisPrescribe.PatientId
				newprescribe.Anticoagulant = lastDialysisPrescribe.Anticoagulant
				newprescribe.AnticoagulantShouji = lastDialysisPrescribe.AnticoagulantShouji
				newprescribe.AnticoagulantWeichi = lastDialysisPrescribe.AnticoagulantWeichi
				newprescribe.AnticoagulantZongliang = lastDialysisPrescribe.AnticoagulantZongliang
				newprescribe.AnticoagulantGaimingcheng = lastDialysisPrescribe.AnticoagulantGaimingcheng
				newprescribe.AnticoagulantGaijiliang = lastDialysisPrescribe.AnticoagulantGaijiliang
				newprescribe.ModeId = lastDialysisPrescribe.ModeId
				newprescribe.DialysisDuration = lastDialysisPrescribe.DialysisDuration
				newprescribe.ReplacementWay = lastDialysisPrescribe.ReplacementWay
				newprescribe.HemodialysisMachine = lastDialysisPrescribe.HemodialysisMachine
				newprescribe.BloodFilter = lastDialysisPrescribe.BloodFilter
				newprescribe.PerfusionApparatus = lastDialysisPrescribe.PerfusionApparatus
				newprescribe.BloodFlowVolume = lastDialysisPrescribe.BloodFlowVolume
				newprescribe.DisplaceLiqui = lastDialysisPrescribe.DisplaceLiqui
				newprescribe.Glucose = lastDialysisPrescribe.Glucose
				newprescribe.DialysateFlow = lastDialysisPrescribe.DialysateFlow
				newprescribe.Kalium = lastDialysisPrescribe.Kalium
				newprescribe.Sodium = lastDialysisPrescribe.Sodium
				newprescribe.Calcium = lastDialysisPrescribe.Calcium
				newprescribe.Bicarbonate = lastDialysisPrescribe.Bicarbonate
				newprescribe.DialysateTemperature = lastDialysisPrescribe.DialysateTemperature
				newprescribe.Conductivity = lastDialysisPrescribe.Conductivity
				newprescribe.BodyFluid = lastDialysisPrescribe.BodyFluid
				newprescribe.SpecialMedicine = lastDialysisPrescribe.SpecialMedicine
				newprescribe.SpecialMedicineOther = lastDialysisPrescribe.SpecialMedicineOther
				newprescribe.DisplaceLiquiPart = lastDialysisPrescribe.DisplaceLiquiPart
				newprescribe.DisplaceLiquiValue = lastDialysisPrescribe.DisplaceLiquiValue
				newprescribe.BloodAccess = lastDialysisPrescribe.BloodAccess
				newprescribe.Ultrafiltration = lastDialysisPrescribe.Ultrafiltration
				newprescribe.DialysisDurationHour = lastDialysisPrescribe.DialysisDurationHour
				newprescribe.DialysisDurationMinute = lastDialysisPrescribe.DialysisDurationMinute
				newprescribe.DialysateFormulation = lastDialysisPrescribe.DialysateFormulation
				newprescribe.Dialyzer = lastDialysisPrescribe.Dialyzer
				newprescribe.ReplacementTotal = lastDialysisPrescribe.ReplacementTotal
				newprescribe.DialyzerPerfusionApparatus = lastDialysisPrescribe.DialyzerPerfusionApparatus
				newprescribe.BodyFluidOther = lastDialysisPrescribe.BodyFluidOther
				newprescribe.TargetKtv = lastDialysisPrescribe.TargetKtv
				newprescribe.CreatedTime = time.Now().Unix()
				newprescribe.UpdatedTime = time.Now().Unix()
				newprescribe.RecordDate = recordDate.Unix()
				newprescribe.DewaterAmount = dewater_amount
				newprescribe.TargetUltrafiltration = dewater_amount
				newprescribe.Status = 1

				err := service.AddSigleRecord(&newprescribe)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			} else {
				var newprescribe models.DialysisPrescription
				newprescribe.UserOrgId = adminUserInfo.CurrentOrgId
				newprescribe.PatientId = patient
				newprescribe.ModeId = mode_id
				newprescribe.CreatedTime = time.Now().Unix()
				newprescribe.UpdatedTime = time.Now().Unix()
				newprescribe.RecordDate = recordDate.Unix()
				newprescribe.DewaterAmount = dewater_amount
				newprescribe.TargetUltrafiltration = dewater_amount
				newprescribe.Status = 1

				err := service.AddSigleRecord(&newprescribe)
				if err != nil {
					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
				}
			}
		}

		err := service.UpadatePredialysisEvaluation(&assessmentBeforeDislysis)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)

		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_befores_list_all"
		redis.Set(keyOne, "", time.Second)
		defer redis.Close()
		keyTwo := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyTwo, "", time.Second)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"assessmentBeforeDislysis": &assessmentBeforeDislysis,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}

	}

}
func (c *DialysisApiController) PostTreatmentSummary() {
	patient, _ := c.GetInt64("patient", 0)
	recordDateStr := c.GetString("record_date")

	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
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	mission := c.GetString("mission")
	dialysis_summary := c.GetString("dialysis_summary")
	nursingRecord := c.GetString("nursing_record")
	specialRecord := c.GetString("special_record")
	sj_nurse := adminUserInfo.AdminUser.Id
	zl_nurse := adminUserInfo.AdminUser.Id
	hd_nurse := adminUserInfo.AdminUser.Id
	xj_nurse := adminUserInfo.AdminUser.Id
	zl_doctor := adminUserInfo.AdminUser.Id

	treatmentSummary := models.TreatmentSummary{
		UserOrgId:       adminUserInfo.CurrentOrgId,
		PatientId:       patient,
		AssessmentDate:  recordDate.Unix(),
		Mission:         mission,
		DialysisSummary: dialysis_summary,
		SjNurse:         sj_nurse,
		ZlNurse:         zl_nurse,
		HdNurse:         hd_nurse,
		XjNurse:         xj_nurse,
		ZlDoctor:        zl_doctor,
		Status:          1,
		CreatedTime:     time.Now().Unix(),
		NursingRecord:   nursingRecord,
		SpecialRecord:   specialRecord,
	}

	_, tempTreatmentSummary := service.FindTreatmentSummaryByReordDate(patient, recordDate.Unix(), adminUserInfo.CurrentOrgId)
	if tempTreatmentSummary.ID == 0 { //新增
		treatmentSummary.Creater = adminUserInfo.AdminUser.Id
		err := service.AddSigleSummaryRecord(&treatmentSummary)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":treatment_summary"
		redis := service.RedisClient()
		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":treatment_summarys_list_all"
		redis.Set(keyOne, "", time.Second)
		keyThree := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		redis.Set(keyThree, "", time.Second)
		defer redis.Close()
		//清空key 值
		redis.Set(key, "", time.Second)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"summary": treatmentSummary,
			})
		} else {

			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)

		}

	} else { //修改
		//if tempTreatmentSummary.Creater != adminUserInfo.AdminUser.Id {
		//	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
		//	}
		//}

		treatmentSummary.Creater = tempTreatmentSummary.Creater
		treatmentSummary.CreatedTime = tempTreatmentSummary.CreatedTime
		treatmentSummary.UpdatedTime = time.Now().Unix()
		treatmentSummary.Modifier = adminUserInfo.AdminUser.Id
		treatmentSummary.ID = tempTreatmentSummary.ID
		err := service.UpdateSummeRecord(&treatmentSummary)

		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":treatment_summary"
		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":treatment_summarys_list_all"
		keyThree := "scheduals_" + recordDateStr + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
		//清空key 值
		redis := service.RedisClient()
		redis.Set(key, "", time.Second)
		redis.Set(keyOne, "", time.Second)
		redis.Set(keyThree, "", time.Second)
		defer redis.Close()
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"summary": treatmentSummary,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCommitFail)
		}

	}

}

func (c *DialysisApiController) GetDeviceList() {
	adminUserInfo := c.GetAdminUserInfo()
	device, _ := service.FindAllDeviceInfo(adminUserInfo.CurrentOrgId)

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

func (c *DialysisApiController) GetAllDeviceZone() {
	adminUserInfo := c.GetAdminUserInfo()
	err, zone := service.GetAllDeviceZone(adminUserInfo.CurrentOrgId)
	dics, _, err := service.GetDrugWayDics(adminUserInfo.CurrentOrgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"zone": zone,
			"dics": dics,
		})
	}

}

func (c *DialysisApiController) GetDialysisWatch() {
	page, _ := c.GetInt64("page", 1)
	limit, _ := c.GetInt64("limit", 10)
	schedulType, _ := c.GetInt64("schedul_type", 0)
	startTime, _ := c.GetInt64("schedul_time", 0)
	partitionType, _ := c.GetInt64("partition_type", 0)
	keywords := c.GetString("keywords")
	start_time, _ := c.GetInt64("start_time")
	end_time, _ := c.GetInt64("end_time")
	adminUserInfo := c.GetAdminUserInfo()
	if len(keywords) > 0 {

		dialysisSchedule, err, total := service.GetDialysisWatchByKeyword(adminUserInfo.CurrentOrgId, keywords, schedulType, partitionType, page, limit, start_time/1000, end_time/1000)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"schedule": dialysisSchedule,
				"total":    total,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		}

	} else {
		dialysisSchedule, err, total := service.GetDialysisWatch(adminUserInfo.CurrentOrgId, startTime/1000, schedulType, partitionType, page, limit, start_time/1000, end_time/1000)
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"schedule": dialysisSchedule,
				"total":    total,
			})
		} else {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		}
	}
}

//func (c *DialysisApiController) GetDialysisWatch() {
//	page, _ := c.GetInt64("page", 1)
//	limit, _ := c.GetInt64("limit", 10)
//	schedulType, _ := c.GetInt64("schedul_type", 0)
//	startTime, _ := c.GetInt64("schedul_time", 0)
//	partitionType, _ := c.GetInt64("partition_type", 0)
//	keywords := c.GetString("keywords")
//
//	adminUserInfo := c.GetAdminUserInfo()
//	if len(keywords) > 0 {
//		dialysisSchedule, err, total := service.GetDialysisWatchByKeyword(adminUserInfo.CurrentOrgId, keywords, schedulType, partitionType, page, limit)
//
//		//获取所有床位号
//		numberList, _ := service.GetAllDeviceNumberByListSix(adminUserInfo.CurrentOrgId)
//
//		//获取透析处方
//		prescriptions, _ := service.GetAllPrescriptionByListTwo(adminUserInfo.CurrentOrgId, startTime)
//		//获取透前评估
//		assessmentBefores, _ := service.GetAllAssessmentBeforesByListThree(adminUserInfo.CurrentOrgId, startTime)
//		//获取上机
//		dialysisOrders, _ := service.GetAllDialysisOrdersByListThree(adminUserInfo.CurrentOrgId, startTime)
//		//获取透后
//		AssessmentAfterDislysis, _ := service.GetAllAssessmentAfterDislysisByListThree(adminUserInfo.CurrentOrgId, startTime)
//
//		//获取透后监测
//		monitorlist, _ := service.GetAllMonitorListThree(adminUserInfo.CurrentOrgId, startTime)
//
//		//获取所有的患者
//		patients, _ := service.GetAllPatientListByListSix(adminUserInfo.CurrentOrgId,keywords)
//
//		//获取所有透析模式
//		treatments, _ := service.GetAllTreatModeByList(adminUserInfo.CurrentOrgId)
//
//		for key, scheduals := range dialysisSchedule {
//			// 获取患者信息
//			for _, patient := range patients {
//				if scheduals.PatientId == patient.ID {
//					dialysisSchedule[key].MonitorPatients = patient
//					break
//				}
//			}
//			// 床位信息
//			for _, device := range numberList {
//				if scheduals.BedId == device.ID {
//					dialysisSchedule[key].DeviceNumber = device
//					break
//				}
//			}
//
//			// 医嘱信息
//			for _, prescription := range prescriptions {
//				if scheduals.PatientId == prescription.PatientId {
//					dialysisSchedule[key].Prescription = prescription
//					break
//				}
//			}
//
//			// 透前评估
//			for _, assessmentBefore := range assessmentBefores {
//				if scheduals.PatientId == assessmentBefore.PatientId {
//					dialysisSchedule[key].AssessmentBeforeDislysis = assessmentBefore
//					break
//				}
//			}
//
//			// 透析上下机
//			for _, dialysisOrder := range dialysisOrders {
//				if scheduals.PatientId == dialysisOrder.PatientId {
//					dialysisSchedule[key].DialysisOrder = dialysisOrder
//					break
//				}
//			}
//
//			records := make([]*models.MonitoringRecord, 0)
//			// 透析监测
//			for _, it := range monitorlist {
//				records := append(records, it)
//				if scheduals.PatientId == it.PatientId {
//					dialysisSchedule[key].MonitoringRecord = records
//				}
//			}
//
//			// 透后评估
//			for _, afterDislysis := range AssessmentAfterDislysis {
//				if scheduals.PatientId == afterDislysis.PatientId {
//					dialysisSchedule[key].AssessmentAfterDislysis = afterDislysis
//					break
//				}
//			}
//
//			//透析模式
//			for _, treatment := range treatments {
//				if scheduals.ModeId == treatment.ID {
//					dialysisSchedule[key].TreatmentMode = treatment
//					break
//				}
//			}
//		}
//		//获取所有床位号
//		if err == nil {
//			c.ServeSuccessJSON(map[string]interface{}{
//				"schedule": dialysisSchedule,
//				"total":    total,
//			})
//		} else {
//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
//		}
//
//	} else {
//		dialysisSchedule, err, total := service.GetDialysisWatch(adminUserInfo.CurrentOrgId, startTime/1000, schedulType, partitionType, page, limit)
//		if err == nil {
//			c.ServeSuccessJSON(map[string]interface{}{
//				"schedule": dialysisSchedule,
//				"total":    total,
//			})
//		} else {
//			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
//		}
//	}
//}

func (c *DialysisApiController) GetSchedualPatientsInfo() {
	patientId, _ := c.GetInt64("id", 0)
	record_date, _ := c.GetInt64("record_date", 0)
	adminUserInfo := c.GetAdminUserInfo()
	_, dialysisOrder := service.FindDialysisRecordById(adminUserInfo.CurrentOrgId, patientId, record_date)
	var dialysisStatus int64
	if dialysisOrder == nil { //没有透析记录
		dialysisStatus = 0 //未透析
	} else {
		dialysisStatus = dialysisOrder.Stage
	}
	//用户基本信息
	schedualPatientInfo, _ := service.FindPatientInfoById(adminUserInfo.CurrentOrgId, patientId, record_date)

	//接诊评估
	receiverTreatmentAccess, _ := service.FindReceiverTreatmentAccessRecordById(adminUserInfo.CurrentOrgId, patientId, record_date)
	//透前评估
	PredialysisEvaluation, _ := service.FindPredialysisEvaluationById(adminUserInfo.CurrentOrgId, patientId, record_date)
	//临时医嘱
	DoctorAdvice, _ := service.FindDoctorAdviceById(adminUserInfo.CurrentOrgId, patientId, record_date)
	//双人核对
	DoubleCheck, _ := service.FindDoubleCheckById(adminUserInfo.CurrentOrgId, patientId, record_date)
	//透析监测
	Record, _ := service.FindAllMonitorRecord(adminUserInfo.CurrentOrgId, patientId, record_date)

	//透后评估
	AssessmentAfterDislysis, _ := service.FindAssessmentAfterDislysisById(adminUserInfo.CurrentOrgId, patientId, record_date)
	//透析小结
	TreatmentSummary, _ := service.FindTreatmentSummaryById(adminUserInfo.CurrentOrgId, patientId, record_date)

	//透析处方
	dialysisPrescription, _ := service.FindPatientPrescribeById(adminUserInfo.CurrentOrgId, patientId, record_date)
	if dialysisPrescription.ID == 0 {
		solution, _ := service.FindDialysisSolution(adminUserInfo.CurrentOrgId, patientId)
		c.ServeSuccessJSON(map[string]interface{}{
			"patientInfo":             schedualPatientInfo,
			"dialysisPrescription":    solution,
			"receiverTreatmentAccess": receiverTreatmentAccess,
			"predialysisEvaluation":   PredialysisEvaluation,
			"doctorAdvice":            DoctorAdvice,
			"doubleCheck":             DoubleCheck,
			"assessmentAfterDislysis": AssessmentAfterDislysis,
			"treatmentSummary":        TreatmentSummary,
			"monitorRecord":           Record,
			"dialysisStatus":          dialysisStatus,
			"dialysisOrder":           dialysisOrder,
			"isSolution":              1,
		})
	} else {
		c.ServeSuccessJSON(map[string]interface{}{
			"patientInfo":             schedualPatientInfo,
			"dialysisPrescription":    dialysisPrescription,
			"receiverTreatmentAccess": receiverTreatmentAccess,
			"predialysisEvaluation":   PredialysisEvaluation,
			"doctorAdvice":            DoctorAdvice,
			"doubleCheck":             DoubleCheck,
			"assessmentAfterDislysis": AssessmentAfterDislysis,
			"treatmentSummary":        TreatmentSummary,
			"monitorRecord":           Record,
			"dialysisStatus":          dialysisStatus,
			"dialysisOrder":           dialysisOrder,
			"isSolution":              2,
		})

	}

}

func (c *DialysisApiController) CreateDoctorAdvice() {
	patient, _ := c.GetInt64("id", 0)
	dialysis_id, _ := c.GetInt64("dialysis_id", 0)
	record_date, _ := c.GetInt64("record_date", 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 advice models.DoctorAdvice
	code, subAdivice := adviceFormDatas(&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.RecordDate = record_date
	advice.DialysisOrderId = dialysis_id
	advice.Status = 1
	advice.CreatedTime = time.Now().Unix()
	advice.UpdatedTime = time.Now().Unix()
	advice.StopState = 2
	advice.ExecutionState = 2
	advice.AdviceType = 2
	advice.UserOrgId = adminUserInfo.CurrentOrgId
	advice.PatientId = patient
	advice.AdviceDoctor = adminUserInfo.AdminUser.Id

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

	for _, subAdvice := range subAdivice {
		subAdvice.ParentId = advice.ID
		subAdvice.PatientId = patient
		subAdvice.RecordDate = record_date
		subAdvice.CreatedTime = time.Now().Unix()
		subAdvice.UpdatedTime = time.Now().Unix()
		subAdvice.UserOrgId = adminUserInfo.CurrentOrgId

	}
	service.CreateSubDoctorAdvice(subAdivice)
	_, subAdivices := service.FindAllSubDoctorAdvice(patient, advice.ID)

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

}
func (c *DialysisApiController) EditDoctorAdvice() {
	patient, _ := c.GetInt64("patient", 0)
	id, _ := c.GetInt64("id", 0)
	parent_id, _ := c.GetInt64("parent_id", 0)
	execution_time := c.GetString("execution_time")
	// execution_staff, _ := c.GetInt64("execution_staff", 0)
	// checker, _ := c.GetInt64("checker", 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 len(execution_time) <= 0 {
		utils.ErrorLog("execution_time")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return

	}

	execution_staff := adminUserInfo.AdminUser.Id
	checker := adminUserInfo.AdminUser.Id

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

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

		return
	}

	advices := models.DoctorAdvice{
		ExecutionStaff: execution_staff,
		ExecutionTime:  theTime.Unix(),
		Checker:        checker,
		UpdatedTime:    time.Now().Unix(),
	}
	var err error
	if parent_id > 0 {
		err = service.ExceDoctorAdviceById(&advices, parent_id, patient)
	} else {
		err = service.ExceDoctorAdviceById(&advices, id, patient)
	}

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

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

}
func (c *DialysisApiController) GetDoctorAdvice() {
	patient, _ := c.GetInt64("patient_id", 0)
	parent_id, _ := c.GetInt64("parent_id", 0)
	adviceId, _ := c.GetInt64("id", 0)

	if patient <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	dminUserInfo := c.GetAdminUserInfo()
	patientInfo, _ := service.FindPatientById(dminUserInfo.CurrentOrgId, patient)
	if patientInfo.ID == 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}
	var subAdvice []*models.DoctorAdvice
	var advice models.DoctorAdvice

	if parent_id > 0 {
		_, advice = service.FindAdivceById(dminUserInfo.CurrentOrgId, patient, parent_id)
		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
			return
		}
		subAdvice = service.FindSubAdivceById(patient, parent_id)

	} else {
		_, advice = service.FindAdivceById(dminUserInfo.CurrentOrgId, patient, adviceId)
		if advice.ID == 0 || advice.PatientId != patient {
			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParentAdviceNotExist)
			return
		}
		subAdvice = service.FindSubAdivceById(patient, adviceId)

	}

	c.ServeSuccessJSON(map[string]interface{}{
		"msg":       "ok",
		"advice":    advice,
		"subAdvice": subAdvice,
	})
}
func (this *DialysisApiController) DelMonitor() {
	recordID, _ := this.GetInt64("record_id")
	patientID, _ := this.GetInt64("patient_id")
	if recordID <= 0 || patientID <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	adminInfo := this.GetAdminUserInfo()
	patient, getPatientErr := service.MobileGetPatientById(adminInfo.CurrentOrgId, patientID)
	if getPatientErr != nil {
		this.ErrorLog("获取患者信息失败：%v", getPatientErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if patient == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	monitor, getMonitorErr := service.GetMonitor(adminInfo.CurrentOrgId, patientID, recordID)
	if getMonitorErr != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	//if monitor != nil {
	//	if monitor.MonitoringNurse != adminInfo.AdminUser.Id {
	//		headNursePermission, getPermissionErr := service.GetAdminUserSpecialPermission(adminInfo.CurrentOrgId, adminInfo.CurrentAppId, adminInfo.AdminUser.Id, models.SpecialPermissionTypeHeadNurse)
	//		if getPermissionErr != nil {
	//			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//			return
	//		} else if headNursePermission == nil {
	//			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisPermissionDeniedModify)
	//			return
	//		}
	//	}
	//}

	err := service.DisableMonitor(adminInfo.CurrentOrgId, patientID, recordID, adminInfo.AdminUser.Id)
	key := strconv.FormatInt(adminInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(monitor.MonitoringDate, 10) + ":monitor_records"
	redis := service.RedisClient()
	//清空key 值
	redis.Set(key, "", time.Second)

	keyOne := strconv.FormatInt(adminInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(monitor.MonitoringDate, 10) + ":monitor_record_list_all"
	redis.Set(keyOne, "", time.Second)
	defer redis.Close()

	if err != nil {
		this.ErrorLog("删除透析监测记录失败：%v", err)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDBDelete)
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"record_id": monitor.ID,
	})

}
func (c *DialysisApiController) CreateMonitor() {
	patient, _ := c.GetInt64("id", 0)
	dialysis_order_id, _ := c.GetInt64("dialysis_order_id", 0)
	monitoring_date, _ := c.GetInt64("monitoring_date", 0)
	operate_time, _ := c.GetInt64("operate_time", 0)
	// monitoring_time := c.GetString("monitoring_time")
	pulse_frequency, _ := c.GetFloat("pulse_frequency", 0)
	breathing_rated := c.GetString("breathing_rated")
	systolic_blood_pressure, _ := c.GetFloat("systolic_blood_pressure", 0)
	diastolic_blood_pressure, _ := c.GetFloat("diastolic_blood_pressure", 0)
	blood_pressure_type, _ := c.GetInt64("blood_pressure_type", 0)
	blood_flow_volume, _ := c.GetFloat("blood_flow_volume", 0)
	venous_pressure, _ := c.GetFloat("venous_pressure", 0)
	venous_pressure_type, _ := c.GetInt64("venous_pressure_type", 1)
	transmembrane_pressure, _ := c.GetFloat("transmembrane_pressure", 0)
	transmembrane_pressure_type, _ := c.GetInt64("transmembrane_pressure_type", 1)
	ultrafiltration_rate, _ := c.GetFloat("ultrafiltration_rate", 0)
	ultrafiltration_volume, _ := c.GetFloat("ultrafiltration_volume", 0)
	sodium_concentration, _ := c.GetFloat("sodium_concentration", 0)
	arterial_pressure, _ := c.GetFloat("arterial_pressure", 0)
	arterial_pressure_type, _ := c.GetInt64("arterial_pressure_type", 1)
	dialysate_temperature, _ := c.GetFloat("dialysate_temperature", 0)
	temperature, _ := c.GetFloat("temperature", 0)
	replacement_rate, _ := c.GetFloat("replacement_rate", 0)
	displacement_quantity, _ := c.GetFloat("displacement_quantity", 0)
	conductivity, _ := c.GetFloat("conductivity", 0)

	displacement_flow_quantity, _ := c.GetFloat("displacement_flow_quantity", 0)

	heparin, _ := c.GetFloat("heparin", 0)
	dialysate_flow, _ := c.GetFloat("dialysate_flow", 0)

	ktv, _ := c.GetFloat("ktv", 0)
	symptom := c.GetString("symptom")
	dispose := c.GetString("dispose")
	result := c.GetString("results")

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

	monitor_anticoagulant, _ := c.GetInt64("monitor_anticoagulant")
	monitor_anticoagulant_value := c.GetString("monitor_anticoagulant_value")
	monitoring_date = monitoring_date / 1000
	// operate_time = operate_time / 1000
	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
	}

	monitorRecord := models.MonitoringRecord{
		PatientId:       patient,
		MonitoringDate:  monitoring_date,
		DialysisOrderId: dialysis_order_id,
		OperateTime:     operate_time,
		// MonitoringTime:            monitoring_time,
		PulseFrequency:            pulse_frequency,
		BreathingRate:             breathing_rated,
		SystolicBloodPressure:     systolic_blood_pressure,
		DiastolicBloodPressure:    diastolic_blood_pressure,
		BloodPressureType:         blood_pressure_type,
		BloodFlowVolume:           blood_flow_volume,
		VenousPressure:            venous_pressure,
		VenousPressureType:        venous_pressure_type,
		TransmembranePressure:     transmembrane_pressure,
		TransmembranePressureType: transmembrane_pressure_type,
		UltrafiltrationRate:       ultrafiltration_rate,
		UltrafiltrationVolume:     ultrafiltration_volume,
		SodiumConcentration:       sodium_concentration,
		ArterialPressure:          arterial_pressure,
		ArterialPressureType:      arterial_pressure_type,
		DialysateTemperature:      dialysate_temperature,
		Temperature:               temperature,
		ReplacementRate:           replacement_rate,
		DisplacementQuantity:      displacement_quantity,
		Ktv:                       ktv,
		Symptom:                   symptom,
		Dispose:                   dispose,
		Result:                    result,
		MonitoringNurse:           monitoring_nurse,
		Status:                    1,
		CreatedTime:               time.Now().Unix(),
		UpdatedTime:               time.Now().Unix(),
		UserOrgId:                 adminUserInfo.CurrentOrgId,
		Conductivity:              conductivity,
		DisplacementFlowQuantity:  displacement_flow_quantity,
		Heparin:                   heparin,
		DialysateFlow:             dialysate_flow,
		MonitorAnticoagulant:      monitor_anticoagulant,
		MonitorAnticoagulantValue: monitor_anticoagulant_value,
	}

	err := service.CreateMonitor(&monitorRecord)
	redis := service.RedisClient()
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(monitoring_date, 10) + ":monitor_record_list_all"

	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(monitoring_date, 10) + ":monitor_records"
	redis.Set(keyOne, "", time.Second)
	redis.Close()
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeMonitorCreate)
		return
	}

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

}

// 已弃用
// func (c *DialysisApiController) CreateRecordData() {
// 	patient, _ := c.GetInt64("id", 0)
// 	status, _ := c.GetInt64("status", 0)

// 	now := time.Now()
// 	year, month, day := now.Date()
// 	today_time := time.Date(year, month, day, 0, 0, 0, 0, time.Local)
// 	todayTimeStamp := today_time.Unix()

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

// 	record := &models.DialysisOrder{
// 		DialysisDate: todayTimeStamp,
// 		UserOrgId:    adminUserInfo.CurrentOrgId,
// 		PatientId:    patient,
// 		Stage:        status,
// 		Status:       1,
// 		CreatedTime:  time.Now().Unix(),
// 		UpdatedTime:  time.Now().Unix(),
// 	}

// 	if status == 1 {
// 		//创建透析记录
// 		err := service.CreateDialysisRecord(patient, adminUserInfo.CurrentOrgId, record)
// 		if err == nil {
// 			c.ServeSuccessJSON(map[string]interface{}{
// 				"dialysisOrder": record,
// 			})
// 		} else {
// 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
// 		}

// 	} else {

// 		record_id, _ := c.GetInt64("record_id", 0)
// 		//修改透析记录状态
// 		errs := service.ModifyDialysisRecord(record_id)
// 		//结束时候透析次数加1
// 		service.UpdateSolutionByPatientId(patient)

// 		if errs == nil {
// 			c.ServeSuccessJSON(map[string]interface{}{
// 				"dialysisOrder": record,
// 			})

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

// 		}

// 	}

// }

func adviceFormDatas(advice *models.DoctorAdvice, data []byte, action string) (code int, subAdvice []*models.DoctorAdvice) {
	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 "
	timeLayout2 := "2006-01-02 15:04"

	loc, _ := time.LoadLocation("Local")

	if action == "create" {
		if dataBody["advice_type"] == nil || reflect.TypeOf(dataBody["advice_type"]).String() != "float64" {
			utils.ErrorLog("advice_type")
			code = enums.ErrorCodeParamWrong
			return
		}

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

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

	}

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

	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["delivery_way"] == nil || reflect.TypeOf(dataBody["delivery_way"]).String() != "string" {
		utils.ErrorLog("delivery_way")
		code = enums.ErrorCodeParamWrong
		return
	}
	deliveryWay, _ := dataBody["delivery_way"].(string)
	if len(deliveryWay) == 0 {
		utils.ErrorLog("len(deliveryWay) == 0")
		code = enums.ErrorCodeParamWrong
		return
	}
	advice.DeliveryWay = deliveryWay

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

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

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

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

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

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

	if dataBody["subAdviceForm"] != nil && reflect.TypeOf(dataBody["subAdviceForm"]).String() == "[]interface {}" {
		thisContagions, _ := dataBody["subAdviceForm"].([]interface{})
		if len(thisContagions) > 0 {
			for _, item := range thisContagions {
				items := item.(map[string]interface{})
				advice_name, _ := items["advice_name"].(string)
				advice_desc, _ := items["advice_desc"].(string)
				drug_spec_unit, _ := items["drug_spec_unit"].(string)

				prescribing_number_unit, _ := items["prescribing_number_unit"].(string)
				single_dose_unit, _ := items["single_dose_unit"].(string)
				prescribing_number, _ := strconv.ParseFloat(items["prescribing_number"].(string), 64)
				single_dose, _ := strconv.ParseFloat(items["single_dose"].(string), 64)

				advice := &models.DoctorAdvice{
					AdviceName:            advice_name,
					AdviceDesc:            advice_desc,
					SingleDose:            single_dose,
					SingleDoseUnit:        single_dose_unit,
					DrugSpecUnit:          drug_spec_unit,
					PrescribingNumber:     prescribing_number,
					PrescribingNumberUnit: prescribing_number_unit,
				}
				subAdvice = append(subAdvice, advice)

			}
		}
	}

	return

}

func (c *DialysisApiController) GetDialysisOrder() {
	xtno := c.GetString("xtno")
	xtdate := c.GetString("xtdate")

	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", xtdate+" 00:00:00", loc)

	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	xttime := theTime.Unix()

	operatorIDs := make([]int64, 0)

	adminUserInfo := c.GetAdminUserInfo()

	adminUser, _ := service.GetAllAdminUsers(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId)

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

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

	//透前评估
	PredialysisEvaluation, _ := service.FindPredialysisEvaluationById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	predialysName, err := service.FindPredialysisName(PredialysisEvaluation.BloodAccessPartOperaId, adminUserInfo.CurrentOrgId)
	//透后评估
	AssessmentAfterDislysis, _ := service.FindAssessmentAfterDislysisById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	if AssessmentAfterDislysis.Modifier > 0 {
		operatorIDs = append(operatorIDs, AssessmentAfterDislysis.Modifier)
	}
	//上次透前评估
	lastPredialysisEvaluation, _ := service.GetLastTimePredialysisEvaluation(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

	lastOrder, _ := service.GetLastTimeOrder(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

	//透析处方
	dialysisPrescription, _ := service.FindPatientPrescribeWidyDevideById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	if dialysisPrescription.PrescriptionDoctor > 0 {
		operatorIDs = append(operatorIDs, dialysisPrescription.PrescriptionDoctor)
	}

	//获取病人的透析模式
	schedule, err := service.FindDialysisMode(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

	order, err := service.FindDialysisMacher(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	nurse, err := service.FindPunctureNurse(order.PunctureNurse, adminUserInfo.CurrentAppId, adminUserInfo.CurrentOrgId)

	startNuse, err := service.FindeStartNuse(order.StartNurse, adminUserInfo.CurrentAppId, adminUserInfo.CurrentOrgId)
	FinishNuse, err := service.FindeStartNuse(order.FinishNurse, adminUserInfo.CurrentAppId, adminUserInfo.CurrentOrgId)
	//获取透析处方
	dialysisway, err := service.FindDialysisWay(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//获取临时医嘱
	doctorAdvice, _ := service.FindDoctorOrder(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//config, err := service.GetHisDoctorConfig(adminUserInfo.CurrentOrgId)

	//获取医嘱内容
	doctor, err := service.FindDoctor(doctorAdvice.AdviceDoctor, adminUserInfo.CurrentAppId, adminUserInfo.CurrentOrgId)
	DoctorName, err := service.FindDoctorName(doctorAdvice.AdviceDoctor, adminUserInfo.CurrentAppId, adminUserInfo.CurrentOrgId)

	DoctorAdvice, _ := service.FindDoctorAdviceOrderById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	doctorAdevieInfo, err := service.FindDoctorAdviceByInfo(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//获取上次的透后体重
	//	assessmentAfterDislysis, _ := service.MobileGetLastTimeAssessmentAfterDislysis(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	assessmentAfterDislysis, _ := service.MobileGetLast(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//获取透析次数
	_, total, err := service.GetTotalDialysisCout(adminUserInfo.CurrentOrgId, patientInfo.ID)

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

	//透析监测
	Record, _ := service.FindAllMonitorRecord(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//透析检测
	//monitor, err := service.FindAllMonitor(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//透析小结
	TreatmentSummary, _ := service.FindTreatmentSummaryById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

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

	check, _ := service.FindDoubleCheckById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

	if adminUserInfo.CurrentOrgId != 10101 {
		dialysis_count, _ := service.GetDialysisOrderCount(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
		patientInfo.TotalDialysis = dialysis_count
	}
	if adminUserInfo.CurrentOrgId == 10101 {
		dialysis_count, _ := service.GetDialysisOrderCountOne(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
		patientInfo.TotalDialysis = dialysis_count
	}

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

	//获取当前日期月份的第一天
	firstmonth := service.GetFirstDateOfMonth(theTime)
	firstMonthDate := firstmonth.Unix()
	//获取当前月份的病人透析次数
	dialysiscount, err := service.GetDialysisCountByPatientId(firstMonthDate, xttime, patientInfo.ID, adminUserInfo.CurrentOrgId)

	//获取his数据
	hisAdvice, err := service.GetHisDoctorPatientById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)

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

	project_config, _ := service.GetHisProjectConfig(adminUserInfo.CurrentOrgId)
	projects, _ := service.FindAllHisProjectById(adminUserInfo.CurrentOrgId, patientInfo.ID, xttime)
	//if config.IsOpen == 1 && project_config.IsOpen == 1 && len(projects) > 0 {
	//	for _, item := range projects {
	//		var advice *models.HisDoctorAdviceInfo
	//		advice.ID = item.ID
	//		advice.Checker = item.Checker
	//		advice.CheckTime = item.CheckTime
	//		advice.CheckState = item.CheckState
	//		advice.ExecutionState = item.ExecutionState
	//		advice.ExecutionStaff = item.ExecutionStaff
	//		advice.PrescribingNumber = float64(item.Count)
	//		advice.PrescribingNumberUnit = item.Unit
	//		advice.AdviceDoctor = item.Doctor
	//		if item.Type == 3 {
	//			advice.AdviceName = item.GoodInfo.GoodName
	//		} else if item.Type == 2 {
	//			advice.AdviceName = item.HisProject.ProjectName
	//		}
	//		advice.StartTime = item.StartTime
	//		hisAdvice = append(hisAdvice, advice)
	//	}
	//}
	if config.IsOpen == 1 {
		c.ServeSuccessJSON(map[string]interface{}{
			"xtdate":                    xtdate,
			"users":                     adminUser,
			"patientInfo":               patientInfo,
			"PredialysisEvaluation":     PredialysisEvaluation,
			"AssessmentAfterDislysis":   AssessmentAfterDislysis,
			"dialysisPrescription":      dialysisPrescription,
			"advices":                   hisAdvice,
			"monitors":                  Record,
			"summary":                   TreatmentSummary,
			"receiverTreatmentAccess":   receiverTreatmentAccess,
			"dialysisOrder":             dialysisOrder,
			"operators":                 operators,
			"org_template_info":         templateInfo,
			"check":                     check,
			"schedule":                  schedule,
			"dialysisway":               dialysisway,
			"order":                     order,
			"doctorAdvice":              doctorAdvice,
			"doctor":                    doctor,
			"nurse":                     nurse,
			"doctorAdevieInfo":          doctorAdevieInfo,
			"total":                     total,
			"startNuse":                 startNuse,
			"DoctorName":                DoctorName,
			"assessmentAfterDislysis":   assessmentAfterDislysis,
			"predialysName":             predialysName,
			"FinishNuse":                FinishNuse,
			"lastPredialysisEvaluation": lastPredialysisEvaluation,
			"dialysiscount":             dialysiscount,
			"last_order":                lastOrder,
			"project_config":            project_config,
			"projects":                  projects,
		})

	}
	if config.IsOpen == 0 || config.IsOpen == 2 {
		c.ServeSuccessJSON(map[string]interface{}{
			"xtdate":                    xtdate,
			"users":                     adminUser,
			"patientInfo":               patientInfo,
			"PredialysisEvaluation":     PredialysisEvaluation,
			"AssessmentAfterDislysis":   AssessmentAfterDislysis,
			"dialysisPrescription":      dialysisPrescription,
			"advices":                   DoctorAdvice,
			"monitors":                  Record,
			"summary":                   TreatmentSummary,
			"receiverTreatmentAccess":   receiverTreatmentAccess,
			"dialysisOrder":             dialysisOrder,
			"operators":                 operators,
			"org_template_info":         templateInfo,
			"check":                     check,
			"schedule":                  schedule,
			"dialysisway":               dialysisway,
			"order":                     order,
			"doctorAdvice":              doctorAdvice,
			"doctor":                    doctor,
			"nurse":                     nurse,
			"doctorAdevieInfo":          doctorAdevieInfo,
			"total":                     total,
			"startNuse":                 startNuse,
			"DoctorName":                DoctorName,
			"assessmentAfterDislysis":   assessmentAfterDislysis,
			"predialysName":             predialysName,
			"FinishNuse":                FinishNuse,
			"lastPredialysisEvaluation": lastPredialysisEvaluation,
			"dialysiscount":             dialysiscount,
			"last_order":                lastOrder,
			"project_config":            project_config,
			"projects":                  projects,
		})
	}

}

//
func (c *DialysisApiController) GetLongAdvice() {
	patient_id, _ := c.GetInt64("patient_id")
	adminUserInfo := c.GetAdminUserInfo()
	_, config := service.FindDoctorAdviceRecordByOrgId(adminUserInfo.CurrentOrgId)

	//patient, _ := service.FindPatientIsOpenRemindById(patient_id, adminUserInfo.Org.Id)
	if config.IsOpenRemind == 0 { //针对老用户，即没开启推送功能，也没有	不开启推送功能，不做任何处理
		c.ServeSuccessJSON(map[string]interface{}{
			"status": "1",
		})
		return
	} else { //开启推送提醒
		//开启推送提醒逻辑    提交长期处方的时候，弹起长期医嘱推送
		var advice_three []*models.DoctorAdvice
		//groupNo := service.GetMaxLongAdviceGroupID(adminUserInfo.Org.Id, patient_id)
		recordDateStr := time.Now().Format("2006-01-02")
		recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)

		nowtime := recordDate.Unix()

		advices, err := service.GetLastLongAdviceByGroupNo(adminUserInfo.CurrentOrgId, patient_id, nowtime)
		advices_two, err := service.GetLastLongAdviceByGroupNoThree(adminUserInfo.CurrentOrgId, patient_id, nowtime)

		for _, advice := range advices {
			if advice.FrequencyType == 3 {
				t := time.Now()
				week := int(t.Weekday())

				switch week {
				case 1:
					if strings.Index(advice.WeekDay, "周一") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 2:
					if strings.Index(advice.WeekDay, "周二") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 3:
					if strings.Index(advice.WeekDay, "周三") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 4:
					if strings.Index(advice.WeekDay, "周四") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 5:
					if strings.Index(advice.WeekDay, "周五") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 6:
					if strings.Index(advice.WeekDay, "周六") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 0:
					if strings.Index(advice.WeekDay, "周日") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				}
			}
		}

		for _, advice := range advices_two {
			p, _ := time.Parse("2006-01-02", time.Now().Format("2006-01-02"))
			now := p.Unix()
			dayStr := strconv.FormatInt(advice.DayCount, 10)
			dayStr2 := "-" + dayStr
			count, _ := strconv.ParseInt(dayStr2, 10, 64)
			oldTime := time.Now().AddDate(0, 0, int(count)).Unix()
			advices, _ := service.FindAllDoctorAdviceByTime(now, oldTime, patient_id, adminUserInfo.CurrentOrgId, advice.TemplateId)

			for _, ad := range advices {
				advice_three = append(advice_three, ad)
			}
		}
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"status":         "2",
				"advices":        advices,
				"advices_two":    RemoveRepeatedElement(advice_three),
				"is_open_remind": config.IsOpenRemind,
			})
		}
	}

}

func (c *DialysisApiController) GetLongAdviceOne() {
	patient_id, _ := c.GetInt64("patient_id")
	schedule_date := c.GetString("schedule_date")
	adminUserInfo := c.GetAdminUserInfo()
	_, config := service.FindDoctorAdviceRecordByOrgId(adminUserInfo.CurrentOrgId)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", schedule_date+" 00:00:00", loc)
	//patient, _ := service.FindPatientIsOpenRemindById(patient_id, adminUserInfo.Org.Id)
	if config.IsOpenRemind == 0 { //针对老用户，即没开启推送功能，也没有	不开启推送功能，不做任何处理
		c.ServeSuccessJSON(map[string]interface{}{
			"status": "1",
		})
		return
	} else { //开启推送提醒
		//开启推送提醒逻辑    提交长期处方的时候，弹起长期医嘱推送
		var advice_three []*models.DoctorAdvice
		//groupNo := service.GetMaxLongAdviceGroupID(adminUserInfo.Org.Id, patient_id)
		//recordDateStr := time.Now().Format("2006-01-02")
		//recordDate, _ := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
		//
		//nowtime := recordDate.Unix()

		advices, err := service.GetLastLongAdviceByGroupNo(adminUserInfo.CurrentOrgId, patient_id, theTime.Unix())
		advices_two, err := service.GetLastLongAdviceByGroupNoThree(adminUserInfo.CurrentOrgId, patient_id, theTime.Unix())

		for _, advice := range advices {
			if advice.FrequencyType == 3 {
				t := time.Now()
				week := int(t.Weekday())

				switch week {
				case 1:
					if strings.Index(advice.WeekDay, "周一") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 2:
					if strings.Index(advice.WeekDay, "周二") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 3:
					if strings.Index(advice.WeekDay, "周三") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 4:
					if strings.Index(advice.WeekDay, "周四") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 5:
					if strings.Index(advice.WeekDay, "周五") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 6:
					if strings.Index(advice.WeekDay, "周六") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 0:
					if strings.Index(advice.WeekDay, "周日") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				}
			}
		}

		for _, advice := range advices_two {
			p, _ := time.Parse("2006-01-02", time.Now().Format("2006-01-02"))
			now := p.Unix()
			dayStr := strconv.FormatInt(advice.DayCount, 10)
			dayStr2 := "-" + dayStr
			count, _ := strconv.ParseInt(dayStr2, 10, 64)
			oldTime := time.Now().AddDate(0, 0, int(count)).Unix()
			advices, _ := service.FindAllDoctorAdviceByTime(now, oldTime, patient_id, adminUserInfo.CurrentOrgId, advice.TemplateId)

			for _, ad := range advices {
				advice_three = append(advice_three, ad)
			}
		}
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"status":         "2",
				"advices":        advices,
				"advices_two":    RemoveRepeatedElement(advice_three),
				"is_open_remind": config.IsOpenRemind,
			})
		}
	}

}

func (c *DialysisApiController) GetLongAdviceTwo() {
	patient_id, _ := c.GetInt64("patient_id")
	schedule_date, _ := c.GetInt64("schedule_date")
	adminUserInfo := c.GetAdminUserInfo()
	_, config := service.FindDoctorAdviceRecordByOrgId(adminUserInfo.CurrentOrgId)

	//patient, _ := service.FindPatientIsOpenRemindById(patient_id, adminUserInfo.Org.Id)
	if config.IsOpenRemind == 0 { //针对老用户，即没开启推送功能，也没有	不开启推送功能，不做任何处理
		c.ServeSuccessJSON(map[string]interface{}{
			"status": "1",
		})
		return
	} else { //开启推送提醒
		//开启推送提醒逻辑    提交长期处方的时候，弹起长期医嘱推送
		var advice_three []*models.DoctorAdvice
		//groupNo := service.GetMaxLongAdviceGroupID(adminUserInfo.Org.Id, patient_id)
		advices, err := service.GetLastLongAdviceByGroupNo(adminUserInfo.CurrentOrgId, patient_id, schedule_date)
		advices_two, err := service.GetLastLongAdviceByGroupNoThree(adminUserInfo.CurrentOrgId, patient_id, schedule_date)

		for _, advice := range advices {
			if advice.FrequencyType == 3 {
				t := time.Now()
				week := int(t.Weekday())

				switch week {
				case 1:
					if strings.Index(advice.WeekDay, "周一") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 2:
					if strings.Index(advice.WeekDay, "周二") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 3:
					if strings.Index(advice.WeekDay, "周三") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 4:
					if strings.Index(advice.WeekDay, "周四") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 5:
					if strings.Index(advice.WeekDay, "周五") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				case 6:
					if strings.Index(advice.WeekDay, "周六") == -1 {
						advice_three = append(advice_three, advice)
					}

					break
				case 0:
					if strings.Index(advice.WeekDay, "周日") == -1 {
						advice_three = append(advice_three, advice)
					}
					break
				}
			}
		}

		for _, advice := range advices_two {
			p, _ := time.Parse("2006-01-02", time.Now().Format("2006-01-02"))
			now := p.Unix()
			dayStr := strconv.FormatInt(advice.DayCount, 10)
			dayStr2 := "-" + dayStr
			count, _ := strconv.ParseInt(dayStr2, 10, 64)
			oldTime := time.Now().AddDate(0, 0, int(count)).Unix()
			advices, _ := service.FindAllDoctorAdviceByTime(now, oldTime, patient_id, adminUserInfo.CurrentOrgId, advice.TemplateId)

			for _, ad := range advices {
				advice_three = append(advice_three, ad)
			}
		}
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"status":         "2",
				"advices":        advices,
				"advices_two":    RemoveRepeatedElement(advice_three),
				"is_open_remind": config.IsOpenRemind,
			})
		}
	}

}

func RemoveRepeatedElement(arr []*models.DoctorAdvice) (newArr []*models.DoctorAdvice) {
	newArr = make([]*models.DoctorAdvice, 0)
	for i := 0; i < len(arr); i++ {
		repeat := false
		for j := i + 1; j < len(arr); j++ {
			if arr[i].ID == arr[j].ID {
				repeat = true
				break
			}
		}
		if !repeat {
			newArr = append(newArr, arr[i])
		}
	}
	return
}

func (c *DialysisApiController) CreateRemindDoctorAdvice() {

	patient, _ := c.GetInt64("id", 0)
	groupNo, _ := c.GetInt64("groupno", 0)

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

	adminUserInfo := c.GetAdminUserInfo()

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

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

	timeLayout2 := "2006-01-02"
	loc2, _ := time.LoadLocation("Local")

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

	if dataBody["advice_date"] == nil || reflect.TypeOf(dataBody["advice_date"]).String() != "string" {
		utils.ErrorLog("advice_date")
		return
	}
	adviceDate, _ := dataBody["advice_date"].(string)
	theTime, err := time.ParseInLocation(timeLayout2, adviceDate, loc2)

	AdviceDate := theTime.Unix()
	RecordDate := theTime.Unix()

	if dataBody["start_time"] == nil || reflect.TypeOf(dataBody["start_time"]).String() != "string" {
		utils.ErrorLog("start_time")
		return
	}
	startTime, _ := dataBody["start_time"].(string)
	if len(startTime) == 0 {
		utils.ErrorLog("len(start_time) == 0")
		return
	}
	theTimeUnix, err := time.ParseInLocation(timeLayout, startTime, loc)
	if err != nil {
		utils.ErrorLog(err.Error())
		return
	}
	StartTime := theTimeUnix.Unix()
	fmt.Println("startTIME", StartTime)
	Remark := ""
	if dataBody["remark"] != nil && reflect.TypeOf(dataBody["remark"]).String() == "string" {
		remark, _ := dataBody["remark"].(string)
		Remark = remark
	}

	var advices []*models.GroupAdvice
	if dataBody["advices"] == nil || reflect.TypeOf(dataBody["advices"]).String() != "[]interface {}" {
		utils.ErrorLog("advices")
		return
	}
	adviceNames := dataBody["advices"].([]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 = patient
		advice.AdviceDoctor = adminUserInfo.AdminUser.Id
		advice.IsSettle = 2
		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["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" {
			//single_dose := int64(adviceNameM["single_dose"].(float64))
			advice.SingleDose = adviceNameM["single_dose"].(float64)
		}

		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["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" {

			advice.PrescribingNumber = adviceNameM["prescribing_number"].(float64)
		}

		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["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() == "float64" {
			day_count := int64(adviceNameM["day_count"].(float64))
			advice.DayCount = day_count
		}

		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() == "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
		}

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

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

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

		if adviceNameM["child"] != nil && reflect.TypeOf(adviceNameM["child"]).String() == "[]interface {}" {
			children := adviceNameM["child"].([]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 = patient
					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")
						return
					}
					childAdviceName, _ := childMap["advice_name"].(string)
					if len(childAdviceName) == 0 {
						utils.ErrorLog("len(child advice_name) == 0")
						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"] != nil && reflect.TypeOf(childMap["single_dose"]).String() == "float64" {
						//childSingleDose, _ := strconv.ParseFloat(childMap["single_dose"].(string), 64)
						child.SingleDose = childMap["single_dose"].(float64)
					}
					if childMap["remark"] != nil && reflect.TypeOf(childMap["remark"]).String() == "string" {
						//childSingleDose, _ := strconv.ParseFloat(childMap["single_dose"].(string), 64)
						child.Remark = childMap["remark"].(string)
					}
					if childMap["drug_id"] != nil && reflect.TypeOf(childMap["drug_id"]).String() == "float64" {
						//childSingleDose, _ := strconv.ParseFloat(childMap["single_dose"].(string), 64)
						child.DrugId = int64(childMap["drug_id"].(float64))
					}

					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"] != nil && reflect.TypeOf(childMap["prescribing_number"]).String() == "float64" {
						//childPrescribingNumber, _ := strconv.ParseFloat(childMap["prescribing_number"].(string), 64)
						child.PrescribingNumber = childMap["prescribing_number"].(float64)
					}

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

					child.DeliveryWay = advice.DeliveryWay
					child.ExecutionFrequency = advice.ExecutionFrequency
					advice.Children = append(advice.Children, &child)
				}
			}
		}

		advices = append(advices, &advice)
	}

	list, err := service.CreateMGroupAdvice(adminUserInfo.CurrentOrgId, advices, groupNo)
	redis := service.RedisClient()
	formatAdviceDate := theTime.Format("2006-01-02")
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":doctor_advices"
	redis.Set(keyOne, "", time.Second)
	keyFour := "scheduals_" + formatAdviceDate + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
	redis.Set(keyFour, "", time.Second)
	defer redis.Close()
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
		return
	}

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

	return

}

func (c *DialysisApiController) GetSolution() {
	patient_id, _ := c.GetInt64("patient_id")
	mode_id, _ := c.GetInt64("mode_id")

	adminUserInfo := c.GetAdminUserInfo()

	solution, err := service.MobileGetDialysisSolutionByModeIdSix(adminUserInfo.CurrentOrgId, patient_id, mode_id)
	prescription, err := service.MobileGetLastDialysisPrescribeByModeIdSix(adminUserInfo.CurrentOrgId, patient_id, mode_id)
	system_prescription, err := service.MobileGetSystemDialysisPrescribeByModeIdSix(adminUserInfo.CurrentOrgId, mode_id)
	dialysisPrescription, _ := service.MobileGetLastDialysisPrescription(patient_id, adminUserInfo.CurrentOrgId)
	if err != nil {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
	c.ServeSuccessJSON(map[string]interface{}{
		"solution":             solution,
		"prescription":         prescription,
		"system_prescription":  system_prescription,
		"dialysisPrescription": dialysisPrescription,
	})

}

func (c *DialysisApiController) GetSchedule() {
	schedual_type, _ := c.GetInt64("schedual_type")
	adminUserInfo := c.GetAdminUserInfo()

	//timeLayout := "2006-01-02 15:04:05"
	//
	//date := time.Now().Format("2006-01-02") + " 00:00:00"
	//loc, _ := time.LoadLocation("Local")
	//theStartTime, _ := time.ParseInLocation(timeLayout, date, loc)
	//scheduleTime := theStartTime.Unix()
	scheduleTime, _ := c.GetInt64("record_date")

	deviceNumber, _ := service.GetAllDeviceNumbers(adminUserInfo.CurrentOrgId, scheduleTime, schedual_type)

	c.ServeSuccessJSON(map[string]interface{}{
		"number": deviceNumber,
	})

}

func (this *DialysisApiController) GetTodayMonitor() {
	thisTime := time.Now()
	scheduleDateStart := thisTime.Format("2006-01-02") + " 00:00:00"
	timeLayout := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")
	theStartTime, _ := time.ParseInLocation(timeLayout, scheduleDateStart, loc)
	theAssessmentDateTime := theStartTime.Unix()

	patientID, _ := this.GetInt64("patient_id")
	monitorDate, _ := this.GetInt64("monitoring_date", theAssessmentDateTime)
	adminInfo := this.GetAdminUserInfo()
	record, _ := service.FindLastMonitorRecordToday(patientID, adminInfo.CurrentOrgId, monitorDate)
	fristrecord, _ := service.FindFirstMonitorRecordToday(patientID, adminInfo.CurrentOrgId, monitorDate)

	template, _ := service.GetOrgInfoTemplate(adminInfo.CurrentOrgId)

	var ultrafiltration_rate float64
	_, prescription := service.FindDialysisPrescriptionByReordDate(patientID, theAssessmentDateTime, adminInfo.CurrentOrgId)
	//针对福建医师汇 获取透前评估预增脱水量

	_, evaluation := service.FindPredialysisEvaluationByReordDate(patientID, theAssessmentDateTime, adminInfo.CurrentOrgId)
	fmt.Println("透前评估数据", evaluation)

	if prescription.ID > 0 {
		if prescription.TargetUltrafiltration > 0 && prescription.DialysisDurationHour > 0 {

			totalMin := prescription.DialysisDurationHour*60 + prescription.DialysisDurationMinute
			if template.TemplateId == 6 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)
				record.UltrafiltrationRate = ultrafiltration_rate
			}
			if template.TemplateId == 6 && adminInfo.CurrentOrgId == 10121 {

				dehydration, _ := strconv.ParseFloat(evaluation.Dehydration, 64)
				ultrafiltration_rate = math.Floor((prescription.TargetUltrafiltration + dehydration) / float64(totalMin) * 60 * 1000)

				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 6 && adminInfo.CurrentOrgId == 10234 {

				dehydration, _ := strconv.ParseFloat(evaluation.Dehydration, 64)
				ultrafiltration_rate = math.Floor((prescription.TargetUltrafiltration + dehydration) / float64(totalMin) * 60 * 1000)

				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 20 || template.TemplateId == 22 || template.TemplateId == 32 || template.TemplateId == 34 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60)
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 41 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 43 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60)
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 46 || template.TemplateId == 54 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60)
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if template.TemplateId == 47 { //adminInfo.CurrentOrgId == 9538
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			// 只针对方济医院
			if template.TemplateId == 1 && adminInfo.CurrentOrgId != 9849 {
				value, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", prescription.TargetUltrafiltration/float64(totalMin)*60), 6)
				ultrafiltration_rate = value
				record.UltrafiltrationRate = ultrafiltration_rate
			}

			if adminInfo.CurrentOrgId == 10395 || adminInfo.CurrentOrgId == 10138 || adminInfo.CurrentOrgId == 10278 || adminInfo.CurrentOrgId == 10340 || adminInfo.CurrentOrgId == 10432 || adminInfo.CurrentOrgId == 10441 || adminInfo.CurrentOrgId == 10445 {
				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration * 60 / 1000 / float64(totalMin) * 1000)

				record.UltrafiltrationRate = ultrafiltration_rate
			}

		}
	}
	// record.UltrafiltrationRate = ultrafiltration_rate

	record.UltrafiltrationVolume = 0

	if template.TemplateId == 1 && adminInfo.CurrentOrgId != 9849 {
		if ultrafiltration_rate > 0 {
			value, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", float64(record.OperateTime+3600-fristrecord.OperateTime)/3600*ultrafiltration_rate), 6)
			record.UltrafiltrationVolume = value
		}
	}

	if template.TemplateId == 6 || template.TemplateId == 20 || template.TemplateId == 22 || template.TemplateId == 32 || template.TemplateId == 34 || template.TemplateId == 41 || template.TemplateId == 43 || template.TemplateId == 47 || template.TemplateId == 54 {
		if ultrafiltration_rate > 0 && adminInfo.CurrentOrgId != 9538 {
			ultrafiltration_volume := math.Floor(float64(record.OperateTime+3600-fristrecord.OperateTime) / 3600 * ultrafiltration_rate)

			record.UltrafiltrationVolume = ultrafiltration_volume
		}

	}

	if adminInfo.CurrentOrgId == 10395 || adminInfo.CurrentOrgId == 10138 || adminInfo.CurrentOrgId == 10278 || adminInfo.CurrentOrgId == 10340 || adminInfo.CurrentOrgId == 10432 || adminInfo.CurrentOrgId == 10441 || adminInfo.CurrentOrgId == 10445 {

		if ultrafiltration_rate > 0 {
			ultrafiltration_volume := math.Floor(float64(record.OperateTime+3600-fristrecord.OperateTime) / 3600 * ultrafiltration_rate)

			record.UltrafiltrationVolume = ultrafiltration_volume
		}
	}

	if template.TemplateId == 47 || template.TemplateId == 54 {
		record.DisplacementQuantity = record.DisplacementQuantity + record.DisplacementQuantity
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"monitor": record,
	})

}

func (c *DialysisApiController) UploadDryWeight() {
	patient_id, _ := c.GetInt64("id")
	dry_weight, _ := c.GetFloat("dry_weight")
	doctor_id, _ := c.GetInt64("doctor_id")
	remark := c.GetString("remark")
	adminUserInfo := c.GetAdminUserInfo()
	weightAdjust, err := service.FindLastDryWeightAdjust(adminUserInfo.CurrentOrgId, patient_id)
	fmt.Println(err)
	if err == gorm.ErrRecordNotFound {
		dryWeight := &models.SgjPatientDryweight{
			PatientId:     patient_id,
			DryWeight:     dry_weight,
			Remakes:       remark,
			Ctime:         time.Now().Unix(),
			Mtime:         time.Now().Unix(),
			Creator:       doctor_id,
			Status:        1,
			UserOrgId:     adminUserInfo.CurrentOrgId,
			AdjustedValue: "/",
			UserId:        adminUserInfo.AdminUser.Id,
		}
		createErr := service.CreatePatientWeightAdjust(dryWeight)
		loc, _ := time.LoadLocation("Local")
		nowTime := time.Now()
		nowDay := nowTime.Format("2006-01-02")
		dayTime, _ := time.ParseInLocation("2006-01-02 15:04:05", nowDay+" 00:00:00", loc)
		redis := service.RedisClient()
		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(dayTime.Unix(), 10) + ":assessment_befores_list_all"
		redis.Set(keyOne, "", time.Second)

		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(dayTime.Unix(), 10) + ":assessment_before_dislysis"

		redis.Set(key, "", time.Second)
		keyTwo := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":last_dry_weight"
		redis.Set(keyTwo, "", time.Second)
		redis.Close()
		if createErr == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":    "提交成功",
				"weight": dryWeight,
			})
		}

	} else {
		dryWeight := &models.SgjPatientDryweight{
			PatientId:     patient_id,
			DryWeight:     dry_weight,
			Remakes:       remark,
			Ctime:         time.Now().Unix(),
			Mtime:         time.Now().Unix(),
			Creator:       doctor_id,
			Status:        1,
			UserOrgId:     adminUserInfo.CurrentOrgId,
			AdjustedValue: "/",
			UserId:        adminUserInfo.AdminUser.Id,
		}
		var value float64
		value = dry_weight - weightAdjust.DryWeight
		fmt.Println(value)

		if value < 0 {
			dryWeight.AdjustedValue = strconv.FormatFloat(math.Abs(value), 'f', 1, 64) + "(下调)"
		} else if value == 0 {
			dryWeight.AdjustedValue = "/"
		} else if value > 0 {
			dryWeight.AdjustedValue = strconv.FormatFloat(value, 'f', 1, 64) + "(上调)"
		}
		fmt.Println(value)

		createErr := service.CreatePatientWeightAdjust(dryWeight)
		loc, _ := time.LoadLocation("Local")
		nowTime := time.Now()
		nowDay := nowTime.Format("2006-01-02")
		dayTime, _ := time.ParseInLocation("2006-01-02 15:04:05", nowDay+" 00:00:00", loc)
		redis := service.RedisClient()
		keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(dayTime.Unix(), 10) + ":assessment_befores_list_all"
		redis.Set(keyOne, "", time.Second)

		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":" + strconv.FormatInt(dayTime.Unix(), 10) + ":assessment_before_dislysis"
		redis.Set(key, "", time.Second)
		keyTwo := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patient_id, 10) + ":last_dry_weight"
		redis.Set(keyTwo, "", time.Second)
		redis.Close()
		if createErr == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"msg":    "提交成功",
				"weight": dryWeight,
			})
		}
	}

}

func (this *DialysisApiController) GetFuncPurview() {
	adminUserInfo := this.GetAdminUserInfo()
	user_id := adminUserInfo.AdminUser.Id
	app_id := adminUserInfo.CurrentAppId
	org_id := adminUserInfo.CurrentOrgId
	create_url := this.GetString("create_url")
	modify_url := this.GetString("modify_url")
	modify_other_url := this.GetString("modify_other_url")
	del_url := this.GetString("del_url")
	del_other_url := this.GetString("del_other_url")
	exce_url := this.GetString("exce_url")
	check_url := this.GetString("check_url")
	modify_exce_url := this.GetString("modify_exce_url")
	module, _ := this.GetInt64("module", 0)

	app_role, _ := service.GetAppRole(org_id, app_id, user_id)
	var is_has_create bool
	var is_has_modify bool
	var is_has_modify_other bool
	var is_has_del bool
	var is_has_del_other bool
	var is_has_exce bool
	var is_has_check bool
	var is_has_modify_exce bool

	org, _ := service.GetOrgById(adminUserInfo.CurrentOrgId)

	if adminUserInfo.AdminUser.Id != org.Creator {

		if app_role != nil {
			if len(app_role.RoleIds) > 0 {
				roles := strings.Split(app_role.RoleIds, ",")
				var userRolePurviews string
				for _, item := range roles {
					role_id, _ := strconv.ParseInt(item, 10, 64)
					purviews, _ := service.GetRoleFuncPurviewIds(role_id)
					if len(userRolePurviews) == 0 {
						userRolePurviews = purviews
					} else {
						userRolePurviews = userRolePurviews + "," + purviews
					}
				}
				userRolePurviewsArr := RemoveRepeatedPurviewElement2(strings.Split(userRolePurviews, ","))
				funcPurviews, _ := service.FindAllFuncPurview(userRolePurviewsArr)
				for _, item := range funcPurviews {
					//for _, url := range strings.Split(item.Urlfor,","){
					if strings.Split(item.Urlfor, ",")[1] == create_url {
						is_has_create = true
					}
					if strings.Split(item.Urlfor, ",")[1] == modify_url {
						is_has_modify = true
					}
					if strings.Split(item.Urlfor, ",")[1] == modify_other_url {
						is_has_modify_other = true
					}
					if strings.Split(item.Urlfor, ",")[1] == del_url {
						is_has_del = true
					}
					if strings.Split(item.Urlfor, ",")[1] == del_other_url {
						is_has_del_other = true
					}
					if strings.Split(item.Urlfor, ",")[1] == exce_url {
						is_has_exce = true
					}
					if strings.Split(item.Urlfor, ",")[1] == check_url {
						is_has_check = true
					}
					if strings.Split(item.Urlfor, ",")[1] == modify_exce_url {
						is_has_modify_exce = true
					}

				}
			} else {
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeRole)
				return
			}
			this.ServeSuccessJSON(map[string]interface{}{
				"is_has_create":       is_has_create,
				"is_has_modify":       is_has_modify,
				"is_has_modify_other": is_has_modify_other,
				"is_has_del":          is_has_del,
				"is_has_del_other":    is_has_del_other,
				"is_has_exce":         is_has_exce,
				"is_has_check":        is_has_check,
				"is_has_modify_exce":  is_has_modify_exce,
				"module":              module,
			})
		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAdminUserIsExit)
			return
		}
	} else {
		this.ServeSuccessJSON(map[string]interface{}{
			"is_has_create":       true,
			"is_has_modify":       true,
			"is_has_modify_other": true,
			"is_has_del":          true,
			"is_has_del_other":    true,
			"is_has_exce":         true,
			"is_has_check":        true,
			"is_has_modify_exce":  true,
			"module":              true,
		})
	}
}

func (this *DialysisApiController) GetOrderDoctorAdvice() {
	patient_id, _ := this.GetInt64("patient_id", 0)
	advice_date, _ := this.GetInt64("advice_date")
	adminUserInfo := this.GetAdminUserInfo()
	doctorAdvice, _ := service.GetBloodDoctorAdvice(advice_date, adminUserInfo.CurrentOrgId, patient_id)
	hisDoctorAdvice, _ := service.GetHisDoctorAdvice(advice_date, adminUserInfo.CurrentOrgId, patient_id)

	this.ServeSuccessJSON(map[string]interface{}{

		"doctorAdvice":    doctorAdvice,
		"hisDoctorAdvice": hisDoctorAdvice,
	})

}

func (this *DialysisApiController) GetLastOrNextDoctorAdvice() {
	change_type, _ := this.GetInt64("type", 0)
	record_date := this.GetString("record_time")
	patient_id, _ := this.GetInt64("patient_id", 0)
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	theAdviceRecordTime, _ := time.ParseInLocation(timeLayout, record_date, loc)
	record_time := theAdviceRecordTime.Unix()
	adminUserInfo := this.GetAdminUserInfo()
	advices, sch, err := service.GetDoctorAdviceByType(change_type, record_time, adminUserInfo.CurrentOrgId, patient_id)

	if err == nil {
		if len(advices) == 0 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDoctorAdviceEmpty)
			return
		} else {
			this.ServeSuccessJSON(map[string]interface{}{
				"advices":  advices,
				"schedule": sch,
			})
			return
		}
	} else {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
		return
	}
}

func (c *DialysisApiController) GetDialysisGoods() {
	schedualDate := c.GetString("schedule_date")
	schedule_type, _ := c.GetInt64("schedule_type")
	partition_id, _ := c.GetInt64("partition_id")
	page, _ := c.GetInt("page")
	limit, _ := c.GetInt("limit")
	keywords := c.GetString("keywords")

	patient_id, _ := c.GetInt64("patient_id")

	good_type, _ := c.GetInt64("good_type")

	date, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", schedualDate)
	if parseDateErr != nil && len(schedualDate) != 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	schedualEndDate := int64(0)

	endDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02 15:04:05", schedualDate+" 23:59:59")
	if parseDateErr != nil && len(schedualDate) != 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	schedualEndDate = endDate.Unix()

	adminUser := c.GetAdminUserInfo()

	_, err := service.FindStockOutByIsSys(adminUser.CurrentOrgId, 1, date.Unix())

	goodTypes, _ := service.FindAllGoodType(adminUser.CurrentOrgId)

	if err == gorm.ErrRecordNotFound {
		list, _ := service.GetDialysisGood(adminUser.CurrentOrgId, date.Unix())
		var ids []int64
		for _, item := range list {
			ids = append(ids, item.PatientId)
		}

		dialysisGoods, _, total := service.PCGetDialysisGoods(adminUser.CurrentOrgId, date.Unix(), schedule_type, partition_id, page, limit, patient_id, keywords, schedualEndDate, good_type, ids)
		for _, item := range dialysisGoods { //获取当天排班的每个患者的最后日期的库存使用情况
			goodUser, _ := service.GetLastDialysisGoods(item.PatientId, adminUser.CurrentOrgId, date.Unix())
			lastGoodUserDetial, _ := service.GetLastDialysisBeforePrepare(item.PatientId, adminUser.CurrentOrgId, date.Unix())
			item.LastAutomaticReduceDetail = goodUser
			item.LastDialysisBeforePrepare = lastGoodUserDetial
		}
		c.ServeSuccessJSON(map[string]interface{}{
			"dialysis_goods": dialysisGoods,
			"good_type":      goodTypes,
			"total":          total,
		})
		return

	} else if err == nil {
		//获取当天排班的每个患者的库存使用情况
		list, _ := service.GetDialysisGood(adminUser.CurrentOrgId, date.Unix())
		var ids []int64
		for _, item := range list {
			ids = append(ids, item.PatientId)
		}

		dialysisGoods, err, total := service.PCGetDialysisGoods(adminUser.CurrentOrgId, date.Unix(), schedule_type, partition_id, page, limit, patient_id, keywords, schedualEndDate, good_type, ids)
		for _, item := range dialysisGoods { //获取当天排班的每个患者的最后日期的库存使用情况
			goodUser, _ := service.GetLastDialysisGoods(item.PatientId, adminUser.CurrentOrgId, date.Unix())
			lastGoodUserDetial, _ := service.GetLastDialysisBeforePrepare(item.PatientId, adminUser.CurrentOrgId, date.Unix())

			fmt.Println(goodUser)
			fmt.Println(lastGoodUserDetial)

			item.LastAutomaticReduceDetail = goodUser
			item.LastDialysisBeforePrepare = lastGoodUserDetial
		}
		if err == nil {
			c.ServeSuccessJSON(map[string]interface{}{
				"dialysis_goods": dialysisGoods,
				"good_type":      goodTypes,
				"total":          total,
			})
			return

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

	}

}
func (c *DialysisApiController) GetDialysisGoodsStatistics() {
	start_time := c.GetString("start_time")
	end_time := c.GetString("end_time")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var theStartTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
		}
		theStartTime = theTime.Unix()
	}
	var theEndtTime 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())
		}
		theEndtTime = theTime.Unix()
	}

	adminUser := c.GetAdminUserInfo()
	outInfo, err := service.MobileGetGoodsStatistics(adminUser.CurrentOrgId, theStartTime, theEndtTime)

	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"stock_out": outInfo,
		})
		return

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

}

func (c *DialysisApiController) GetRoleList() {

	orgId := c.GetAdminUserInfo().CurrentOrgId
	admin_user_id, _ := c.GetInt64("admin_user_id")
	list, err := service.GetRoleList(orgId, admin_user_id)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"adminRole": list,
		})
		return

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

func (c *DialysisApiController) GetInitPrintData() {

	patient_id, _ := c.GetInt64("patient_id")
	record_date, _ := c.GetInt64("record_date")
	orgId := c.GetAdminUserInfo().CurrentOrgId
	list, err := service.GetInitPrintData(patient_id, record_date, orgId)
	assessmentAfterDislysis, _ := service.GetLastWeightAfter(patient_id, record_date, orgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":                    list,
			"assessmentAfterDislysis": assessmentAfterDislysis,
		})
		return

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

func (c *DialysisApiController) GetInitPrintDataOne() {

	patient_id, _ := c.GetInt64("patient_id")
	start_time := c.GetString("record_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var theStartTime int64
	if len(start_time) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
		}
		theStartTime = theTime.Unix()
	}
	orgId := c.GetAdminUserInfo().CurrentOrgId
	list, err := service.GetInitPrintData(patient_id, theStartTime, orgId)
	assessmentAfterDislysis, _ := service.GetLastWeightAfter(patient_id, theStartTime, orgId)
	if err == nil {
		c.ServeSuccessJSON(map[string]interface{}{
			"list":                    list,
			"assessmentAfterDislysis": assessmentAfterDislysis,
		})
		return

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

//新接口
func (this *DialysisApiController) GetPatientDialysisSolutionGroupList() {

	keyword := this.GetString("keywords")

	limit, _ := this.GetInt64("limit")

	page, _ := this.GetInt64("page")

	partition_id, _ := this.GetInt64("partition_id")

	schedule_type, _ := this.GetInt64("schedule_type")

	start_time := this.GetString("schedule_date")

	advice_ids := this.GetString("ids")
	var ids []string
	if advice_ids != "" {
		ids = strings.Split(advice_ids, ",")
	}

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

	orgId := this.GetAdminUserInfo().CurrentOrgId
	_, config := service.FindXTHisRecordByOrgId(orgId)

	goodType, _ := service.GetAllGoodType(orgId)
	if config.IsOpen != 1 {
		list, total, err := service.GetPatientDialysisSolutionGroupList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, ids)
		fmt.Println("list2232323223332323232", list)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":     list,
				"total":    total,
				"config":   config,
				"goodType": goodType,
			})
			return

		} else {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
			return
		}
	}
	if config.IsOpen == 1 {
		list, total, err := service.GetHisPatientDialysisSolutionGroupList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, ids)
		if err == nil {
			this.ServeSuccessJSON(map[string]interface{}{
				"list":     list,
				"total":    total,
				"config":   config,
				"goodType": goodType,
			})
			return
		}

	}

}

func (this *DialysisApiController) GetDialysisAdviceTemplateList() {

	keyword := this.GetString("keywords")

	limit, _ := this.GetInt64("limit")

	page, _ := this.GetInt64("page")

	partition_id, _ := this.GetInt64("partition_id")

	schedule_type, _ := this.GetInt64("schedule_type")

	start_time := this.GetString("schedule_date")

	ids := this.GetString("ids")

	var idArray []string
	if ids != "" {
		idArray = strings.Split(ids, ",")
	}

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

	orgId := this.GetAdminUserInfo().CurrentOrgId

	list, total, err := service.GetDialysisAdviceTemplateList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, idArray)

	tablelist, _, err := service.GetDialysisAdviceSchedulistSix(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, idArray)
	//获取长期医嘱
	adviceList, _ := service.GetAllLongAdviceList(orgId)

	_, config := service.FindXTHisRecordByOrgId(orgId)

	drugList, _ := service.GetAllBaseDrugListTwenty(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":       list,
			"total":      total,
			"adviceList": adviceList,
			"config":     config,
			"drugList":   drugList,
			"tablelist":  tablelist,
		})
		return

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

func (this *DialysisApiController) SaveDialysisSetting() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	device_number_set, _ := this.GetInt64("device_number_set")
	device_type_set, _ := this.GetInt64("device_type_set")
	name_set, _ := this.GetInt64("name_set")
	admission_number_set, _ := this.GetInt64("admission_number_set")
	dialysis_no_set, _ := this.GetInt64("dialysis_no_set")
	weight_befor_set, _ := this.GetInt64("weight_befor_set")
	dry_weight_set, _ := this.GetInt64("dry_weight_set")
	blood_pressure_set, _ := this.GetInt64("blood_pressure_set")
	ultrafiltration_volume_set, _ := this.GetInt64("ultrafiltration_volume_set")
	internal_fistula_set, _ := this.GetInt64("internal_fistula_set")
	blood_flow_volume_set, _ := this.GetInt64("blood_flow_volume_set")
	anticoagulant_set, _ := this.GetInt64("anticoagulant_set")
	sealing_fluid_dispose_set, _ := this.GetInt64("sealing_fluid_dispose_set")
	mode_id_set, _ := this.GetInt64("mode_id_set")
	dialysis_time_set, _ := this.GetInt64("dialysis_time_set")
	dialysis_dialyszers_set, _ := this.GetInt64("dialysis_dialyszers_set")
	dialysis_irrigation_set, _ := this.GetInt64("dialysis_irrigation_set")
	gaijiliang_set, _ := this.GetInt64("gaijiliang_set")
	kalium_set, _ := this.GetInt64("kalium_set")
	displace_liqui_value_set, _ := this.GetInt64("displace_liqui_value_set")
	bicarbonate_set, _ := this.GetInt64("bicarbonate_set")
	glucose_set, _ := this.GetInt64("glucose_set")

	sodium_set, _ := this.GetInt64("sodium_set")
	calcium_set, _ := this.GetInt64("calcium_set")
	blood_access_set, _ := this.GetInt64("blood_access_set")
	dialyzer_perfusion_apparatus_set, _ := this.GetInt64("dialyzer_perfusion_apparatus_set")
	displace_liqui_part_set, _ := this.GetInt64("displace_liqui_part_set")
	dialysisSetting := models.XtDialysisSetting{
		Sodium:                     sodium_set,
		Calcium:                    calcium_set,
		BloodAccess:                blood_access_set,
		DialyzerPerfusionApparatus: dialyzer_perfusion_apparatus_set,
		DisplaceLiquiPart:          displace_liqui_part_set,
		UserOrgId:                  orgId,
		Status:                     1,
		DeviceNumber:               device_number_set,
		DeviceType:                 device_type_set,
		Name:                       name_set,
		AdmissionNumber:            admission_number_set,
		DialysisNo:                 dialysis_no_set,
		WeightBefor:                weight_befor_set,
		DryWeight:                  dry_weight_set,
		BloodPressure:              blood_pressure_set,
		UltrafiltrationVolume:      ultrafiltration_volume_set,
		InternalFistula:            internal_fistula_set,
		BloodFlowVolume:            blood_flow_volume_set,
		Anticoagulant:              anticoagulant_set,
		SealingFluidDispose:        sealing_fluid_dispose_set,
		ModeId:                     mode_id_set,
		DialysisTime:               dialysis_time_set,
		DialysisDialyszers:         dialysis_dialyszers_set,
		DialysisIrrigation:         dialysis_irrigation_set,
		Gaijiliang:                 gaijiliang_set,
		Kalium:                     kalium_set,
		DisplaceLiquiValue:         displace_liqui_value_set,
		Bicarbonate:                bicarbonate_set,
		Glucose:                    glucose_set,
		Ctime:                      time.Now().Unix(),
		Mtime:                      time.Now().Unix(),
	}
	err := service.SaveDialysisSetting(dialysisSetting)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"dialysisSetting": dialysisSetting,
		})
		return

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

func (this *DialysisApiController) GetDialysisSetting() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	dialysisSett, _ := service.GetDialysisSetting(orgId)
	this.ServeSuccessJSON(map[string]interface{}{
		"dialysisSett": dialysisSett,
	})
	return
}

func (this *DialysisApiController) GetDialysisParameterList() {

	keyword := this.GetString("keywords")

	limit, _ := this.GetInt64("limit")

	page, _ := this.GetInt64("page")

	partition_id, _ := this.GetInt64("partition_id")

	schedule_type, _ := this.GetInt64("schedule_type")

	start_time := this.GetString("schedule_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

	orgId := this.GetAdminUserInfo().CurrentOrgId

	scheduids := this.GetString("ids")
	var ids []string
	if scheduids != "" {
		ids = strings.Split(scheduids, ",")
	}
	list, total, err := service.GetDialysisParameterList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, ids)

	dialysisSett, _ := service.GetDialysisSetting(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":         list,
			"total":        total,
			"dialysisSett": dialysisSett,
		})
		return

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

func (this *DialysisApiController) GetDialysisGoodTotalCount() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	schedule_type, _ := this.GetInt64("schedule_type")

	partion_type, _ := this.GetInt64("partion_type")

	start_time := this.GetString("selected_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

	list, err := service.GetDialysisGoodTotalCount(orgId, schedule_type, partion_type, startTime.Unix())
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": list,
		})
		return

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

func (this *DialysisApiController) GetDialysisAdviceSchedulist() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	schedule_type, _ := this.GetInt64("schedule_type")

	partion_type, _ := this.GetInt64("partion_type")

	start_time := this.GetString("selected_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

	list, err := service.GetDialysisAdviceSchedulist(orgId, schedule_type, partion_type, startTime.Unix())

	tablelist, _ := service.GetDialysisAdviceSchedulistTwo(orgId, schedule_type, partion_type, startTime.Unix())

	//获取长期医嘱
	adviceList, _ := service.GetAllLongAdviceList(orgId)

	drug, _ := service.GetAllBaseDrugListTwenty(orgId)
	_, config := service.FindXTHisRecordByOrgId(orgId)
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list":       list,
			"drug":       drug,
			"adviceList": adviceList,
			"config":     config,
			"tablelist":  tablelist,
		})
		return

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

func (this *DialysisApiController) GetDialysisParameterGoodList() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	schedule_type, _ := this.GetInt64("schedule_type")

	partion_type, _ := this.GetInt64("partion_type")

	start_time := this.GetString("selected_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

	list, err := service.GetDialysisParameterGoodList(orgId, schedule_type, partion_type, startTime.Unix())
	if err == nil {
		this.ServeSuccessJSON(map[string]interface{}{
			"list": list,
		})
		return

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

func (this *DialysisApiController) SaveHisDialysis() {

	var ids []string
	advice_ids := this.GetString("ids")
	ids = strings.Split(advice_ids, ",")

	orgId := this.GetAdminUserInfo().CurrentOrgId

	service.SaveHisDialysis(orgId, ids)

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

func (this *DialysisApiController) GetHisDialysisGoodCount() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	schedule_type, _ := this.GetInt64("schedule_type")

	partion_type, _ := this.GetInt64("partion_type")

	start_time := this.GetString("selected_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)

	list, _ := service.GetHisDialysisGoodCount(orgId, schedule_type, partion_type, startTime.Unix())

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

func (this *DialysisApiController) GetPatientSchedule() {

	orgId := this.GetAdminUserInfo().CurrentOrgId

	patient_id, _ := this.GetInt64("patient_id")
	schedule_date, _ := this.GetInt64("schedule_date")

	schedulePatient, _ := service.GetScheduleByPatient(patient_id, schedule_date, orgId)

	this.ServeSuccessJSON(map[string]interface{}{
		"schedulePatient": schedulePatient,
	})
}

func (c *DialysisApiController) GetSchedulePrintList() {
	page, _ := c.GetInt64("page", 1)
	limit, _ := c.GetInt64("limit", 10)
	schedulType, _ := c.GetInt64("schedule_type", 0)
	partitionType, _ := c.GetInt64("partition_type", 0)
	keywords := c.GetString("keywords")
	schedule_date := c.GetString("schedule_date")
	timeLayout := "2006-01-02"
	loc, _ := time.LoadLocation("Local")
	var theStartTime int64
	if len(schedule_date) > 0 {
		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", schedule_date+" 00:00:00", loc)
		if err != nil {
			utils.ErrorLog(err.Error())
		}
		theStartTime = theTime.Unix()
	}
	adminUserInfo := c.GetAdminUserInfo()

	list, total, _ := service.GetSchedulePrintList(page, limit, schedulType, partitionType, keywords, theStartTime, adminUserInfo.CurrentOrgId)
	for _, item := range list {
		order, _ := service.GetLastOrder(item.UserOrgId, item.PatientId, item.ScheduleDate)
		item.DialysisOrderTwenty = order
	}
	listOne, _ := service.GetSchedulePrintListOne(page, limit, schedulType, partitionType, keywords, theStartTime, adminUserInfo.CurrentOrgId)
	numberList, _ := service.GetAllBedNumberSix(adminUserInfo.CurrentOrgId)
	c.ServeSuccessJSON(map[string]interface{}{
		"list":       list,
		"total":      total,
		"numberList": numberList,
		"listOne":    listOne,
	})

}

func (this *DialysisApiController) GetSolutionListByOrgId() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	list, _ := service.GetSolutionListByOrgId(orgId)
	for _, item := range list {
		//获取该模式最新的1条数据
		solution, _ := service.GetNewPatientSolutionByModeId(item.PatientId, item.ModeId, orgId)

		//更新状态值
		service.UpdateDialysisSolutionStatus(solution.ID, item.ModeId, orgId, item.PatientId)
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"list": list,
	})

}

func (this *DialysisApiController) ExcutionDoctorAdvice() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	is_open, _ := this.GetInt64("is_open")
	idsStr := this.GetString("str")
	recordIDStrs := strings.Split(idsStr, ",")
	start_time := this.GetString("advice_date")
	exec_time, _ := this.GetInt64("exec_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 {
			//fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}
	config, _ := service.GetDrugOpenConfigOne(orgId)
	pharmacyConfig, _ := service.FindPharmacyConfig(orgId)
	storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
	//his医嘱
	if is_open == 1 {

		groupList, _ := service.GetHisExcutionDoctorAdviceListGroupList(recordIDStrs, startTime, orgId)
		//查找未执行医嘱
		list, _ := service.GetHisExcutionDoctorAdviceList(recordIDStrs, startTime, orgId)
		for _, item := range list {
			if item.Checker == this.GetAdminUserInfo().AdminUser.Id {
				this.ServeSuccessJSON(map[string]interface{}{
					"msg": "3",
				})
				return
			}
		}
		for _, item := range groupList {
			for _, it := range list {
				if item.DrugId == it.DrugId {
					item.ChildDoctorAdvice = append(item.ChildDoctorAdvice, it)
				}
			}
		}

		for _, item := range groupList {
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			var sum_out_count int64
			for _, it := range item.ChildDoctorAdvice {
				var prescribing_number int64
				stringPrescribingNumber := strconv.FormatFloat(it.PrescribingNumber, 'f', -1, 64)
				parseIntPrescribingNumber, _ := strconv.ParseInt(stringPrescribingNumber, 10, 64)
				if it.PrescribingNumberUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber * medical.MinNumber
				}
				if it.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber
				}
				if it.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber
				}
				sum_out_count += prescribing_number
				drugStockOut, _ := service.GetDrugSumOutCountByDrugId(it.DrugId, orgId)
				//库存不足
				if sum_out_count > drugStockOut.FlushCount {
					this.ServeSuccessJSON(map[string]interface{}{
						"msg":  "2",
						"drug": medical,
					})
					return
				}
			}
		}
		creater := this.GetAdminUserInfo().AdminUser.Id
		//执行出库逻辑
		for _, item := range list {
			hisadvice := &models.HisDoctorAdviceInfo{
				ID:                    item.ID,
				UserOrgId:             item.UserOrgId,
				PatientId:             item.PatientId,
				AdviceType:            item.AdviceType,
				AdviceDate:            item.AdviceDate,
				StartTime:             item.StartTime,
				AdviceName:            item.AdviceName,
				AdviceDesc:            item.AdviceDesc,
				ReminderDate:          item.ReminderDate,
				SingleDose:            item.SingleDose,
				SingleDoseUnit:        item.SingleDoseUnit,
				DrugSpec:              item.DrugSpec,
				DrugSpecUnit:          item.DrugSpecUnit,
				PrescribingNumber:     item.PrescribingNumber,
				PrescribingNumberUnit: item.PrescribingNumberUnit,
				DeliveryWay:           item.DeliveryWay,
				ExecutionFrequency:    item.ExecutionFrequency,
				AdviceDoctor:          item.AdviceDoctor,
				Status:                1,
				CreatedTime:           item.CreatedTime,
				UpdatedTime:           item.UpdatedTime,
				AdviceAffirm:          item.AdviceAffirm,
				Remark:                item.Remark,
				StopTime:              item.StopTime,
				StopReason:            item.StopReason,
				StopDoctor:            item.StopDoctor,
				StopState:             item.StopState,
				ParentId:              item.ParentId,
				ExecutionTime:         item.ExecutionTime,
				ExecutionStaff:        creater,
				ExecutionState:        item.ExecutionState,
				Checker:               item.Checker,
				RecordDate:            item.RecordDate,
				DialysisOrderId:       item.DialysisOrderId,
				CheckTime:             item.CheckTime,
				CheckState:            item.CheckState,
				RemindType:            item.RemindType,
				FrequencyType:         item.FrequencyType,
				DayCount:              item.DayCount,
				WeekDay:               item.WeekDay,
				TemplateId:            item.TemplateId,
				Modifier:              item.Modifier,
				Way:                   item.Way,
				DrugId:                item.DrugId,
				ExecutionFrequencyId:  item.ExecutionFrequencyId,
			}
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			if medical.IsUse == 2 {
				if config.IsOpen != 1 {
					if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
						service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, hisadvice)

					}
					//不通过药房发药
					if pharmacyConfig.IsOpen != 1 {
						service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, hisadvice)
					}
					//查询默认仓库
					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)
				}
			}

			info := models.HisDoctorAdviceInfo{
				ExecutionStaff: this.GetAdminUserInfo().AdminUser.Id,
				ExecutionTime:  exec_time,
				ExecutionState: 1,
				UpdatedTime:    time.Now().Unix(),
			}
			//执行医嘱
			service.UpdateHisDoctorAdviceExecution(info, item.ID)

			key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"

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

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

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

	} else {

		groupList, _ := service.GetExcutionDoctorAdviceGroupList(recordIDStrs, startTime, orgId)
		//查找未执行医嘱
		list, _ := service.GetExcutionDoctorAdviceList(recordIDStrs, startTime, orgId)
		for _, item := range groupList {
			for _, it := range list {
				if item.DrugId == it.DrugId {
					item.ChildDoctorAdvice = append(item.ChildDoctorAdvice, it)
				}
			}
		}

		for _, item := range groupList {
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			var sum_out_count int64
			for _, it := range item.ChildDoctorAdvice {
				var prescribing_number int64
				stringPrescribingNumber := strconv.FormatFloat(it.PrescribingNumber, 'f', -1, 64)
				parseIntPrescribingNumber, _ := strconv.ParseInt(stringPrescribingNumber, 10, 64)
				if it.PrescribingNumberUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber * medical.MinNumber
				}
				if it.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber
				}
				if it.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
					prescribing_number = parseIntPrescribingNumber
				}
				sum_out_count += prescribing_number
				drugStockOut, _ := service.GetDrugSumOutCountByDrugId(it.DrugId, orgId)
				//库存不足
				if sum_out_count > drugStockOut.FlushCount {
					this.ServeSuccessJSON(map[string]interface{}{
						"msg":  "2",
						"drug": medical,
					})
					return
				}
			}
		}

		for _, item := range list {
			medical, _ := service.GetBaseDrugMedical(item.DrugId)
			dadvice := &models.DoctorAdvice{
				ID:                    item.ID,
				UserOrgId:             item.UserOrgId,
				PatientId:             item.PatientId,
				AdviceType:            item.AdviceType,
				AdviceDate:            item.AdviceDate,
				StartTime:             item.StartTime,
				AdviceName:            item.AdviceName,
				AdviceDesc:            item.AdviceDesc,
				ReminderDate:          item.ReminderDate,
				SingleDose:            item.SingleDose,
				SingleDoseUnit:        item.SingleDoseUnit,
				DrugSpec:              item.DrugSpec,
				DrugSpecUnit:          item.DrugSpecUnit,
				PrescribingNumber:     item.PrescribingNumber,
				PrescribingNumberUnit: item.PrescribingNumberUnit,
				DeliveryWay:           item.DeliveryWay,
				ExecutionFrequency:    item.ExecutionFrequency,
				AdviceDoctor:          item.AdviceDoctor,
				Status:                1,
				CreatedTime:           item.CreatedTime,
				UpdatedTime:           item.UpdatedTime,
				AdviceAffirm:          item.AdviceAffirm,
				Remark:                item.Remark,
				StopTime:              item.StopTime,
				StopReason:            item.StopReason,
				StopDoctor:            item.StopDoctor,
				StopState:             item.StopState,
				ParentId:              item.ParentId,
				ExecutionTime:         item.ExecutionTime,
				ExecutionStaff:        item.ExecutionStaff,
				ExecutionState:        item.ExecutionState,
				Checker:               item.Checker,
				RecordDate:            item.ReminderDate,
				DialysisOrderId:       item.DialysisOrderId,
				CheckTime:             item.CheckTime,
				CheckState:            item.CheckState,
				RemindType:            item.RemindType,
				FrequencyType:         item.FrequencyType,
				DayCount:              item.DayCount,
				WeekDay:               item.WeekDay,
				TemplateId:            item.TemplateId,
				Modifier:              item.Modifier,
				Way:                   item.Way,
				DrugId:                item.DrugId,
			}
			if medical.IsUse == 2 {
				if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
					service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, dadvice)
				}
				if pharmacyConfig.IsOpen != 1 {
					service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, dadvice)
				}

				//更新字典里面的库存
				stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
				var sum_count int64
				for _, its := range stockInfo {
					baseDrug, _ := service.GetBaseDrugMedical(its.DrugId)
					if its.MaxUnit == baseDrug.MaxUnit {
						its.StockMaxNumber = its.StockMaxNumber * baseDrug.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)
			}

			info := models.DoctorAdvice{
				ExecutionStaff: this.GetAdminUserInfo().AdminUser.Id,
				ExecutionTime:  exec_time,
				ExecutionState: 1,
				UpdatedTime:    time.Now().Unix(),
			}
			//执行医嘱
			service.UpdateDoctorAdviceExecution(info, item.ID)
		}

	}

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

func (this *DialysisApiController) CheckNewDoctorAdvice() {

	orgId := this.GetAdminUserInfo().CurrentOrgId
	idsStr := this.GetString("str")
	recordIDStrs := strings.Split(idsStr, ",")
	start_time := this.GetString("advice_date")
	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 {
			//fmt.Println(err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}

	config, _ := service.FindXTHisRecordByOrgIdSix(orgId)

	if config.IsOpen == 1 {

		creater := this.GetAdminUserInfo().AdminUser.Id
		//查询未核对的医嘱
		advicelist, _ := service.GetHisCheckDoctorAdvice(orgId, recordIDStrs, startTime)
		for _, item := range advicelist {
			if item.ExecutionStaff == creater {
				this.ServeSuccessJSON(map[string]interface{}{
					"msg":    "2",
					"advice": item,
				})
				return
			}

			service.CheckHisDoctorAdvice(item.ID, creater)

			key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			theTime := time.Now()
			recordDate := theTime.Format("2006-01-02")
			keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(orgId, 10)

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

		}
	} else {

		//查询未核对的医嘱
		advicelist, _ := service.GetCheckDoctorAdvice(orgId, recordIDStrs, startTime)
		creater := this.GetAdminUserInfo().AdminUser.Id
		for _, item := range advicelist {
			if item.ExecutionStaff == creater {
				this.ServeSuccessJSON(map[string]interface{}{
					"msg":    "2",
					"advice": item,
				})
				return
			}

			service.CheckDoctorAdvice(item.ID, creater)
			key := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":doctor_advices"
			redis := service.RedisClient()
			//清空key 值
			redis.Set(key, "", time.Second)
			keyTwo := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":advice_list_all"
			redis.Set(keyTwo, "", time.Second)
			keyThree := strconv.FormatInt(orgId, 10) + ":" + strconv.FormatInt(item.PatientId, 10) + ":" + strconv.FormatInt(item.AdviceDate, 10) + ":his_doctor_advice"
			redis.Set(keyThree, "", time.Second)
			theTime := time.Now()
			recordDate := theTime.Format("2006-01-02")
			keyFour := "scheduals_" + recordDate + "_" + strconv.FormatInt(orgId, 10)

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

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

}

func (this *DialysisApiController) SettleNewDoctorAdvice() {
	orgId := this.GetAdminUserInfo().CurrentOrgId
	is_open, _ := this.GetInt64("is_open")
	idsStr := this.GetString("str")
	recordIDStrs := strings.Split(idsStr, ",")
	start_time := this.GetString("advice_date")
	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 {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
			return
		}
		startTime = theTime.Unix()
	}

	if is_open == 1 {
		service.SettleHisNewDoctorAdvice(recordIDStrs, startTime, orgId)
	} else {
		service.SettleNewDoctorAdvice(recordIDStrs, startTime, orgId)
	}

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

func (this *DialysisApiController) ExcutionDoctorAdviceById() {

	advice_id, _ := this.GetInt64("advice_id")
	start_time := this.GetString("advice_date")
	orgId := this.GetAdminUserInfo().CurrentOrgId
	config, _ := service.FindXTHisRecordByOrgIdSix(orgId)
	exec_time, _ := this.GetInt64("exec_time")

	//his医嘱
	if config.IsOpen == 1 {

		//查询医嘱
		advice, _ := service.GetHisDocById(advice_id, orgId)
		if advice.Checker == this.GetAdminUserInfo().AdminUser.Id {
			this.ServeSuccessJSON(map[string]interface{}{
				"msg": "3",
			})
			return
		}
		medical, _ := service.GetBaseDrugMedical(orgId)
		var prescribing_number int64
		stringPrescribingNumber := strconv.FormatFloat(advice.PrescribingNumber, 'f', -1, 64)
		parseIntPrescribingNumber, _ := strconv.ParseInt(stringPrescribingNumber, 10, 64)
		if advice.PrescribingNumberUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber * medical.MinNumber
		}
		if advice.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber
		}
		if advice.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber
		}

		drugStockOut, _ := service.GetDrugSumOutCountByDrugId(advice.DrugId, orgId)
		//库存不足
		if prescribing_number > drugStockOut.FlushCount {
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":  "2",
				"drug": medical,
			})
			return
		}
		info := models.HisDoctorAdviceInfo{
			ExecutionStaff: this.GetAdminUserInfo().AdminUser.Id,
			ExecutionTime:  exec_time,
			ExecutionState: 1,
			UpdatedTime:    time.Now().Unix(),
		}
		//执行医嘱
		service.UpdateHisDoctorAdviceExecution(info, advice.ID)

		key := strconv.FormatInt(orgId, 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(orgId, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":advice_list_all"

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

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

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

		//出库
		if prescribing_number <= drugStockOut.FlushCount {
			pharmacyConfig, _ := service.FindPharmacyConfig(orgId)
			//执行出库逻辑
			hisadvice := &models.HisDoctorAdviceInfo{
				ID:                    advice.ID,
				UserOrgId:             advice.UserOrgId,
				PatientId:             advice.PatientId,
				AdviceType:            advice.AdviceType,
				AdviceDate:            advice.AdviceDate,
				StartTime:             advice.StartTime,
				AdviceName:            advice.AdviceName,
				AdviceDesc:            advice.AdviceDesc,
				ReminderDate:          advice.ReminderDate,
				SingleDose:            advice.SingleDose,
				SingleDoseUnit:        advice.SingleDoseUnit,
				DrugSpec:              advice.DrugSpec,
				DrugSpecUnit:          advice.DrugSpecUnit,
				PrescribingNumber:     advice.PrescribingNumber,
				PrescribingNumberUnit: advice.PrescribingNumberUnit,
				DeliveryWay:           advice.DeliveryWay,
				ExecutionFrequency:    advice.ExecutionFrequency,
				AdviceDoctor:          advice.AdviceDoctor,
				Status:                1,
				CreatedTime:           advice.CreatedTime,
				UpdatedTime:           advice.UpdatedTime,
				AdviceAffirm:          advice.AdviceAffirm,
				Remark:                advice.Remark,
				StopTime:              advice.StopTime,
				StopReason:            advice.StopReason,
				StopDoctor:            advice.StopDoctor,
				StopState:             advice.StopState,
				ParentId:              advice.ParentId,
				ExecutionTime:         advice.ExecutionTime,
				ExecutionStaff:        this.GetAdminUserInfo().AdminUser.Id,
				ExecutionState:        advice.ExecutionState,
				Checker:               advice.Checker,
				RecordDate:            advice.RecordDate,
				DialysisOrderId:       advice.DialysisOrderId,
				CheckTime:             advice.CheckTime,
				CheckState:            advice.CheckState,
				RemindType:            advice.RemindType,
				FrequencyType:         advice.FrequencyType,
				DayCount:              advice.DayCount,
				WeekDay:               advice.WeekDay,
				TemplateId:            advice.TemplateId,
				Modifier:              advice.Modifier,
				Way:                   advice.Way,
				DrugId:                advice.DrugId,
				ExecutionFrequencyId:  advice.ExecutionFrequencyId,
			}
			if medical.IsUse == 2 {
				if config.IsOpen != 1 {
					if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
						service.HisDrugsDelivery(advice.UserOrgId, advice.ExecutionStaff, hisadvice)

					}
					//不通过药房发药
					if pharmacyConfig.IsOpen != 1 {
						service.HisDrugsDelivery(advice.UserOrgId, advice.ExecutionStaff, hisadvice)
					}
					//查询默认仓库
					storeHouseConfig, _ := service.GetAllStoreHouseConfig(advice.UserOrgId)
					//查询默认仓库剩余多少库存
					var sum_count int64
					stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
					for _, its := range stockInfo {
						if its.MaxUnit == medical.MaxUnit {
							its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
						}
						sum_count += its.StockMaxNumber + its.StockMinNumber
					}
					service.UpdateBaseDrugSumTwo(advice.DrugId, sum_count, advice.UserOrgId)
					service.UpdateDrugStockCount(advice.DrugId, advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
				}
			}
		}

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

	if config.IsOpen == 2 || config.IsOpen == 0 {

		advice, _ := service.GetBloodDocById(advice_id, orgId)
		medical, _ := service.GetBaseDrugMedical(orgId)
		pharmacyConfig, _ := service.FindPharmacyConfig(orgId)
		storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
		var prescribing_number int64
		stringPrescribingNumber := strconv.FormatFloat(advice.PrescribingNumber, 'f', -1, 64)
		parseIntPrescribingNumber, _ := strconv.ParseInt(stringPrescribingNumber, 10, 64)
		if advice.PrescribingNumberUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber * medical.MinNumber
		}
		if advice.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber
		}
		if advice.PrescribingNumberUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
			prescribing_number = parseIntPrescribingNumber
		}
		drugStockOut, _ := service.GetDrugSumOutCountByDrugId(advice.DrugId, orgId)
		//库存不足
		if prescribing_number > drugStockOut.FlushCount {
			this.ServeSuccessJSON(map[string]interface{}{
				"msg":  "2",
				"drug": medical,
			})
			return
		}
		info := models.DoctorAdvice{
			ExecutionStaff: this.GetAdminUserInfo().AdminUser.Id,
			ExecutionTime:  exec_time,
			ExecutionState: 1,
			UpdatedTime:    time.Now().Unix(),
		}
		//执行医嘱
		service.UpdateDoctorAdviceExecution(info, advice.ID)

		dadvice := &models.DoctorAdvice{
			ID:                    advice.ID,
			UserOrgId:             advice.UserOrgId,
			PatientId:             advice.PatientId,
			AdviceType:            advice.AdviceType,
			AdviceDate:            advice.AdviceDate,
			StartTime:             advice.StartTime,
			AdviceName:            advice.AdviceName,
			AdviceDesc:            advice.AdviceDesc,
			ReminderDate:          advice.ReminderDate,
			SingleDose:            advice.SingleDose,
			SingleDoseUnit:        advice.SingleDoseUnit,
			DrugSpec:              advice.DrugSpec,
			DrugSpecUnit:          advice.DrugSpecUnit,
			PrescribingNumber:     advice.PrescribingNumber,
			PrescribingNumberUnit: advice.PrescribingNumberUnit,
			DeliveryWay:           advice.DeliveryWay,
			ExecutionFrequency:    advice.ExecutionFrequency,
			AdviceDoctor:          advice.AdviceDoctor,
			Status:                1,
			CreatedTime:           advice.CreatedTime,
			UpdatedTime:           advice.UpdatedTime,
			AdviceAffirm:          advice.AdviceAffirm,
			Remark:                advice.Remark,
			StopTime:              advice.StopTime,
			StopReason:            advice.StopReason,
			StopDoctor:            advice.StopDoctor,
			StopState:             advice.StopState,
			ParentId:              advice.ParentId,
			ExecutionTime:         advice.ExecutionTime,
			ExecutionStaff:        advice.ExecutionStaff,
			ExecutionState:        advice.ExecutionState,
			Checker:               advice.Checker,
			RecordDate:            advice.ReminderDate,
			DialysisOrderId:       advice.DialysisOrderId,
			CheckTime:             advice.CheckTime,
			CheckState:            advice.CheckState,
			RemindType:            advice.RemindType,
			FrequencyType:         advice.FrequencyType,
			DayCount:              advice.DayCount,
			WeekDay:               advice.WeekDay,
			TemplateId:            advice.TemplateId,
			Modifier:              advice.Modifier,
			Way:                   advice.Way,
			DrugId:                advice.DrugId,
		}
		if medical.IsUse == 2 {
			if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
				service.DrugsDelivery(advice.UserOrgId, advice.ExecutionStaff, dadvice)
			}
			if pharmacyConfig.IsOpen != 1 {
				service.DrugsDelivery(advice.UserOrgId, advice.ExecutionStaff, dadvice)
			}

			//更新字典里面的库存
			stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
			var sum_count int64
			for _, its := range stockInfo {
				baseDrug, _ := service.GetBaseDrugMedical(its.DrugId)
				if its.MaxUnit == baseDrug.MaxUnit {
					its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
				}
				sum_count += its.StockMaxNumber + its.StockMinNumber
			}
			service.UpdateBaseDrugSumTwo(advice.DrugId, sum_count, advice.UserOrgId)
			//剩余库存
			service.UpdateDrugStockCount(advice.DrugId, advice.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"msg": "1",
	})
	return

}