XT_New/controllers/dialysis_record_api_control...

package controllers

import (
	"XT_New/models"
	"encoding/json"
	"github.com/jinzhu/gorm"
	"math"
	"strconv"
	"time"

	"XT_New/enums"
	"XT_New/service"
	"XT_New/utils"
	"fmt"
	"github.com/astaxie/beego"
	"net/http"
	"net/url"
)

func DialysisRecordAPIControllerRegistRouter() {
	beego.Router("/api/dialysis/initdata", &DialysisRecordAPIController{}, "get:RecordInitData")
	beego.Router("/api/dialysis/schedules", &DialysisRecordAPIController{}, "get:GetSchedules")
	beego.Router("/api/dislysis/schedule", &DialysisRecordAPIController{}, "get:DialysisSchedule")
	beego.Router("/api/dislysis/monitor/edit", &DialysisRecordAPIController{}, "post:EditMonitor")
	beego.Router("/api/dialysis/start_record", &DialysisRecordAPIController{}, "post:StartDialysis")
	beego.Router("/api/dialysis/finish", &DialysisRecordAPIController{}, "post:FinishDialysis")
	beego.Router("/api/start_dialysis/modify", &DialysisRecordAPIController{}, "post:ModifyStartDialysis")
	beego.Router("/api/finish_dialysis/modify", &DialysisRecordAPIController{}, "post:ModifyFinishDialysis")

}

type DialysisRecordAPIController struct {
	BaseAuthAPIController
}

// /api/dialysis/initdata [get]
func (this *DialysisRecordAPIController) RecordInitData() {
	adminInfo := this.GetAdminUserInfo()
	orgID := adminInfo.CurrentOrgId

	now := time.Now()
	ymdDate, _ := utils.ParseTimeStringToTime("2006-01-02", now.Format("2006-01-02"))
	schedules, getSchedulesErr := service.GetDialysisScheduals(orgID, ymdDate.Unix())
	if getSchedulesErr != nil {
		this.ErrorLog("获取排班信息失败:%v", getSchedulesErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	zones, getZonesErr := service.GetAllValidDeviceZones(orgID)
	if getZonesErr != nil {
		this.ErrorLog("获取全部分区失败:%v", getZonesErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

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

// /api/dialysis/schedules [get]
// @param date:string (yyyy-mm-dd)
func (this *DialysisRecordAPIController) GetSchedules() {
	schedualDate := this.GetString("date")

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

	adminInfo := this.GetAdminUserInfo()
	orgID := adminInfo.CurrentOrgId

	redis := service.RedisClient()
	defer redis.Close()
	key := "scheduals_" + schedualDate + "_" + strconv.FormatInt(orgID, 10)
	patients, _ := service.GetAllPcPatientListByListEight(orgID)
	scheduals_json_str, _ := redis.Get(key).Result()

	if len(scheduals_json_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
		scheduals, err := service.GetDialysisSchedualsOne(orgID, date.Unix())

		if err != nil {
			this.ErrorLog("获取排班信息失败:%v", err)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		} else {
			if len(scheduals) > 0 {

				dialysisOrders, _ := service.GetAllPcDialysisOrdersByList(orgID, date.Unix())

				prescriptions, _ := service.GetAllPrescriptionsByList(orgID, date.Unix())

				assessmentBefores, _ := service.GetAllAssessmentBeforesByList(orgID, date.Unix())

				treatmentSummarys, _ := service.GetAllPcTreatmentSummarysByList(orgID, date.Unix())

				AssessmentAfterDislysis, _ := service.GetAllPcAssessmentAfterDislysisByList(orgID, date.Unix())

				advices, _ := service.GetAllPcAdvicestByList(orgID, date.Unix())

				for key, item := range scheduals {
					// 获取患者信息
					for _, patient := range patients {
						if item.PatientId == patient.ID {
							scheduals[key].SchedualPatient = patient
							break
						}
					}

					for _, advice := range advices {
						if item.PatientId == advice.PatientId {
							scheduals[key].Advices = append(scheduals[key].Advices, advice)
						}
					}

					// 医嘱信息
					for _, prescription := range prescriptions {
						if item.PatientId == prescription.PatientId {
							scheduals[key].Prescription = prescription
							break
						}
					}

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

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

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

					// 透后评估
					for _, treatmentSummary := range treatmentSummarys {
						if item.PatientId == treatmentSummary.PatientId {
							scheduals[key].TreatmentSummary = treatmentSummary
							break
						}
					}
				}

				//缓存数据
				scheduals_json, err := json.Marshal(&scheduals)
				if err == nil {
					redis.Set(key, scheduals_json, time.Second*60)
				}
			}

			_, errcodes := service.GetOrgFollowIsExist(orgID)
			if errcodes == gorm.ErrRecordNotFound {
				information, _ := service.GetAdminUserRoleInformation(0)
				this.ServeSuccessJSON(map[string]interface{}{
					"schedules":   scheduals,
					"information": information,
				})
			} else if errcodes == nil {
				information, _ := service.GetAdminUserRoleInformation(orgID)
				this.ServeSuccessJSON(map[string]interface{}{
					"schedules":   scheduals,
					"information": information,
				})
			}

		}

	} else { //缓存数据了数据，将redis缓存的json字符串转为map
		var dat []map[string]interface{}

		if err := json.Unmarshal([]byte(scheduals_json_str), &dat); err == nil {

		} else {

		}

		_, errcodes := service.GetOrgFollowIsExist(orgID)
		if errcodes == gorm.ErrRecordNotFound {
			information, _ := service.GetAdminUserRoleInformation(0)
			this.ServeSuccessJSON(map[string]interface{}{
				"schedules":   dat,
				"information": information,
			})
		} else if errcodes == nil {
			information, _ := service.GetAdminUserRoleInformation(orgID)
			this.ServeSuccessJSON(map[string]interface{}{
				"schedules":   dat,
				"information": information,
			})
		}

	}

	//if err != nil {
	//	this.ErrorLog("获取排班信息失败:%v", err)
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//} else {
	//	this.ServeSuccessJSON(map[string]interface{}{
	//		"schedules": schedules,
	//	})
	//}
}

// /api/dislysis/schedule [get]
// @param patient_id:int
// @param date:string (yyyy-MM-dd)
func (this *DialysisRecordAPIController) DialysisSchedule() {
	patientID, _ := this.GetInt64("patient_id")
	recordDateStr := this.GetString("date")
	if patientID <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	if len(recordDateStr) == 0 {
		recordDateStr = time.Now().Format("2006-01-02")
	}
	date, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseDateErr != nil {
		this.ErrorLog("日期(%v)解析错误：%v", recordDateStr, parseDateErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminInfo := this.GetAdminUserInfo()
	ch := make(chan struct{})
	count := 15 // count 表示活动的协程个数
	var patient *service.MPatient
	var schedual *service.MDialysisScheduleVM
	var receiverTreatmentAccess *models.ReceiveTreatmentAsses
	var predialysisEvaluation *models.PredialysisEvaluation
	var doctorAdvices []*models.DoctorAdvice
	var dialysisOrder *models.DialysisOrder
	var doubleCheck *models.DoubleCheck
	var monitorRecords []*models.MonitoringRecord
	var assessmentAfterDislysis *models.AssessmentAfterDislysis
	var treatmentSummary *models.TreatmentSummary
	var record models.GobalConfig
	var is_open_config models.XtHisConfig
	var stockType []*models.GoodsTypeOne
	var prepare []*models.XtDialysisBeforePrepare
	var lastAssessment models.XtPatientVascularAccess
	go func() {
		patient, _ = service.MobileGetPatientDetail(adminInfo.CurrentOrgId, patientID)
		ch <- struct{}{}
	}()

	go func() {
		schedual, _ = service.MobileGetSchedualDetail(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		receiverTreatmentAccess, _ = service.MobileGetReceiverTreatmentAccessRecord(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		predialysisEvaluation, _ = service.MobileGetPredialysisEvaluation(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		doctorAdvices, _ = service.MobileGetDoctorAdvices(adminInfo.CurrentOrgId, patientID, date.Unix())

		ch <- struct{}{}
	}()

	go func() {
		dialysisOrder, _ = service.MobileGetSchedualDialysisRecord(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		doubleCheck, _ = service.MobileGetDoubleCheck(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		monitorRecords, _ = service.MobileGetMonitorRecords(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		assessmentAfterDislysis, _ = service.MobileGetAssessmentAfterDislysis(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		treatmentSummary, _ = service.MobileGetTreatmentSummary(adminInfo.CurrentOrgId, patientID, date.Unix())
		ch <- struct{}{}
	}()

	go func() {
		_, record = service.FindAutomaticReduceRecordByOrgId(adminInfo.CurrentOrgId)
		ch <- struct{}{}
	}()

	go func() {
		_, is_open_config = service.FindXTHisRecordByOrgId(adminInfo.CurrentOrgId)
		ch <- struct{}{}
	}()

	go func() {
		//获取耗材类型
		stockType, _ = service.GetStockType(adminInfo.CurrentOrgId)
		ch <- struct{}{}
	}()

	go func() {
		prepare, _ = service.GetDialyStockOut(adminInfo.CurrentOrgId, date.Unix(), patientID)

		ch <- struct{}{}
	}()

	go func() {
		//获取患者的最后一次血管通路数据
		lastAssessment, _ = service.GetLastPassWayAssessment(adminInfo.CurrentOrgId, patientID)
		ch <- struct{}{}
	}()

	for range ch {
		// 每次从ch中接收数据，表明一个活动的协程结束
		count--
		// 当所有活动的协程都结束时，关闭管道
		if count == 0 {
			close(ch)
		}
	}

	admins, getAdminsErr := service.GetAllAdminUsers(adminInfo.CurrentOrgId, adminInfo.CurrentAppId)
	if getAdminsErr != nil {
		this.ErrorLog("获取医护列表失败：%v", getAdminsErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	devices, getDevicesErr := service.GetValidDevicesBy(adminInfo.CurrentOrgId, 0, 0)
	if getDevicesErr != nil {
		this.ErrorLog("获取设备列表失败：%v", getDevicesErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	deviceNumbers, getDeviceNumbersErr := service.GetAllValidDeviceNumbers(adminInfo.CurrentOrgId)
	if getDeviceNumbersErr != nil {
		this.ErrorLog("获取床位号列表失败:%v", getDeviceNumbersErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	lastPredialysisEvaluation, getLPEErr := service.GetLastTimePredialysisEvaluation(adminInfo.CurrentOrgId, patientID, date.Unix())
	if getLPEErr != nil {
		this.ErrorLog("获取上一次透前评估失败:%v", getLPEErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	var lastMonitorRecord *models.MonitoringRecord

	lastMonitorRecord, getLastErr := service.GetLastMonitorRecord(adminInfo.CurrentOrgId, patientID, date.Unix())
	if getLastErr != nil {
		this.ErrorLog("获取上一次透析的监测记录失败:%v", getLastErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	lastAssessmentAfterDislysis, getLAADErr := service.GetLastTimeAssessmentAfterDislysis(adminInfo.CurrentOrgId, patientID, date.Unix())
	if getLAADErr != nil {
		this.ErrorLog("获取上一次透后评估失败:%v", getLAADErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	dialysisPrescribe, _ := service.GetDialysisPrescribe(adminInfo.CurrentOrgId, patientID, date.Unix())

	dialysisSolution, _ := service.GetDialysisSolution(adminInfo.CurrentOrgId, patientID, schedual.ModeId)

	lastDialysisPrescribe, _ := service.GetLastDialysisPrescribeByModeId(adminInfo.CurrentOrgId, patientID, schedual.ModeId)

	systemDialysisPrescribe, _ := service.GetSystemDialysisPrescribeByModeId(adminInfo.CurrentOrgId, schedual.ModeId)

	lastDryWeightDislysis, getDryErr := service.GetLastDryWeight(adminInfo.CurrentOrgId, patientID)
	if getDryErr != nil {
		this.ErrorLog("获取最后一条干体重失败:%v", getDryErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	headNurses, _ := service.GetAllSpecialPermissionAdminUsersWithoutStatus(adminInfo.CurrentOrgId, adminInfo.CurrentAppId, models.SpecialPermissionTypeHeadNurse)

	var his_advices []*models.HisDoctorAdviceInfo

	if is_open_config.IsOpen == 1 {
		his_advices, _ = service.GetAllHisDoctorAdvice(adminInfo.CurrentOrgId, patientID, date.Unix())
	}
	//查询是否是开起
	adviceConfig, _ := service.FindAdviceSettingById(adminInfo.CurrentOrgId)
	if adviceConfig.IsAdviceOpen == 1 {
		his_advices, _ = service.GetAllHisDoctorAdvice(adminInfo.CurrentOrgId, patientID, date.Unix())
	}

	_, errcode := service.GetOrgFollowIsExist(adminInfo.CurrentOrgId)
	if errcode == gorm.ErrRecordNotFound {
		information, _ := service.GetAdminUserRoleInformation(0)
		returnData := map[string]interface{}{
			"patient":                     patient,
			"schedual":                    schedual,
			"prescription":                dialysisPrescribe,
			"solution":                    dialysisSolution,
			"receiver_treatment_access":   receiverTreatmentAccess,
			"predialysis_evaluation":      predialysisEvaluation,
			"doctor_advices":              doctorAdvices,
			"double_check":                doubleCheck,
			"assessment_after_dislysis":   assessmentAfterDislysis,
			"treatment_summary":           treatmentSummary,
			"monitor_records":             monitorRecords,
			"dialysis_order":              dialysisOrder,
			"doctors":                     admins,
			"config":                      record,
			"devices":                     devices,
			"device_numbers":              deviceNumbers,
			"lastPredialysisEvaluation":   lastPredialysisEvaluation,
			"lastMonitorRecord":           lastMonitorRecord,
			"lastAssessmentAfterDislysis": lastAssessmentAfterDislysis,
			"lastDialysisPrescribe":       lastDialysisPrescribe,
			"lastDryWeightDislysis":       lastDryWeightDislysis,
			"headNurses":                  headNurses,
			"system_prescribe":            systemDialysisPrescribe,
			"his_advices":                 his_advices,
			"is_open_config":              is_open_config,
			"stockType":                   stockType,
			"prepare":                     prepare,
			"lastAssessment":              lastAssessment,
			"information":                 information,
			"is_advice_open":              adviceConfig,
		}
		this.ServeSuccessJSON(returnData)

	} else if errcode == nil {
		information, _ := service.GetAdminUserRoleInformation(adminInfo.CurrentOrgId)
		returnData := map[string]interface{}{
			"patient":                     patient,
			"schedual":                    schedual,
			"prescription":                dialysisPrescribe,
			"solution":                    dialysisSolution,
			"receiver_treatment_access":   receiverTreatmentAccess,
			"predialysis_evaluation":      predialysisEvaluation,
			"doctor_advices":              doctorAdvices,
			"double_check":                doubleCheck,
			"assessment_after_dislysis":   assessmentAfterDislysis,
			"treatment_summary":           treatmentSummary,
			"monitor_records":             monitorRecords,
			"dialysis_order":              dialysisOrder,
			"doctors":                     admins,
			"config":                      record,
			"devices":                     devices,
			"device_numbers":              deviceNumbers,
			"lastPredialysisEvaluation":   lastPredialysisEvaluation,
			"lastMonitorRecord":           lastMonitorRecord,
			"lastAssessmentAfterDislysis": lastAssessmentAfterDislysis,
			"lastDialysisPrescribe":       lastDialysisPrescribe,
			"lastDryWeightDislysis":       lastDryWeightDislysis,
			"headNurses":                  headNurses,
			"system_prescribe":            systemDialysisPrescribe,
			"his_advices":                 his_advices,
			"is_open_config":              is_open_config,
			"stockType":                   stockType,
			"prepare":                     prepare,
			"lastAssessment":              lastAssessment,
			"information":                 information,
			"is_advice_open":              adviceConfig,
		}
		this.ServeSuccessJSON(returnData)
	}

}

type EditMonitorParamObject struct {
	ID             int64 `json:"id"`
	MonitoringDate int64 `json:"monitoring_date"`
	OperateTime    int64 `json:"operate_time"`
	// MonitoringTime        string  `json:"monitoring_time"`
	SystolicBP                  float64 `json:"systolic_bp"`
	DiastolicBP                 float64 `json:"diastolic_bp"`
	PulseFrequency              float64 `json:"pulse_frequency"`
	BreathingRated              string  `json:"breathing_rated"`
	BloodFlowVolume             float64 `json:"blood_flow_volume"`
	VenousPressure              float64 `json:"venous_pressure"`
	VenousPressureType          int64   `json:"venous_pressure_type"`
	TransmembranePressure       float64 `json:"transmembrane_pressure"`
	TransmembranePressureType   int64   `json:"transmembrane_pressure_type"`
	UltrafiltrationVolume       float64 `json:"ultrafiltration_volume"`
	UltrafiltrationRate         float64 `json:"ultrafiltration_rate"`
	ArterialPressure            float64 `json:"arterial_pressure"`
	ArterialPressureType        int64   `json:"arterial_pressure_type"`
	SodiumConcentration         float64 `json:"sodium_concentration"`
	DialysateTemperature        float64 `json:"dialysate_temperature"`
	Temperature                 float64 `json:"temperature"`
	ReplacementRate             float64 `json:"replacement_rate"`
	DisplacementQuantity        float64 `json:"displacement_quantity"`
	KTV                         float64 `json:"ktv"`
	Symptom                     string  `json:"symptom"`
	Dispose                     string  `json:"dispose"`
	Result                      string  `json:"result"`
	Conductivity                float64 `json:"conductivity"`
	DisplacementFlowQuantity    float64 `json:"displacement_flow_quantity"`
	BloodOxygenSaturation       string  `gorm:"column:blood_oxygen_saturation" json:"blood_oxygen_saturation" form:"blood_oxygen_saturation"`
	Heparin                     float64 `gorm:"column:heparin" json:"heparin" form:"heparin"`
	DialysateFlow               float64 `gorm:"column:dialysate_flow" json:"dialysate_flow" form:"dialysate_flow"`
	Urr                         string  `gorm:"column:urr" json:"urr" form:"urr"`
	BloodSugar                  float64 `gorm:"column:blood_sugar" json:"blood_sugar" form:"blood_sugar"`
	MonitorAnticoagulant        int64   `gorm:"column:monitor_anticoagulant" json:"monitor_anticoagulant" form:"monitor_anticoagulant"`
	MonitorAnticoagulantValue   string  `gorm:"column:monitor_anticoagulant_value" json:"monitor_anticoagulant_value" form:"monitor_anticoagulant_value"`
	BloodPressureMonitoringSite int64   `gorm:"column:blood_pressure_monitoring_site" json:"blood_pressure_monitoring_site" form:"blood_pressure_monitoring_site"`
	Complication                int64   `gorm:"column:complication" json:"complication" form:"complication"`
	AccumulatedBloodVolume      float64 `gorm:"column:accumulated_blood_volume" json:"accumulated_blood_volume" form:"accumulated_blood_volume"`
	BloodTemperature            float64 `gorm:"column:blood_temperature" json:"blood_temperature" form:"blood_temperature"`
	UreaMonitoring              float64 `gorm:"column:urea_monitoring" json:"urea_monitoring" form:"urea_monitoring"`
	BloodThickness              float64 `gorm:"column:blood_thickness" json:"blood_thickness" form:"blood_thickness"`
	BloodMonitor                float64 `gorm:"column:blood_monitor" json:"blood_monitor" form:"blood_monitor"`
	HeparinAmount               float64 `gorm:"column:heparin_amount" json:"heparin_amount" form:"heparin_amount"`
	Dehydration                 float64 `gorm:"column:dehydration" json:"dehydration" form:"dehydration"`
}

// /api/dislysis/monitor/edit [post]
// @param patient_id:int 患者id
// @param schedule_date:int 排班日期
// 下面的参数放到 body
// @param id?:int 监测记录ID（id为0时为创建记录，不为0时为修改记录）
// @param monitoring_date:int 排班日期
// @param operate_time:int 实际测量日期
// @param monitoring_time:string (HH:mm) 监测时间 废弃
// @param systolic_bp?:float 收缩压
// @param diastolic_bp?:float 舒张压
// @param pulse_frequency?:float 心率
// @param breathing_rated?:float 呼吸频率
// @param blood_flow_volume?:float 血流量
// @param venous_pressure?:float 静脉压
// @param transmembrane_pressure?:float 跨膜压
// @param ultrafiltration_volume?:float 超滤量
// @param ultrafiltration_rate?:float 超滤率
// @param arterial_pressure?:float 动脉压
// @param sodium_concentration?:float 钠浓度
// @param dialysate_temperature?:float 透析液温度
// @param replacement_rate?:float 置换率
// @param displacement_quantity?:float 置换量
// @param ktv?:float KT/V
// @param symptom?:string 病情变化
// @param dispose?:string 处理
// @param result?:string 结果
func (this *DialysisRecordAPIController) EditMonitor() {
	patientID, _ := this.GetInt64("patient_id")
	scheduleDate, _ := this.GetInt64("schedule_date")
	if patientID <= 0 || scheduleDate <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	var monitorParam EditMonitorParamObject
	if parseErr := json.Unmarshal(this.Ctx.Input.RequestBody, &monitorParam); parseErr != nil {
		this.ErrorLog("参数解析失败:%v", parseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamFormatWrong)
		return
	}
	if monitorParam.MonitoringDate != scheduleDate {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := this.GetAdminUserInfo()
	schedule, getScheduleErr := service.MobileGetSchedualDetail(adminUserInfo.CurrentOrgId, patientID, scheduleDate)
	if getScheduleErr != nil {
		this.ErrorLog("获取排班信息失败：%v", getScheduleErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if schedule == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeScheduleNotExist)
		return
	}
	// TODO 其实这里合理的逻辑是“透析记录存在的情况下才能添加监测记录的”
	dialysisOrder, getDialysisOrderErr := service.MobileGetDialysisRecord(adminUserInfo.CurrentOrgId, patientID, scheduleDate)
	if getDialysisOrderErr != nil {
		this.ErrorLog("获取透析记录失败：%v", getDialysisOrderErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	orderID := int64(0)
	if dialysisOrder != nil {
		orderID = dialysisOrder.ID
	}

	if monitorParam.ID <= 0 { // 新建记录
		monitor := models.MonitoringRecord{
			UserOrgId:       adminUserInfo.CurrentOrgId,
			PatientId:       patientID,
			DialysisOrderId: orderID,
			MonitoringDate:  monitorParam.MonitoringDate,
			OperateTime:     monitorParam.OperateTime,
			// MonitoringTime:         monitorParam.MonitoringTime,
			PulseFrequency:              monitorParam.PulseFrequency,
			BreathingRate:               monitorParam.BreathingRated,
			SystolicBloodPressure:       monitorParam.SystolicBP,
			DiastolicBloodPressure:      monitorParam.DiastolicBP,
			BloodFlowVolume:             monitorParam.BloodFlowVolume,
			VenousPressure:              monitorParam.VenousPressure,
			VenousPressureType:          monitorParam.VenousPressureType,
			ArterialPressure:            monitorParam.ArterialPressure,
			ArterialPressureType:        monitorParam.ArterialPressureType,
			TransmembranePressure:       monitorParam.TransmembranePressure,
			TransmembranePressureType:   monitorParam.TransmembranePressureType,
			UltrafiltrationRate:         monitorParam.UltrafiltrationRate,
			UltrafiltrationVolume:       monitorParam.UltrafiltrationVolume,
			SodiumConcentration:         monitorParam.SodiumConcentration,
			DialysateTemperature:        monitorParam.DialysateTemperature,
			Temperature:                 monitorParam.Temperature,
			ReplacementRate:             monitorParam.ReplacementRate,
			DisplacementQuantity:        monitorParam.DisplacementQuantity,
			Ktv:                         monitorParam.KTV,
			Symptom:                     monitorParam.Symptom,
			Dispose:                     monitorParam.Dispose,
			Result:                      monitorParam.Result,
			MonitoringNurse:             adminUserInfo.AdminUser.Id,
			Conductivity:                monitorParam.Conductivity,
			DisplacementFlowQuantity:    monitorParam.DisplacementFlowQuantity,
			Status:                      1,
			CreatedTime:                 time.Now().Unix(),
			UpdatedTime:                 time.Now().Unix(),
			BloodOxygenSaturation:       monitorParam.BloodOxygenSaturation,
			Creator:                     adminUserInfo.AdminUser.Id,
			Heparin:                     monitorParam.Heparin,
			DialysateFlow:               monitorParam.DialysateFlow,
			Urr:                         monitorParam.Urr,
			BloodSugar:                  monitorParam.BloodSugar,
			MonitorAnticoagulant:        monitorParam.MonitorAnticoagulant,
			MonitorAnticoagulantValue:   monitorParam.MonitorAnticoagulantValue,
			BloodPressureMonitoringSite: monitorParam.BloodPressureMonitoringSite,
			Complication:                monitorParam.Complication,
			AccumulatedBloodVolume:      monitorParam.AccumulatedBloodVolume,
			BloodTemperature:            monitorParam.BloodTemperature,
			UreaMonitoring:              monitorParam.UreaMonitoring,
			BloodThickness:              monitorParam.BloodThickness,
			BloodMonitor:                monitorParam.BloodMonitor,
			HeparinAmount:               monitorParam.HeparinAmount,
			Dehydration:                 monitorParam.Dehydration,
		}
		createErr := service.CreateMonitor(&monitor)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(scheduleDate, 10) + ":monitor_records"
		redis := service.RedisClient()
		//清空key 值
		redis.Set(key, "", time.Second)

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

		if createErr != nil {
			this.ErrorLog("创建监测记录失败：%v", createErr)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"monitor": monitor,
		})

	} else { // 修改记录
		monitor, getMonitorErr := service.GetMonitor(adminUserInfo.CurrentOrgId, patientID, monitorParam.ID)
		if getMonitorErr != nil {
			this.ErrorLog("获取透析监测记录失败：%v", getMonitorErr)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		} else if monitor == nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeMonitorNotExist)
			return
		}

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

		monitor.OperateTime = monitorParam.OperateTime
		monitor.PulseFrequency = monitorParam.PulseFrequency
		monitor.BreathingRate = monitorParam.BreathingRated
		monitor.SystolicBloodPressure = monitorParam.SystolicBP
		monitor.DiastolicBloodPressure = monitorParam.DiastolicBP
		monitor.BloodFlowVolume = monitorParam.BloodFlowVolume
		monitor.VenousPressure = monitorParam.VenousPressure
		monitor.VenousPressureType = monitorParam.VenousPressureType
		monitor.ArterialPressure = monitorParam.ArterialPressure
		monitor.ArterialPressureType = monitorParam.ArterialPressureType
		monitor.TransmembranePressure = monitorParam.TransmembranePressure
		monitor.TransmembranePressureType = monitorParam.TransmembranePressureType
		monitor.UltrafiltrationRate = monitorParam.UltrafiltrationRate
		monitor.UltrafiltrationVolume = monitorParam.UltrafiltrationVolume
		monitor.SodiumConcentration = monitorParam.SodiumConcentration
		monitor.DialysateTemperature = monitorParam.DialysateTemperature
		monitor.Temperature = monitorParam.Temperature
		monitor.ReplacementRate = monitorParam.ReplacementRate
		monitor.DisplacementQuantity = monitorParam.DisplacementQuantity
		monitor.Conductivity = monitorParam.Conductivity
		monitor.DisplacementFlowQuantity = monitorParam.DisplacementFlowQuantity
		monitor.Ktv = monitorParam.KTV
		monitor.Symptom = monitorParam.Symptom
		monitor.Dispose = monitorParam.Dispose
		monitor.Result = monitorParam.Result
		monitor.MonitoringNurse = adminUserInfo.AdminUser.Id
		monitor.UpdatedTime = time.Now().Unix()
		monitor.Modify = adminUserInfo.AdminUser.Id
		monitor.BloodOxygenSaturation = monitorParam.BloodOxygenSaturation
		monitor.Heparin = monitorParam.Heparin
		monitor.DialysateFlow = monitorParam.DialysateFlow
		monitor.Urr = monitorParam.Urr
		monitor.BloodSugar = monitorParam.BloodSugar
		monitor.MonitorAnticoagulant = monitorParam.MonitorAnticoagulant
		monitor.MonitorAnticoagulantValue = monitorParam.MonitorAnticoagulantValue
		monitor.AccumulatedBloodVolume = monitorParam.AccumulatedBloodVolume
		monitor.BloodTemperature = monitorParam.BloodTemperature
		monitor.UreaMonitoring = monitorParam.UreaMonitoring
		monitor.BloodThickness = monitorParam.BloodThickness
		monitor.BloodMonitor = monitorParam.BloodMonitor
		monitor.HeparinAmount = monitorParam.HeparinAmount
		monitor.Dehydration = monitorParam.Dehydration
		updateErr := service.UpdateMonitor(monitor)
		key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(scheduleDate, 10) + ":monitor_records"
		redis := service.RedisClient()
		defer redis.Close()
		//清空key 值
		redis.Set(key, "", time.Second)
		if updateErr != nil {
			this.ErrorLog("修改透析监测记录失败:%v", updateErr)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}
		this.ServeSuccessJSON(map[string]interface{}{
			"monitor": monitor,
		})
	}
}

// /api/dialysis/start_record [post]
// @param patient_id:int
// @param date:string 排班时间 (yyyy-mm-dd)
// @param nurse:int 上机护士
// @param bed:int 上机床位号
func (this *DialysisRecordAPIController) StartDialysis() {

	patientID, _ := this.GetInt64("patient_id")
	recordDateStr := this.GetString("date")
	nurseID, _ := this.GetInt64("nurse")
	punctureNurseId, _ := this.GetInt64("puncture_nurse")
	startDateStr := this.GetString("start_time")
	blood_drawing, _ := this.GetInt64("blood_drawing")
	schedual_type, _ := this.GetInt64("schedual_type")

	washpipe_nurse, _ := this.GetInt64("washpipe_nurse")
	change_nurse, _ := this.GetInt64("change_nurse")
	difficult_puncture_nurse, _ := this.GetInt64("difficult_puncture_nurse")
	new_fistula_nurse, _ := this.GetInt64("new_fistula_nurse")
	quality_nurse_id, _ := this.GetInt64("quality_nurse_id")
	bedID, _ := this.GetInt64("bed")

	if patientID <= 0 || len(recordDateStr) == 0 || nurseID <= 0 || bedID <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	recordDate, parseErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseErr != nil {
		this.ErrorLog("时间解析失败:%v", parseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	startDate, parseErr := utils.ParseTimeStringToTime("2006-01-02 15:04", startDateStr)
	if parseErr != nil {
		this.ErrorLog("时间解析失败:%v", parseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := this.GetAdminUserInfo()
	patient, getPatientErr := service.MobileGetPatientById(adminUserInfo.CurrentOrgId, patientID)
	if getPatientErr != nil {
		this.ErrorLog("获取患者信息失败：%v", getPatientErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if patient == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	nurse, getNurseErr := service.GetAdminUserByUserID(nurseID)
	if getNurseErr != nil {
		this.ErrorLog("获取护士失败:%v", getNurseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if nurse == nil {
		this.ErrorLog("护士不存在")
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	//nurse, getNurseErr = service.GetAdminUserByUserID(punctureNurseId)
	//
	//if getNurseErr != nil {
	//	this.ErrorLog("获取护士失败:%v", getNurseErr)
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//	return
	//} else if nurse == nil {
	//	this.ErrorLog("护士不存在")
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}

	deviceNumber, getDeviceNumberErr := service.GetDeviceNumberByID(adminUserInfo.CurrentOrgId, bedID)
	if getDeviceNumberErr != nil {
		this.ErrorLog("获取床位号失败:%v", getDeviceNumberErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if deviceNumber == nil {
		this.ErrorLog("床位号不存在")
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	dialysisRecord, getRecordErr := service.MobileGetDialysisRecord(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
	if getRecordErr != nil {
		this.ErrorLog("获取透析记录失败:%v", getRecordErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if dialysisRecord != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorDialysisOrderRepeatStart)
		return
	}

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

	scheduleDateStart := startDate.Format("2006-01-02") + " 00:00:00"
	scheduleDateEnd := startDate.Format("2006-01-02") + " 23:59:59"
	timeLayout := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")
	theStartTime, _ := time.ParseInLocation(timeLayout, scheduleDateStart, loc)
	theEndTime, _ := time.ParseInLocation(timeLayout, scheduleDateEnd, loc)
	schedulestartTime := theStartTime.Unix()
	scheduleendTime := theEndTime.Unix()

	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机

	schedule, err := service.GetDayScheduleByBedid(adminUserInfo.CurrentOrgId, schedulestartTime, bedID, schedual_type)

	//查询该床位是否有人用了
	order, order_err := service.GetDialysisOrderByBedId(adminUserInfo.CurrentOrgId, schedulestartTime, bedID, schedual_type)

	if err == gorm.ErrRecordNotFound { //空床位
		// 修改了床位逻辑
		daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, patientID)
		if daySchedule.ID > 0 {
			//daySchedule.PartitionId = deviceNumber.ZoneID
			//daySchedule.BedId = bedID
			//daySchedule.ScheduleType = schedual_type
			//daySchedule.UpdatedTime = time.Now().Unix()
			//err := service.UpdateSchedule(&daySchedule)
			xtSchedule := models.Schedule{
				PartitionId:  deviceNumber.ZoneID,
				BedId:        bedID,
				ScheduleType: schedual_type,
				UpdatedTime:  time.Now().Unix(),
			}
			err := service.UpdateScheduleOne(daySchedule.ID, xtSchedule)
			if err != nil {
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
				return
			}
		}

	} else if err == nil {
		if schedule.ID > 0 && schedule.DialysisOrder.ID == 0 { //有排班没上机记录

			if order_err == nil {
				if order.ID > 0 { //该机位被其他人占用了
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorDialysisOrderRepeatBed)
					return

				} else {
					daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, patientID)
					if daySchedule.ID > 0 {
						//daySchedule.PartitionId = deviceNumber.ZoneID
						//daySchedule.BedId = bedID
						//daySchedule.ScheduleType = schedual_type
						//daySchedule.UpdatedTime = time.Now().Unix()
						//err := service.UpdateSchedule(&daySchedule)
						xtSchedule := models.Schedule{
							PartitionId:  deviceNumber.ZoneID,
							BedId:        bedID,
							ScheduleType: schedual_type,
							UpdatedTime:  time.Now().Unix(),
						}
						err := service.UpdateScheduleOne(daySchedule.ID, xtSchedule)
						if err != nil {
							this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
							return
						}
					}
				}
			} else if order_err == gorm.ErrRecordNotFound { //该床位没被占用
				daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, patientID)
				if daySchedule.ID > 0 {
					//daySchedule.PartitionId = deviceNumber.ZoneID
					//daySchedule.BedId = bedID
					//daySchedule.ScheduleType = schedual_type
					//daySchedule.UpdatedTime = time.Now().Unix()
					//err := service.UpdateSchedule(&daySchedule)
					xtSchedule := models.Schedule{
						PartitionId:  deviceNumber.ZoneID,
						BedId:        bedID,
						ScheduleType: schedual_type,
						UpdatedTime:  time.Now().Unix(),
					}
					err := service.UpdateScheduleOne(daySchedule.ID, xtSchedule)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
						return
					}
				}
			} else if order_err != nil {
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
				return
			}
		} else if schedule.ID > 0 && schedule.DialysisOrder.ID > 0 { //有排班且有上机记录
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorDialysisOrderRepeatBed)
			return
		}
	} else if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	dialysisRecord = &models.DialysisOrder{
		DialysisDate:           recordDate.Unix(),
		UserOrgId:              adminUserInfo.CurrentOrgId,
		PatientId:              patientID,
		Stage:                  1,
		BedID:                  bedID,
		StartNurse:             nurseID,
		Status:                 1,
		StartTime:              startDate.Unix(),
		CreatedTime:            time.Now().Unix(),
		UpdatedTime:            time.Now().Unix(),
		PunctureNurse:          punctureNurseId,
		Creator:                adminUserInfo.AdminUser.Id,
		Modifier:               adminUserInfo.AdminUser.Id,
		SchedualType:           schedual_type,
		WashpipeNurse:          washpipe_nurse,
		ChangeNurse:            change_nurse,
		DifficultPunctureNurse: difficult_puncture_nurse,
		NewFistulaNurse:        new_fistula_nurse,
		QualityNurseId:         quality_nurse_id,
	}

	createErr := service.MobileCreateDialysisOrder(adminUserInfo.CurrentOrgId, patientID, dialysisRecord)
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":dialysis_order"
	redis := service.RedisClient()
	//清空key 值
	redis.Set(key, "", time.Second)

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

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

	newdialysisRecord, getRecordErr := service.MobileGetDialysisRecord(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())

	if createErr != nil {
		this.ErrorLog("上机失败：%v", createErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if createErr == nil {

		var tempdispose string
		// 只针对中能建
		if blood_drawing > 0 && adminUserInfo.CurrentOrgId == 9538 { //adminUserInfo.CurrentOrgId == 9538
			tempdispose = "引血" + strconv.FormatInt(blood_drawing, 10) + "ml/min"
		}

		if blood_drawing > 0 && adminUserInfo.CurrentOrgId == 10318 { //adminUserInfo.CurrentOrgId == 9538
			tempdispose = "引血" + strconv.FormatInt(blood_drawing, 10) + "ml/min"
		}

		var ultrafiltration_rate float64
		_, prescription := service.FindDialysisPrescriptionByReordDate(patientID, schedulestartTime, adminUserInfo.CurrentOrgId)

		//获取预增水量
		_, evaluation := service.FindPredialysisEvaluationByReordDate(patientID, schedulestartTime, adminUserInfo.CurrentOrgId)
		if prescription.ID > 0 {
			if prescription.TargetUltrafiltration > 0 && prescription.DialysisDurationHour > 0 {

				totalMin := prescription.DialysisDurationHour*60 + prescription.DialysisDurationMinute
				//fmt.Println("total23232323232322332", totalMin)
				if (template.TemplateId == 6 || template.TemplateId == 20 || template.TemplateId == 22 || template.TemplateId == 32 || template.TemplateId == 36) && adminUserInfo.CurrentOrgId != 9671 {
					ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)
				}

				//针对福建医师汇
				if template.TemplateId == 6 && adminUserInfo.CurrentOrgId == 10121 {
					if evaluation.ID > 0 {
						dehydration, _ := strconv.ParseFloat(evaluation.Dehydration, 64)
						ultrafiltration_rate = math.Floor((prescription.TargetUltrafiltration + dehydration) / float64(totalMin) * 60 * 1000)
					}
				}

				if template.TemplateId == 6 && adminUserInfo.CurrentOrgId == 10234 {
					if evaluation.ID > 0 {
						dehydration, _ := strconv.ParseFloat(evaluation.Dehydration, 64)
						ultrafiltration_rate = math.Floor((prescription.TargetUltrafiltration + dehydration) / float64(totalMin) * 60 * 1000)
					}
				}

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

				//针对监利大垸医院
				if adminUserInfo.CurrentOrgId == 10101 {

					if evaluation.ID > 0 {
						ultrafiltration_rate = math.Ceil(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)

					}
				}

				//针对肇庆三鹤血液透析中心
				if adminUserInfo.CurrentOrgId == 10215 || template.TemplateId == 43 {

					if evaluation.ID > 0 {
						ultrafiltration_rate = math.Ceil(prescription.TargetUltrafiltration / float64(totalMin) * 60)

					}
				}
			}
		}
		record := models.MonitoringRecord{
			UserOrgId:       adminUserInfo.CurrentOrgId,
			PatientId:       patientID,
			DialysisOrderId: dialysisRecord.ID,
			MonitoringDate:  schedulestartTime,
			OperateTime:     startDate.Unix(),
			// MonitoringTime:            recordTime,
			MonitoringNurse:       nurseID,
			Dispose:               tempdispose,
			UltrafiltrationRate:   ultrafiltration_rate,
			UltrafiltrationVolume: 0,
			Status:                1,
			CreatedTime:           time.Now().Unix(),
			UpdatedTime:           time.Now().Unix(),
		}

		//只针对广慈医院
		if template.TemplateId == 26 || template.TemplateId == 25 || template.TemplateId == 28 || adminUserInfo.CurrentOrgId == 9987 || adminUserInfo.CurrentOrgId == 9526 || template.TemplateId == 32 || adminUserInfo.CurrentOrgId == 9918 || adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 3877 || adminUserInfo.CurrentOrgId == 4 {
			// 查询病人是否有透前评估数据
			befor, errcode := service.GetAssessmentBefor(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
			//如果有数据就插入
			if errcode == nil {
				record.SystolicBloodPressure = befor.SystolicBloodPressure
				record.DiastolicBloodPressure = befor.DiastolicBloodPressure
				record.BreathingRate = befor.BreathingRate

				record.PulseFrequency = befor.PulseFrequency
				record.Temperature = befor.Temperature
			}
		}

		// 如果当天有插入数据，则不再往透析纪录里插入数据
		if newdialysisRecord.ID > 0 {

			//针对长沙南雅医院
			if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10340 {

				record.Temperature = 36.5

			}

			err := service.CreateMonitor(&record)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":monitor_records"

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

			if err != nil {
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeMonitorCreate)
				return
			}
		}

		go func() {
			ssoDomain := beego.AppConfig.String("call_domain")
			api := ssoDomain + "/index/uppatient"
			values := make(url.Values)
			values.Set("org_id", strconv.FormatInt(adminUserInfo.CurrentOrgId, 10))
			values.Set("admin_user_id", strconv.FormatInt(nurseID, 10))
			values.Set("patient_id", strconv.FormatInt(patientID, 10))
			values.Set("up_time", strconv.FormatInt(startDate.Unix(), 10))
			http.PostForm(api, values)
		}()

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

	}

}

// /api/dialysis/finish [post]
// @param patient_id:int
// @param date:string 排班时间 (yyyy-mm-dd)
// @param nurse:int 下机护士
func (this *DialysisRecordAPIController) FinishDialysis() {
	patientID, _ := this.GetInt64("patient_id")
	recordDateStr := this.GetString("date")
	nurseID, _ := this.GetInt64("nurse")
	end_time := this.GetString("end_time")

	puncture_point_haematoma, _ := this.GetInt64("puncture_point_haematoma")
	internal_fistula := this.GetString("internal_fistula")
	catheter := this.GetString("catheter")
	cruor := this.GetString("cruor")
	if patientID <= 0 || len(recordDateStr) == 0 || nurseID <= 0 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	recordDate, parseErr := utils.ParseTimeStringToTime("2006-01-02", recordDateStr)
	if parseErr != nil {
		this.ErrorLog("时间解析失败:%v", parseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	//if parseEndDateErr != nil {
	//	this.ErrorLog("时间解析失败:%v", parseEndDateErr)
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}

	adminUserInfo := this.GetAdminUserInfo()
	patient, getPatientErr := service.MobileGetPatientById(adminUserInfo.CurrentOrgId, patientID)
	if getPatientErr != nil {
		this.ErrorLog("获取患者信息失败：%v", getPatientErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if patient == nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodePatientNoExist)
		return
	}

	nurse, getNurseErr := service.GetAdminUserByUserID(nurseID)
	if getNurseErr != nil {
		this.ErrorLog("获取护士失败:%v", getNurseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if nurse == nil {
		this.ErrorLog("护士不存在")
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	dialysisRecord, getRecordErr := service.MobileGetDialysisRecord(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
	if getRecordErr != nil {
		this.ErrorLog("获取透析记录失败:%v", getRecordErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}
	if dialysisRecord.Stage == 2 {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorDialysisOrderNoEND)
		return
	}

	endDate, parseEndDateErr := utils.ParseTimeStringToTime("2006-01-02 15:04", end_time)
	if parseEndDateErr != nil {
		this.ErrorLog("日期(%v)解析错误：%v", end_time, parseEndDateErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	// 获取当天的第一条透析纪录
	fmonitorRecords, getMonitorRecordsErr := service.MobileGetMonitorRecordFirst(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
	if getMonitorRecordsErr != nil {
		this.ErrorLog("获取透析监测记录失败:%v", getMonitorRecordsErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	// 获取当前的最后一条透析纪录
	endmonitorRecords, getMonitorRecordsErr := service.MobileGetLastMonitorRecord(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
	if getMonitorRecordsErr != nil {
		this.ErrorLog("获取透析监测记录失败:%v", getMonitorRecordsErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	assessmentAfterDislysis, getAADErr := service.MobileGetAssessmentAfterDislysis(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
	if getAADErr != nil {
		this.ErrorLog("获取透后评估失败:%v", getAADErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	lastAssessmentAfterDislysis, _ := service.MobileGetLastTimeAssessmentAfterDislysis(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())

	var tempassessmentAfterDislysis models.AssessmentAfterDislysis

	if assessmentAfterDislysis != nil {
		tempassessmentAfterDislysis = *assessmentAfterDislysis
		tempassessmentAfterDislysis.UpdatedTime = time.Now().Unix()
	} else {
		tempassessmentAfterDislysis.CreatedTime = time.Now().Unix()
		tempassessmentAfterDislysis.AssessmentDate = recordDate.Unix()
		tempassessmentAfterDislysis.Status = 1
		tempassessmentAfterDislysis.PatientId = patientID
		tempassessmentAfterDislysis.UserOrgId = adminUserInfo.CurrentOrgId
	}

	if dialysisRecord.Stage == 1 {
		temp_time := (float64(endDate.Unix()) - float64(dialysisRecord.StartTime)) / 3600
		value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", temp_time), 64)
		fmt.Println(value)
		a, b := math.Modf(value)
		c, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", b), 64)
		hour, _ := strconv.ParseInt(fmt.Sprintf("%.0f", a), 10, 64)
		minute, _ := strconv.ParseInt(fmt.Sprintf("%.0f", c*60), 10, 64)
		fmt.Println(hour)
		fmt.Println(minute)
		tempassessmentAfterDislysis.ActualTreatmentHour = hour
		tempassessmentAfterDislysis.ActualTreatmentMinute = minute
	}

	if fmonitorRecords.ID > 0 && endmonitorRecords.ID > 0 {
		tempassessmentAfterDislysis.Temperature = endmonitorRecords.Temperature
		tempassessmentAfterDislysis.PulseFrequency = endmonitorRecords.PulseFrequency
		tempassessmentAfterDislysis.BreathingRate = endmonitorRecords.BreathingRate
		tempassessmentAfterDislysis.SystolicBloodPressure = endmonitorRecords.SystolicBloodPressure
		tempassessmentAfterDislysis.DiastolicBloodPressure = endmonitorRecords.DiastolicBloodPressure
		//长沙南雅
		if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10340 {
			//获取最后一条透析处方数据
			prescription, _ := service.GetLastDialysisPrescriptionByPatientIdTwo(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
			evaluation, _ := service.MobileGetPredialysisEvaluationTwo(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
			tempassessmentAfterDislysis.WeightAfter = evaluation.WeightBefore - prescription.TargetUltrafiltration
		}
		if adminUserInfo.CurrentOrgId == 10101 {
			tempassessmentAfterDislysis.ActualUltrafiltration = endmonitorRecords.UltrafiltrationVolume / 1000
		} else {
			tempassessmentAfterDislysis.ActualUltrafiltration = endmonitorRecords.UltrafiltrationVolume / 1000
		}
		tempassessmentAfterDislysis.ActualDisplacement = endmonitorRecords.DisplacementQuantity
	}

	if adminUserInfo.CurrentOrgId == 9583 {
		//获取最后一条透析处方数据
		prescription, parseErr := service.GetLastDialysisPrescriptionByPatientId(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
		if parseErr != nil {
			this.ErrorLog("获取透析处方失败:%v", getMonitorRecordsErr)
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}

		if prescription.ID > 0 && adminUserInfo.CurrentOrgId == 9583 {
			tempassessmentAfterDislysis.ActualUltrafiltration = prescription.TargetUltrafiltration
		}
		if endmonitorRecords.ID > 0 && adminUserInfo.CurrentOrgId == 10060 {
			tempassessmentAfterDislysis.ActualUltrafiltration = endmonitorRecords.UltrafiltrationVolume
		}

	}

	if lastAssessmentAfterDislysis != nil {
		tempassessmentAfterDislysis.BloodPressureType = lastAssessmentAfterDislysis.BloodPressureType

		tempassessmentAfterDislysis.WeighingWay = lastAssessmentAfterDislysis.WeighingWay

		tempassessmentAfterDislysis.Cruor = lastAssessmentAfterDislysis.Cruor
		tempassessmentAfterDislysis.SymptomAfterDialysis = lastAssessmentAfterDislysis.SymptomAfterDialysis
		tempassessmentAfterDislysis.InternalFistula = lastAssessmentAfterDislysis.InternalFistula
		tempassessmentAfterDislysis.Catheter = lastAssessmentAfterDislysis.Catheter
		tempassessmentAfterDislysis.Complication = lastAssessmentAfterDislysis.Complication
		tempassessmentAfterDislysis.DialysisIntakes = lastAssessmentAfterDislysis.DialysisIntakes
		tempassessmentAfterDislysis.DialysisIntakesFeed = lastAssessmentAfterDislysis.DialysisIntakesFeed
		tempassessmentAfterDislysis.DialysisIntakesTransfusion = lastAssessmentAfterDislysis.DialysisIntakesTransfusion
		tempassessmentAfterDislysis.DialysisIntakesBloodTransfusion = lastAssessmentAfterDislysis.DialysisIntakesBloodTransfusion

		tempassessmentAfterDislysis.DialysisIntakesWashpipe = lastAssessmentAfterDislysis.DialysisIntakesWashpipe

		tempassessmentAfterDislysis.BloodAccessPartId = lastAssessmentAfterDislysis.BloodAccessPartId
		tempassessmentAfterDislysis.BloodAccessPartOperaId = lastAssessmentAfterDislysis.BloodAccessPartOperaId

		tempassessmentAfterDislysis.PuncturePointOozingBlood = lastAssessmentAfterDislysis.PuncturePointOozingBlood
		tempassessmentAfterDislysis.PuncturePointHaematoma = lastAssessmentAfterDislysis.PuncturePointHaematoma
		tempassessmentAfterDislysis.InternalFistulaTremorAc = lastAssessmentAfterDislysis.InternalFistulaTremorAc
		tempassessmentAfterDislysis.PatientGose = lastAssessmentAfterDislysis.PatientGose

		tempassessmentAfterDislysis.InpatientDepartment = lastAssessmentAfterDislysis.InpatientDepartment
		tempassessmentAfterDislysis.ObservationContent = lastAssessmentAfterDislysis.ObservationContent
		tempassessmentAfterDislysis.ObservationContentOther = lastAssessmentAfterDislysis.ObservationContentOther
		tempassessmentAfterDislysis.DryWeight = lastAssessmentAfterDislysis.DryWeight

		tempassessmentAfterDislysis.DialysisProcess = lastAssessmentAfterDislysis.DialysisProcess
		tempassessmentAfterDislysis.InAdvanceMinute = lastAssessmentAfterDislysis.InAdvanceMinute
		tempassessmentAfterDislysis.InAdvanceReason = lastAssessmentAfterDislysis.InAdvanceReason

		tempassessmentAfterDislysis.HemostasisMinute = lastAssessmentAfterDislysis.HemostasisMinute
		tempassessmentAfterDislysis.HemostasisOpera = lastAssessmentAfterDislysis.HemostasisOpera
		tempassessmentAfterDislysis.TremorNoise = lastAssessmentAfterDislysis.TremorNoise

		tempassessmentAfterDislysis.DisequilibriumSyndrome = lastAssessmentAfterDislysis.DisequilibriumSyndrome
		tempassessmentAfterDislysis.DisequilibriumSyndromeOption = lastAssessmentAfterDislysis.DisequilibriumSyndromeOption
		tempassessmentAfterDislysis.ArterialTube = lastAssessmentAfterDislysis.ArterialTube

		tempassessmentAfterDislysis.IntravenousTube = lastAssessmentAfterDislysis.IntravenousTube
		tempassessmentAfterDislysis.Dialyzer = lastAssessmentAfterDislysis.Dialyzer
		tempassessmentAfterDislysis.InAdvanceReasonOther = lastAssessmentAfterDislysis.InAdvanceReasonOther
		tempassessmentAfterDislysis.IsEat = lastAssessmentAfterDislysis.IsEat

		tempassessmentAfterDislysis.DialysisIntakesUnit = lastAssessmentAfterDislysis.DialysisIntakesUnit
		tempassessmentAfterDislysis.CvcA = lastAssessmentAfterDislysis.CvcA
		tempassessmentAfterDislysis.CvcV = lastAssessmentAfterDislysis.CvcV
		tempassessmentAfterDislysis.Channel = lastAssessmentAfterDislysis.Channel
		tempassessmentAfterDislysis.ReturnBlood = lastAssessmentAfterDislysis.ReturnBlood
		tempassessmentAfterDislysis.RehydrationVolume = lastAssessmentAfterDislysis.RehydrationVolume
		tempassessmentAfterDislysis.DialysisDuring = lastAssessmentAfterDislysis.DialysisDuring
		tempassessmentAfterDislysis.StrokeVolume = lastAssessmentAfterDislysis.StrokeVolume
		tempassessmentAfterDislysis.BloodFlow = lastAssessmentAfterDislysis.BloodFlow
		tempassessmentAfterDislysis.SealingFluidDispose = lastAssessmentAfterDislysis.SealingFluidDispose
		tempassessmentAfterDislysis.SealingFluidSpecial = lastAssessmentAfterDislysis.SealingFluidSpecial

	}

	err := service.UpdateAssessmentAfterDislysisRecord(&tempassessmentAfterDislysis)

	if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10340 || adminUserInfo.CurrentOrgId == 10414 {
		fmt.Println("进来2332233333333333333333333333333333333我的")
		evaluation, _ := service.MobileGetPredialysisEvaluationTwo(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
		if evaluation.SystolicBloodPressure == 0 {
			pre := models.PredialysisEvaluation{
				SystolicBloodPressure: fmonitorRecords.SystolicBloodPressure,
			}
			fmt.Println("prew", pre)
			getNurseErr := service.UpdatePredialysisEvaluation(&pre, evaluation.ID)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"
			keyOne := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_befores_list_all"

			redis := service.RedisClient()
			redis.Set(key, "", time.Second)
			redis.Set(keyOne, "", time.Second)
			defer redis.Close()
			fmt.Println(getNurseErr)
		}
		if evaluation.DiastolicBloodPressure == 0 {
			pres := models.PredialysisEvaluation{
				DiastolicBloodPressure: fmonitorRecords.DiastolicBloodPressure,
			}
			getNurseErr := service.UpdatePredialysisEvaluationTwo(&pres, evaluation.ID)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"

			redis := service.RedisClient()
			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()
			fmt.Println(getNurseErr)
		}
		if evaluation.PulseFrequency == 0 {
			evaluation.PulseFrequency = fmonitorRecords.PulseFrequency
			press := models.PredialysisEvaluation{
				PulseFrequency: evaluation.PulseFrequency,
			}
			getNurseErr := service.UpdatePredialysisEvaluationThree(&press, evaluation.ID)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"

			redis := service.RedisClient()
			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()
			fmt.Println(getNurseErr)
		}

		if evaluation.Temperature == 0 {
			evaluation.Temperature = fmonitorRecords.Temperature
			press := models.PredialysisEvaluation{
				Temperature: evaluation.Temperature,
			}
			getNurseErr := service.UpdatePredialysisEvaluationFour(&press, evaluation.ID)
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":assessment_before_dislysis"

			redis := service.RedisClient()
			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()
			fmt.Println(getNurseErr)
		}
	}

	if err != nil {
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	go func() {
		ssoDomain := beego.AppConfig.String("call_domain")
		api := ssoDomain + "/index/downpatient"
		values := make(url.Values)
		values.Set("org_id", strconv.FormatInt(adminUserInfo.CurrentOrgId, 10))
		values.Set("admin_user_id", strconv.FormatInt(nurseID, 10))
		values.Set("patient_id", strconv.FormatInt(patientID, 10))
		http.PostForm(api, values)
	}()

	//执行下机
	updateErr := service.ModifyDialysisRecord(dialysisRecord.ID, nurseID, endDate.Unix(), adminUserInfo.AdminUser.Id, puncture_point_haematoma, internal_fistula, catheter, cruor)
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":dialysis_order"
	redis := service.RedisClient()
	defer redis.Close()
	//清空key 值
	redis.Set(key, "", time.Second)

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

	if updateErr != nil {
		this.ErrorLog("下机失败:%v", updateErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else {
		dialysisRecord.Stage = 2
		dialysisRecord.FinishNurse = nurseID
		dialysisRecord.FinishCreator = adminUserInfo.AdminUser.Id
		dialysisRecord.FinishModifier = adminUserInfo.AdminUser.Id
		dialysisRecord.EndTime = endDate.Unix()
		// 结束时候透析次数加1
		service.UpdateSolutionByPatientId(patientID)

		this.ServeSuccessJSON(map[string]interface{}{
			"dialysis_order":          dialysisRecord,
			"assessmentAfterDislysis": tempassessmentAfterDislysis,
		})
	}

}

func (this *DialysisRecordAPIController) ModifyStartDialysis() {
	record_id, _ := this.GetInt64("id")
	nurseID, _ := this.GetInt64("nurse")
	puncture_nurse, _ := this.GetInt64("puncture_nurse")
	bedID, _ := this.GetInt64("bed")
	start_time := this.GetString("start_time")
	washpipe_nurse, _ := this.GetInt64("washpipe_nurse")

	schedual_type, _ := this.GetInt64("schedual_type")
	change_nurse, _ := this.GetInt64("change_nurse")
	difficult_puncture_nurse, _ := this.GetInt64("difficult_puncture_nurse")
	new_fistula_nurse, _ := this.GetInt64("new_fistula_nurse")
	quality_nurse, _ := this.GetInt64("quality_nurse")
	if record_id == 0 {
		this.ErrorLog("id:%v", record_id)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	startDate, parseStartDateErr := utils.ParseTimeStringToTime("2006-01-02 15:04", start_time)
	if parseStartDateErr != nil {
		this.ErrorLog("时间解析失败:%v", parseStartDateErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := this.GetAdminUserInfo()

	nurse, getNurseErr := service.GetAdminUserByUserID(nurseID)
	if getNurseErr != nil {
		this.ErrorLog("获取护士失败:%v", getNurseErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if nurse == nil {
		this.ErrorLog("护士不存在")
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	//nurse, getNurseErr = service.GetAdminUserByUserID(puncture_nurse)
	//if getNurseErr != nil {
	//	this.ErrorLog("获取护士失败:%v", getNurseErr)
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
	//	return
	//} else if nurse == nil {
	//	this.ErrorLog("护士不存在")
	//	this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
	//	return
	//}

	deviceNumber, getDeviceNumberErr := service.GetDeviceNumberByID(adminUserInfo.CurrentOrgId, bedID)
	if getDeviceNumberErr != nil {
		this.ErrorLog("获取床位号失败:%v", getDeviceNumberErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if deviceNumber == nil {
		this.ErrorLog("床位号不存在")
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	_, tempDialysisRecord := service.FindDialysisOrderById(record_id)

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

	scheduleDateStart := startDate.Format("2006-01-02") + " 00:00:00"
	scheduleDateEnd := startDate.Format("2006-01-02") + " 23:59:59"
	timeLayout := "2006-01-02 15:04:05"
	loc, _ := time.LoadLocation("Local")
	theStartTime, _ := time.ParseInLocation(timeLayout, scheduleDateStart, loc)
	theEndTime, _ := time.ParseInLocation(timeLayout, scheduleDateEnd, loc)
	schedulestartTime := theStartTime.Unix()
	scheduleendTime := theEndTime.Unix()

	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机

	schedule, err := service.GetDayScheduleByBedid(adminUserInfo.CurrentOrgId, schedulestartTime, bedID, schedual_type)
	daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, tempDialysisRecord.PatientId)

	if daySchedule.BedId != bedID || daySchedule.ScheduleType != schedual_type {

		if err == gorm.ErrRecordNotFound { //空床位
			// 修改了床位逻辑
			daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, tempDialysisRecord.PatientId)
			if daySchedule.ID > 0 {
				//daySchedule.BedId = bedID
				//daySchedule.PartitionId = deviceNumber.ZoneID
				//daySchedule.ScheduleType = schedual_type
				//daySchedule.UpdatedTime = time.Now().Unix()
				//err := service.UpdateSchedule(&daySchedule)
				xtSchedule := models.Schedule{
					PartitionId:  deviceNumber.ZoneID,
					BedId:        bedID,
					ScheduleType: schedual_type,
					UpdatedTime:  time.Now().Unix(),
				}
				err := service.UpdateScheduleOne(daySchedule.ID, xtSchedule)
				if err != nil {
					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
					return
				}
			}

		} else if err == nil {
			if schedule.ID > 0 && schedule.DialysisOrder.ID == 0 { //有排班没上机记录
				daySchedule, _ := service.GetDaySchedule(adminUserInfo.CurrentOrgId, schedulestartTime, scheduleendTime, tempDialysisRecord.PatientId)
				if daySchedule.ID > 0 {
					//daySchedule.BedId = bedID
					//daySchedule.PartitionId = deviceNumber.ZoneID
					//
					//daySchedule.ScheduleType = schedual_type
					//daySchedule.UpdatedTime = time.Now().Unix()
					//err := service.UpdateSchedule(&daySchedule)
					xtSchedule := models.Schedule{
						PartitionId:  deviceNumber.ZoneID,
						BedId:        bedID,
						ScheduleType: schedual_type,
						UpdatedTime:  time.Now().Unix(),
					}
					err := service.UpdateScheduleOne(daySchedule.ID, xtSchedule)
					if err != nil {
						this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
						return
					}
				}
			} else if schedule.ID > 0 && schedule.DialysisOrder.ID > 0 { //有排班且有上机记录
				this.ServeFailJSONWithSGJErrorCode(enums.ErrorDialysisOrderRepeatBed)
				return
			}
		} else if err != nil {
			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
			return
		}

	}
	fmt.Println("quality_nurse", quality_nurse)
	dialysisRecord := &models.DialysisOrder{
		ID:                     record_id,
		UserOrgId:              adminUserInfo.CurrentOrgId,
		BedID:                  bedID,
		StartNurse:             nurseID,
		StartTime:              startDate.Unix(),
		PunctureNurse:          puncture_nurse,
		Creator:                adminUserInfo.AdminUser.Id,
		Modifier:               adminUserInfo.AdminUser.Id,
		SchedualType:           schedual_type,
		WashpipeNurse:          washpipe_nurse,
		ChangeNurse:            change_nurse,
		DifficultPunctureNurse: difficult_puncture_nurse,
		NewFistulaNurse:        new_fistula_nurse,
		QualityNurseId:         quality_nurse,
	}

	updateErr := service.ModifyStartDialysisOrder(dialysisRecord)
	redis := service.RedisClient()
	key := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.PatientId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":dialysis_order"
	redis.Set(key, "", time.Second)
	keyOne := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":dialysis_orders_list_all"

	//清空key 值
	redis.Set(keyOne, "", time.Second)
	scheduleDateStartOne := startDate.Format("2006-01-02")
	keyTwo := "scheduals_" + scheduleDateStartOne + "_" + strconv.FormatInt(tempDialysisRecord.UserOrgId, 10)

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

	keyThree := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":doctor_advices"
	redis.Set(keyThree, "", time.Second)
	keyFour := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":monitor_records"
	redis.Set(keyFour, "", time.Second)

	keyFive := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":patient_info"
	redis.Set(keyFive, "", time.Second)

	keySix := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":his_doctor_advice"
	redis.Set(keySix, "", time.Second)

	keySeven := strconv.FormatInt(tempDialysisRecord.UserOrgId, 10) + ":" + ":device_list_all"
	redis.Set(keySeven, "", time.Second)

	if updateErr != nil {
		this.ErrorLog("修改上机失败：%v", updateErr)
		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	if updateErr == nil {
		if tempDialysisRecord.Stage == 2 {
			temp_time := (float64(tempDialysisRecord.EndTime) - float64(startDate.Unix())) / 3600
			value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", temp_time), 64)
			fmt.Println(value)
			a, b := math.Modf(value)
			tempMinute, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", b), 64)
			hour, _ := strconv.ParseInt(fmt.Sprintf("%.0f", a), 10, 64)
			minute, _ := strconv.ParseInt(fmt.Sprintf("%.0f", tempMinute*60), 10, 64)
			updateAssessmentErr := service.UpdateAssessmentAfterDate(tempDialysisRecord.PatientId, tempDialysisRecord.UserOrgId, tempDialysisRecord.DialysisDate, hour, minute)
			redis := service.RedisClient()
			keyThree := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":assessment_after_dislysis_list_all"
			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecord.DialysisDate, 10) + ":dialysis_orders_list_all"
			redis.Set(key, "", time.Second)
			redis.Set(keyThree, "", time.Second)
			redis.Close()
			if updateAssessmentErr != nil {
				utils.ErrorLog("%v", updateAssessmentErr)
			}
			after, _ := service.FindAssessmentAfterDislysisById(tempDialysisRecord.UserOrgId, tempDialysisRecord.PatientId, tempDialysisRecord.DialysisDate)
			_, dialysisRecords := service.FindDialysisOrderById(record_id)
			this.ServeSuccessJSON(map[string]interface{}{
				"dialysis_order": dialysisRecords,
				"after":          after,
			})
		} else {
			_, dialysisRecords := service.FindDialysisOrderById(record_id)
			this.ServeSuccessJSON(map[string]interface{}{
				"dialysis_order": dialysisRecords,
			})
		}
	}

}

func (c *DialysisRecordAPIController) ModifyFinishDialysis() {
	record_id, _ := c.GetInt64("id")
	nurseID, _ := c.GetInt64("nurse")
	end_time := c.GetString("end_time")
	puncture_point_haematoma, _ := c.GetInt64("puncture_point_haematoma")
	internal_fistula := c.GetString("internal_fistula")
	catheter := c.GetString("catheter")
	cruor := c.GetString("cruor")
	if record_id <= 0 || nurseID <= 0 {
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	adminUserInfo := c.GetAdminUserInfo()
	nurse, getNurseErr := service.GetAdminUserByUserID(nurseID)
	if getNurseErr != nil {
		c.ErrorLog("获取护士失败:%v", getNurseErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	} else if nurse == nil {
		c.ErrorLog("护士不存在")
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}

	endDate, parseEndDateErr := utils.ParseTimeStringToTime("2006-01-02 15:04", end_time)
	if parseEndDateErr != nil {
		c.ErrorLog("日期(%v)解析错误：%v", end_time, parseEndDateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
		return
	}
	_, tempDialysisRecords := service.FindDialysisOrderById(record_id)

	//if tempDialysisRecords.FinishCreator != 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
	//	}
	//}

	dialysisRecord := &models.DialysisOrder{
		ID:                         record_id,
		UserOrgId:                  adminUserInfo.CurrentOrgId,
		EndTime:                    endDate.Unix(),
		FinishNurse:                nurseID,
		FinishModifier:             adminUserInfo.AdminUser.Id,
		PuncturePointHaematoma:     puncture_point_haematoma,
		BloodAccessInternalFistula: internal_fistula,
		Catheter:                   catheter,
		Cruor:                      cruor,
	}

	updateErr := service.ModifyFinishDialysisOrder(dialysisRecord)
	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(tempDialysisRecords.PatientId, 10) + ":" + strconv.FormatInt(tempDialysisRecords.DialysisDate, 10) + ":dialysis_order"
	redis := service.RedisClient()
	defer redis.Close()
	//清空key 值
	redis.Set(key, "", time.Second)

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

	if updateErr != nil {
		c.ErrorLog("修改下机失败：%v", updateErr)
		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
		return
	}

	if updateErr == nil {
		temp_time := (float64(endDate.Unix()) - float64(tempDialysisRecords.StartTime)) / 3600
		value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", temp_time), 64)
		fmt.Println(value)
		a, b := math.Modf(value)
		tempMinute, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", b), 64)
		hour, _ := strconv.ParseInt(fmt.Sprintf("%.0f", a), 10, 64)
		minute, _ := strconv.ParseInt(fmt.Sprintf("%.0f", tempMinute*60), 10, 64)
		monitor, _ := service.GetLastMonitorRecord(tempDialysisRecords.UserOrgId, tempDialysisRecords.PatientId, tempDialysisRecords.DialysisDate)
		updateAssessmentErr := service.UpdateAssessmentAfterDateOne(tempDialysisRecords.PatientId, tempDialysisRecords.UserOrgId, tempDialysisRecords.DialysisDate, hour, minute, monitor.BreathingRate)
		if updateAssessmentErr != nil {
			utils.ErrorLog("%v", updateAssessmentErr)
		}

	}

	after, _ := service.FindAssessmentAfterDislysisById(tempDialysisRecords.UserOrgId, tempDialysisRecords.PatientId, tempDialysisRecords.DialysisDate)
	_, dialysisRecords := service.FindDialysisOrderById(record_id)
	c.ServeSuccessJSON(map[string]interface{}{
		"dialysis_order": dialysisRecords,
		"after":          after,
	})

}