Merge branch '20220812' of http://git.shengws.com/csx/XT_New into 20220812

controllers/dialysis_api_controller.go

 	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")
 }
 
 func (c *DialysisApiController) GetQueueCall() {
 	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")
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentOrgId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
 	//template, _ := service.GetOrgInfoTemplate(adminUserInfo.CurrentOrgId)
 
 		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,
 	}
 
 	if appRole.UserType == 2 || appRole.UserType == 1 {
 	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")
 	var prescription_doctor int64
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.CurrentAppId, adminUserInfo.AdminUser.Id, adminUserInfo.CurrentAppId)
 
 		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,
 	}
 
 	//查询最近透析准备表里是否存在 透析器 灌流器
 	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
 		PsychologicalOther:           psychological_other,
 		AdmissionNumber:              admission_number,
 		Tumble:                       tumble,
+		HisDepartment:                his_department,
+		HisBed:                       his_bed,
+		Diacrisis:                    diacrisis,
 	}
 
 	if receiveTreatment.ID == 0 { //新增
 	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,
 		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)
 				ultrafiltration_rate = value
 				record.UltrafiltrationRate = ultrafiltration_rate
 			}
+
+			if adminInfo.CurrentOrgId == 10395 || adminInfo.CurrentOrgId == 10138 || adminInfo.CurrentOrgId == 10278 || adminInfo.CurrentOrgId == 10340 {
+				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration * 60 / 1000 / float64(totalMin) * 1000)
+
+				record.UltrafiltrationRate = ultrafiltration_rate
+			}
+
 		}
 	}
 	// record.UltrafiltrationRate = ultrafiltration_rate
 
 	}
 
+	if adminInfo.CurrentOrgId == 10395 || adminInfo.CurrentOrgId == 10138 || adminInfo.CurrentOrgId == 10278 || adminInfo.CurrentOrgId == 10340 {
+
+		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
 	}
 	startTime, _ := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
 
 	orgId := this.GetAdminUserInfo().CurrentOrgId
+	_, config := service.FindXTHisRecordByOrgId(orgId)
 
-	list, total, err := service.GetPatientDialysisSolutionGroupList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId)
+	goodType, _ := service.GetAllGoodType(orgId)
+	if config.IsOpen != 1 {
+		list, total, err := service.GetPatientDialysisSolutionGroupList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId)
+		fmt.Println("list2232323223332323232", list)
+		if err == nil {
+			this.ServeSuccessJSON(map[string]interface{}{
+				"list":     list,
+				"total":    total,
+				"config":   config,
+				"goodType": goodType,
+			})
+			return
 
-	if err == nil {
-		this.ServeSuccessJSON(map[string]interface{}{
-			"list":  list,
-			"total": total,
-		})
-		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)
+		if err == nil {
+			this.ServeSuccessJSON(map[string]interface{}{
+				"list":     list,
+				"total":    total,
+				"config":   config,
+				"goodType": goodType,
+			})
+			return
+		}
 
-	} else {
-		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
-		return
 	}
+
 }
 
 func (this *DialysisApiController) GetDialysisAdviceTemplateList() {
 	schedule_type, _ := this.GetInt64("schedule_type")
 
 	start_time := this.GetString("schedule_date")
+
+	ids := this.GetString("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)
-
+	fmt.Println("idArray", idArray)
+	list, total, err := service.GetDialysisAdviceTemplateList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId, idArray)
+	fmt.Println("list2323223323223323323223wi", list)
 	//获取长期医嘱
 	adviceList, _ := service.GetAllLongAdviceList(orgId)
 
 	//获取医嘱模版
 	templateList, _ := service.GetAllHisAdviceTemplateList(orgId)
+
+	_, config := service.FindXTHisRecordByOrgId(orgId)
+
+	drugList, _ := service.GetAllBaseDrugList(orgId)
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"list":         list,
 			"total":        total,
 			"adviceList":   adviceList,
 			"templateList": templateList,
+			"config":       config,
+			"drugList":     drugList,
 		})
 		return
 
 	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{
-		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(),
+		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 {
 	})
 	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
+
+	list, total, err := service.GetDialysisParameterList(keyword, limit, page, partition_id, schedule_type, startTime.Unix(), orgId)
+
+	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())
+	drug, _ := service.GetAllDrugMap(orgId)
+	//获取长期医嘱
+	adviceList, _ := service.GetAllLongAdviceList(orgId)
+	//获取医嘱模版
+	templateList, _ := service.GetAllHisAdviceTemplateList(orgId)
+
+	_, config := service.FindXTHisRecordByOrgId(orgId)
+	if err == nil {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"list":         list,
+			"drug":         drug,
+			"adviceList":   adviceList,
+			"templateList": templateList,
+			"config":       config,
+		})
+		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)
+
+	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,
+	})
+
+}

controllers/dialysis_record_api_controller.go

 	systemDialysisPrescribe, _ := service.GetSystemDialysisPrescribeByModeId(adminInfo.CurrentOrgId, schedual.ModeId)
 
 	lastDryWeightDislysis, getDryErr := service.GetLastDryWeight(adminInfo.CurrentOrgId, patientID)
+
+	lastOrder, _ := service.GetLastDilysisOrder(adminInfo.CurrentOrgId, patientID, date.Unix())
 	if getDryErr != nil {
 		this.ErrorLog("获取最后一条干体重失败:%v", getDryErr)
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
 			"lastAssessment":              lastAssessment,
 			"information":                 information,
 			"is_advice_open":              adviceConfig,
+			"lastOrder":                   lastOrder,
 		}
 		this.ServeSuccessJSON(returnData)
 
 			"lastAssessment":              lastAssessment,
 			"information":                 information,
 			"is_advice_open":              adviceConfig,
+			"lastOrder":                   lastOrder,
 		}
 		this.ServeSuccessJSON(returnData)
 	}
 	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")
+	puncture_needle := this.GetString("puncture_needle")
+	puncture_way := this.GetString("puncture_way")
+	dialysis_dialyszers := this.GetString("dialysis_dialyszers")
+	dialysis_irrigation := this.GetString("dialysis_irrigation")
+	blood_access_id, _ := this.GetInt64("blood_access_id")
 	bedID, _ := this.GetInt64("bed")
+	nuclein_date := this.GetString("nuclein_date")
 
 	if patientID <= 0 || len(recordDateStr) == 0 || nurseID <= 0 || bedID <= 0 {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 	schedulestartTime := theStartTime.Unix()
 	scheduleendTime := theEndTime.Unix()
 
+	var theNucleinDate int64
+	timeLayoutOne := "2006-01-02"
+
+	if len(nuclein_date) > 0 {
+		theTime, err := time.ParseInLocation(timeLayoutOne+" 15:04:05", nuclein_date+" 00:00:00", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+		}
+		theNucleinDate = theTime.Unix()
+	}
+
 	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机
 
 	schedule, err := service.GetDayScheduleByBedid(adminUserInfo.CurrentOrgId, schedulestartTime, bedID, schedual_type)
 		ChangeNurse:            change_nurse,
 		DifficultPunctureNurse: difficult_puncture_nurse,
 		NewFistulaNurse:        new_fistula_nurse,
+		QualityNurseId:         quality_nurse_id,
+		PunctureNeedle:         puncture_needle,
+		PunctureWay:            puncture_way,
+		DialysisDialyszers:     dialysis_dialyszers,
+		DialysisIrrigation:     dialysis_irrigation,
+		BloodAccessId:          blood_access_id,
+		NucleinDate:            theNucleinDate,
 	}
 
 	createErr := service.MobileCreateDialysisOrder(adminUserInfo.CurrentOrgId, patientID, dialysisRecord)
 
 		// 如果当天有插入数据，则不再往透析纪录里插入数据
 		if newdialysisRecord.ID > 0 {
+
+			//针对长沙南雅医院
+			if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10340 {
+
+				record.Temperature = 36.5
+				record.ArterialPressure = -100
+				record.Conductivity = 14
+				record.BreathingRate = "20"
+				record.DialysateTemperature = 36.5
+				record.VenousPressure = 80
+				record.TransmembranePressure = 60
+			}
+
 			err := service.CreateMonitor(&record)
 			key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":monitor_records"
 
 	internal_fistula := this.GetString("internal_fistula")
 	catheter := this.GetString("catheter")
 	cruor := this.GetString("cruor")
+	mission := this.GetString("mission")
 	if patientID <= 0 || len(recordDateStr) == 0 || nurseID <= 0 {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 			//获取最后一条透析处方数据
 			prescription, _ := service.GetLastDialysisPrescriptionByPatientIdTwo(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
 			evaluation, _ := service.MobileGetPredialysisEvaluationTwo(adminUserInfo.CurrentOrgId, patientID, recordDate.Unix())
-			tempassessmentAfterDislysis.WeightAfter = evaluation.WeightBefore - prescription.TargetUltrafiltration
+			tempassessmentAfterDislysis.WeightAfter = evaluation.WeightBefore - prescription.TargetUltrafiltration/1000
 		}
 		if adminUserInfo.CurrentOrgId == 10101 {
 			tempassessmentAfterDislysis.ActualUltrafiltration = endmonitorRecords.UltrafiltrationVolume / 1000
 
 	err := service.UpdateAssessmentAfterDislysisRecord(&tempassessmentAfterDislysis)
 
-	if adminUserInfo.CurrentOrgId == 9671 || adminUserInfo.CurrentOrgId == 9675 || adminUserInfo.CurrentOrgId == 10164 || adminUserInfo.CurrentOrgId == 10340 {
+	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 {
 	}()
 
 	//执行下机
-	updateErr := service.ModifyDialysisRecord(dialysisRecord.ID, nurseID, endDate.Unix(), adminUserInfo.AdminUser.Id, puncture_point_haematoma, internal_fistula, catheter, cruor)
+	updateErr := service.ModifyDialysisRecord(dialysisRecord.ID, nurseID, endDate.Unix(), adminUserInfo.AdminUser.Id, puncture_point_haematoma, internal_fistula, catheter, cruor, mission)
 	key := strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":dialysis_order"
 	redis := service.RedisClient()
 	defer redis.Close()
 	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")
+	puncture_needle := this.GetString("puncture_needle")
+	puncture_way := this.GetString("puncture_way")
+	dialysis_dialyszers := this.GetString("dialysis_dialyszers")
+	dialysis_irrigation := this.GetString("dialysis_irrigation")
+	blood_access_id, _ := this.GetInt64("blood_access_id")
+	nuclein_date := this.GetString("nuclein_date")
 	if record_id == 0 {
 		this.ErrorLog("id:%v", record_id)
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 	schedulestartTime := theStartTime.Unix()
 	scheduleendTime := theEndTime.Unix()
 
+	var theNucleinDate int64
+	timeLayoutOne := "2006-01-02"
+
+	if len(nuclein_date) > 0 {
+		theTime, err := time.ParseInLocation(timeLayoutOne+" 15:04:05", nuclein_date+" 00:00:00", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+		}
+		theNucleinDate = theTime.Unix()
+	}
 	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机
 
 	schedule, err := service.GetDayScheduleByBedid(adminUserInfo.CurrentOrgId, schedulestartTime, bedID, schedual_type)
 		}
 
 	}
+	fmt.Println("theNucleinDate", theNucleinDate)
 	dialysisRecord := &models.DialysisOrder{
 		ID:                     record_id,
 		UserOrgId:              adminUserInfo.CurrentOrgId,
 		ChangeNurse:            change_nurse,
 		DifficultPunctureNurse: difficult_puncture_nurse,
 		NewFistulaNurse:        new_fistula_nurse,
+		QualityNurseId:         quality_nurse,
+		PunctureWay:            puncture_way,
+		PunctureNeedle:         puncture_needle,
+		DialysisDialyszers:     dialysis_dialyszers,
+		DialysisIrrigation:     dialysis_irrigation,
+		BloodAccessId:          blood_access_id,
+		NucleinDate:            theNucleinDate,
 	}
 
 	updateErr := service.ModifyStartDialysisOrder(dialysisRecord)
 	internal_fistula := c.GetString("internal_fistula")
 	catheter := c.GetString("catheter")
 	cruor := c.GetString("cruor")
+	mission := c.GetString("mission")
 	if record_id <= 0 || nurseID <= 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 		BloodAccessInternalFistula: internal_fistula,
 		Catheter:                   catheter,
 		Cruor:                      cruor,
+		Mission:                    mission,
 	}
 
 	updateErr := service.ModifyFinishDialysisOrder(dialysisRecord)

controllers/doctors_api_controller.go

 func (c *DoctorsApiController) GetAllDoctorAndNurse() {
 
 	adminUserInfo := c.GetAdminUserInfo()
-	doctors, nursers, _ := service.GetAllDoctorAndNurse(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId)
+	doctors, nursers, _ := service.GetAllDoctorAndNurseSix(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"doctors": doctors,
 
 	adminUserInfo := c.GetAdminUserInfo()
 	users, _ := service.GetAllAdminUsersTwo(adminUserInfo.CurrentOrgId)
+	operators, _ := service.GetAdminUserEsOne(adminUserInfo.CurrentOrgId)
 	c.ServeSuccessJSON(map[string]interface{}{
-		"users": users,
+		"users":     users,
+		"operators": operators,
 	})
 	return
 }

controllers/drug_stock_api_contorller.go

 					IsCheck:          2,
 					StockMinNumber:   0,
 				}
-				fmt.Println(warehouseInfo)
+				//fmt.Println(warehouseInfo)
 				warehousingInfo = append(warehousingInfo, warehouseInfo)
 			}
 		}
 					AdminUserId:             admin_user_id,
 					StockCount:              stock_count,
 					IsCheck:                 2,
+					SysRecordTime:           warehousingOutDate.Unix(),
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 			}
 
 			Creator := c.GetAdminUserInfo().AdminUser.Id
+
+			//查询默认仓库
+
+			//查询默认仓库剩余多少库存
+			list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
+			var sum_count int64
+			var sum_in_count int64
+			for _, it := range list {
+				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
+				if it.MaxUnit == baseDrug.MaxUnit {
+					it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
+					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
+				}
+				sum_count += it.StockMaxNumber + it.StockMinNumber
+				sum_in_count += it.WarehousingCount
+			}
 			flow := &models.DrugFlow{
 				WarehousingId:           0,
 				DrugId:                  item.DrugId,
 				MaxUnit:                 item.MaxUnit,
 				MinUnit:                 item.MinUnit,
 				StorehouseId:            item.StorehouseId,
+				OverCount:               sum_count,
 			}
 			service.CreateDrugFlowTwo(flow)
-
-			//查询默认仓库
-
-			//查询默认仓库剩余多少库存
-			list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
-			var sum_count int64
-			var sum_in_count int64
-			for _, it := range list {
-				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
-				if it.MaxUnit == baseDrug.MaxUnit {
-					it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
-					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
-				}
-				sum_count += it.StockMaxNumber + it.StockMinNumber
-				sum_in_count += it.WarehousingCount
-			}
+			//更新基础库剩余库存
 			service.UpdateMedicalSumCount(item.DrugId, sum_count, sum_in_count, item.OrgId)
 
 			drugInfolist, _ := service.GetDrugSumCountByStorehouseId(item.StorehouseId, item.OrgId, item.DrugId)
 				baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
 				if it.MaxUnit == baseDrug.MaxUnit {
 					it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
+					it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
 				}
+			}
+			for _, it := range drugInfolist {
 				total_count += it.WarehousingCount
-				over_count += it.StockMaxNumber*baseDrug.MinNumber + it.StockMinNumber
+				over_count += it.StockMaxNumber + it.StockMinNumber
 			}
 			//查询该仓库是否有默认数据
 			_, errcode := service.GetDrugStockCount(item.StorehouseId, item.DrugId, item.OrgId)
 		}
 		drugInfolist, _ := service.GetDrugSumCountByStorehouseId(item.StorehouseId, item.OrgId, item.DrugId)
 		var over_count int64 //剩余库存
+		for _, it := range drugInfolist {
+			if it.MaxUnit == medical.MaxUnit {
+				it.StockMaxNumber = it.StockMaxNumber * medical.MinNumber
+			}
+		}
 		for _, it := range drugInfolist {
 			over_count += it.StockMaxNumber*medical.MinNumber + it.StockMinNumber
 		}
 	storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
 
 	for _, it := range warehousingOutInfoList {
+		fmt.Println("countunit23322332232323wo", it.CountUnit)
 		var total_count int64
 		var out_count int64
 		//查询剩余库存
 			total_count += item.StockMaxNumber + item.StockMinNumber
 		}
 
-		//if it.CountUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
-		//	it.Count = it.Count * drup.MinNumber
-		//}
-		//out_count += it.Count
-
 		//出库数量累加
 		if it.CountUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
 			out_count = it.Count * drup.MinNumber
 			return
 		}
 	}
-	for _, it := range warehousingOutInfoList {
-
-		drup, _ := service.FindBaseDrugLibRecord(it.OrgId, it.DrugId)
-		//出库逻辑
-		service.AutoDrugDeliverInfoFourtyOne(orgId, it.Count, &drugWarehouseOut, &drup, it)
+	warehousingOutInfoListTwo, _ := service.GetDrugWarehouseOutListById(warehouse_out_id, orgId)
 
+	for _, it := range warehousingOutInfoListTwo {
 		medical, _ := service.GetBaseDrugMedical(it.DrugId)
-		//查询剩余库存
-		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, it.OrgId, it.DrugId)
-		var sum_count int64
-		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
-
-		}
-		service.UpdateBaseDrugSumTwo(it.DrugId, sum_count, it.OrgId)
-
 		////出库数量累加
 		var out_count_one int64
+		fmt.Println("it.count", it.CountUnit)
+		fmt.Println("MaxUnit", medical.MaxUnit)
+		fmt.Println("MinUnit", medical.MinUnit)
+		fmt.Println("count", it.Count)
+		fmt.Println("number", medical.MinNumber)
 		if it.CountUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
 			out_count_one = it.Count * medical.MinNumber
 		}
 			out_count_one = it.Count
 		}
 
-		if it.CountUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
+		if it.CountUnit == medical.MaxUnit && medical.MaxUnit == medical.MinUnit {
 			out_count_one = it.Count
 		}
-
-		fmt.Println("out_count23233232323woede", out_count_one)
+		fmt.Println("countone3232232323323232332332wo", out_count_one)
 		//增加出库数量
 		service.AddDrugCount(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut, out_count_one)
+		fmt.Println("countunit23322332232323", it.CountUnit)
 
-		//查询该药品剩余库存
-		infolist, _ := service.FindDrugWarehouseInfoFlushCountByStorehouse(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut)
-		var over_count int64
-		for _, its := range infolist {
-			over_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+	}
+	warehousingOutInfoListThree, _ := service.GetDrugWarehouseOutListById(warehouse_out_id, orgId)
+	for _, it := range warehousingOutInfoListThree {
+		medical, _ := service.GetBaseDrugMedical(it.DrugId)
+		drup, _ := service.FindBaseDrugLibRecord(it.OrgId, it.DrugId)
+		//出库逻辑
+		service.AutoDrugDeliverInfoFourtyOne(orgId, it.Count, &drugWarehouseOut, &drup, it)
+
+		//查询剩余库存
+		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, it.OrgId, it.DrugId)
+		var sum_count int64
+		for _, its := range stockInfo {
+			if its.MaxUnit == medical.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
-		service.UpdateDrugStockCount(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut, over_count)
+		//更新基础库库存
+		service.UpdateBaseDrugSumTwo(it.DrugId, sum_count, it.OrgId)
+
+		//查询该药品剩余库存
+		//infolist, _ := service.FindDrugWarehouseInfoFlushCountByStorehouse(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut)
+		//var over_count int64
+		//for _, its := range infolist {
+		//  over_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+		//}
+		//更新剩余库存
+		service.UpdateDrugStockCount(it.DrugId, it.OrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
+
 	}
 
 	out := models.DrugWarehouseOut{
 		IsCheck: 1,
 	}
-
+	//更新审核状态
 	service.UpdateCheckDrugOut(out, warehouse_out_id)
-	info := models.DrugWarehouseOutInfo{
-		IsCheck: 1,
-	}
-	service.UpdateCheckDrugOutInfo(info, warehouse_out_id)
+	//info := models.DrugWarehouseOutInfo{
+	//	IsCheck: 1,
+	//}
+	//service.UpdateCheckDrugOutInfo(info, warehouse_out_id)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"warehousingOutInfoList": warehousingOutInfoList,
 		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+			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.OrgId)
 
 			}
 		}
 
-		//查询该批次的退库数量
-		drugFlow := models.DrugFlow{
-			ID:                        0,
-			WarehousingId:             its.BatchNumberId,
-			DrugId:                    its.DrugId,
-			Number:                    its.Number,
-			BatchNumber:               "",
-			Count:                     its.Count,
-			UserOrgId:                 its.OrgId,
-			PatientId:                 0,
-			SystemTime:                cancelDrugStock.ReturnTime,
-			ConsumableType:            4,
-			IsSys:                     0,
-			WarehousingOrder:          "",
-			WarehouseOutId:            0,
-			WarehouseOutOrderNumber:   "",
-			IsEdit:                    0,
-			CancelStockId:             0,
-			CancelOrderNumber:         its.OrderNumber,
-			Manufacturer:              manufacturer_id,
-			Dealer:                    dealer_id,
-			Creator:                   creater,
-			UpdateCreator:             0,
-			Status:                    1,
-			Ctime:                     time.Now().Unix(),
-			Mtime:                     0,
-			Price:                     its.Price,
-			WarehousingDetailId:       its.BatchNumberId,
-			WarehouseOutDetailId:      0,
-			CancelOutDetailId:         its.ID,
-			ExpireDate:                its.ExpiryDate,
-			ProductDate:               its.ProductDate,
-			MaxUnit:                   its.MaxUnit,
-			MinUnit:                   "",
-			StockMaxNumber:            0,
-			StockMinNumber:            0,
-			LastStockMaxNumber:        0,
-			LastStockMinNumber:        0,
-			AdviceId:                  0,
-			SupplyWarehouseId:         0,
-			SupplyCancelOutId:         0,
-			SupplyWarehouseDetailInfo: 0,
-			StorehouseId:              its.StorehouseId,
-			SecondWarehouseInfoId:     0,
-			AdminUserId:               0,
-			LastPrice:                 0,
-			StockCount:                "",
-			PharmacyId:                0,
-		}
-		service.CreateDrugFlowOne(drugFlow)
-
 		medical, _ := service.GetBaseDrugMedical(its.DrugId)
 		if its.MaxUnit == medical.MaxUnit && medical.MaxUnit != medical.MinUnit {
 			var sum_cancel_count int64
 			sum_cancel_count += its.Count * medical.MinNumber
-			//退库数量增加
-			//service.ModifyAddCancelAddInfomation(its.DrugId,sum_cancel_count,its.OrgId,its.StorehouseId)
 			//出库数量减少
 			service.ModifyAddDrugOutReduceInfomation(its.DrugId, sum_cancel_count, its.OrgId, its.StorehouseId)
 		}
 
 		if its.MaxUnit == medical.MinUnit && medical.MaxUnit != medical.MinUnit {
-			//退库数量增加
-			//service.ModifyAddCancelAddInfomation(its.DrugId,its.Count,its.OrgId,its.StorehouseId)
 			//出库数量减少
 			service.ModifyAddDrugOutReduceInfomation(its.DrugId, its.Count, its.OrgId, its.StorehouseId)
 		}
 
 		if its.MaxUnit == medical.MinUnit && medical.MaxUnit == medical.MinUnit {
-			//退库数量增加
-			//service.ModifyAddCancelAddInfomation(its.DrugId,its.Count,its.OrgId,its.StorehouseId)
 			//出库数量减少
 			service.ModifyAddDrugOutReduceInfomation(its.DrugId, its.Count, its.OrgId, its.StorehouseId)
 		}
 		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, its.OrgId, its.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+			baseDrug, _ := service.GetBaseDrugMedical(its.DrugId)
+			if its.MaxUnit == baseDrug.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
+		//更新剩余库存
 		service.UpdateBaseDrugSumTwo(its.DrugId, sum_count, its.OrgId)
 
 		var cancel_count int64
 		}
 		cancelInfo, _ := service.GetDrugAllStockInfo(its.StorehouseId, its.OrgId, its.DrugId)
 		var over_count int64
-		for _, items := range cancelInfo {
-			over_count += items.StockMaxNumber*medical.MinNumber + items.StockMinNumber
+		for _, its := range cancelInfo {
+			if its.MaxUnit == medical.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+			}
+			over_count += its.StockMaxNumber + its.StockMinNumber
 		}
+		//查询该批次的退库数量
+		drugFlow := models.DrugFlow{
+			ID:                        0,
+			WarehousingId:             its.BatchNumberId,
+			DrugId:                    its.DrugId,
+			Number:                    its.Number,
+			BatchNumber:               "",
+			Count:                     its.Count,
+			UserOrgId:                 its.OrgId,
+			PatientId:                 0,
+			SystemTime:                cancelDrugStock.ReturnTime,
+			ConsumableType:            4,
+			IsSys:                     0,
+			WarehousingOrder:          "",
+			WarehouseOutId:            0,
+			WarehouseOutOrderNumber:   "",
+			IsEdit:                    0,
+			CancelStockId:             0,
+			CancelOrderNumber:         its.OrderNumber,
+			Manufacturer:              manufacturer_id,
+			Dealer:                    dealer_id,
+			Creator:                   creater,
+			UpdateCreator:             0,
+			Status:                    1,
+			Ctime:                     time.Now().Unix(),
+			Mtime:                     0,
+			Price:                     its.Price,
+			WarehousingDetailId:       its.BatchNumberId,
+			WarehouseOutDetailId:      0,
+			CancelOutDetailId:         its.ID,
+			ExpireDate:                its.ExpiryDate,
+			ProductDate:               its.ProductDate,
+			MaxUnit:                   its.MaxUnit,
+			MinUnit:                   "",
+			StockMaxNumber:            0,
+			StockMinNumber:            0,
+			LastStockMaxNumber:        0,
+			LastStockMinNumber:        0,
+			AdviceId:                  0,
+			SupplyWarehouseId:         0,
+			SupplyCancelOutId:         0,
+			SupplyWarehouseDetailInfo: 0,
+			StorehouseId:              its.StorehouseId,
+			SecondWarehouseInfoId:     0,
+			AdminUserId:               0,
+			LastPrice:                 0,
+			StockCount:                "",
+			PharmacyId:                0,
+			OverCount:                 over_count,
+		}
+		service.CreateDrugFlowOne(drugFlow)
+		//增加退库数量 更新剩余库存
 		service.AddCancelSumCount(its.StorehouseId, its.DrugId, its.OrgId, cancel_count, over_count)
-
+		//更改审核状态
 		service.ModifyCancelStock(cancelstock_id, cancelStock, orgId)
 	}
 	//新增库存
 		stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.OrgId, item.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+			if its.MaxUnit == medical.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
+
 		service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.OrgId)
 
 		var cancel_count int64
 		}
 		cancelInfo, _ := service.GetDrugAllStockInfo(item.StorehouseId, item.OrgId, item.DrugId)
 		var over_count int64
-		for _, items := range cancelInfo {
-			over_count += items.StockMaxNumber*medical.MinNumber + items.StockMinNumber
+		for _, its := range cancelInfo {
+			if its.MaxUnit == medical.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+			}
+			over_count += its.StockMaxNumber + its.StockMinNumber
 		}
+
 		//退库数量减少，更新剩余库存
 		service.ReduceCancelSumCount(item.StorehouseId, item.DrugId, item.OrgId, cancel_count, over_count)
 	}

controllers/gobal_config_api_controller.go

 	beego.Router("/api/hisstockpriceconfig/get", &GobalConfigApiController{}, "get:GetHisStockPriceConfig")
 	beego.Router("/api/hisstockpriceconfig/isopen", &GobalConfigApiController{}, "post:PostHisStockPriceConfig")
 
-	beego.Router("/api/xtconfig/get", &GobalConfigApiController{}, "get:GetXTHisConfig")
-	beego.Router("/api/xtconfig/isopen", &GobalConfigApiController{}, "post:PostXTHisConfig")
-
 	beego.Router("/api/xtconfigproject/isopen", &GobalConfigApiController{}, "post:PostXTHisProjectConfig")
 
 	beego.Router("/api/isopen/init", &GobalConfigApiController{}, "get:GetAllIsOpenConfig")
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	//list, _ := service.GetExportOutOrderDrugList(ids)
 	list, _ := service.GetExportOutOrderDrugListOne(ids)
+	outInfoList, _ := service.GetDrugOutListFlow(ids, orgId)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	dealerList, _ := service.GetAllDealerList(orgId)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 		"manufacturerList": manufacturerList,
 		"dealerList":       dealerList,
+		"outInfoList":      outInfoList,
 	})
 }
 
 	stock_type, _ := c.GetInt64("stock_type")
 
 	list, total, _ := service.GetDrugFlow(drug_id, orgId, limit, page, startTime, endTime, stock_type)
+	fmt.Println("listwowoowowowowowo", list)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	dealerList, _ := service.GetAllDealerList(orgId)
 	medical, _ := service.GetBaseDrugMedical(drug_id)

controllers/his_api_controller.go

 														c.ServeDynamicFailJsonSend(drug.DrugName + "该批次剩余库存不足,剩余库存:" + strconv.FormatInt(info.StockMaxNumber, 10) + drug.MaxUnit + strconv.FormatInt(info.StockMinNumber, 10) + drug.MinUnit)
 														return
 													}
-													if adminInfo.CurrentOrgId == 10215 || adminInfo.CurrentOrgId == 10164 || adminInfo.CurrentOrgId == 3877 {
+													if adminInfo.CurrentOrgId == 10215 || adminInfo.CurrentOrgId == 10164 || adminInfo.CurrentOrgId == 3877 || adminInfo.CurrentOrgId == 9671 {
 														// 查询该药品最后一次出库记录
 														outInfo, _ := service.GetLastDrugWarehouseOutByDrugIdTwenty(drug_id, patient_id, recordDateTime, adviceId)
 
 													var sum_count int64
 													stockInfo, _ := service.GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, druginfo.OrgId, drug_id)
 													for _, its := range stockInfo {
-														sum_count += its.StockMaxNumber*drug.MinNumber + its.StockMinNumber
+														if its.MaxUnit == drug.MaxUnit {
+															its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
+														}
+														sum_count += its.StockMaxNumber + its.StockMinNumber
 													}
+
 													service.UpdateBaseDrugSumTwo(drug_id, sum_count, druginfo.OrgId)
 
 												}
 										goodList, _ := service.GetAllAutoRecordByPatient(patient_id, recordDateTime)
 
 										for _, item := range goodList {
-											//回退库存
-											//service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
-
-											//service.ModifyReduceGoodSumCount(item.StorehouseId,item.Count,item.OrgId,item.GoodId)
 
 											goodListSix, _ := service.GetSumGoodList(item.OrgId, item.StorehouseId, item.GoodId)
 											var flush_count int64
 											goodList, _ := service.GetAllAutoRecordByPatient(patient_id, recordDateTime)
 
 											for _, item := range goodList {
-												//回退库存
-												//service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
-												//扣减出库数量
-												//service.ModifyReduceGoodSumCount(item.StorehouseId,item.Count,item.OrgId,item.GoodId)
 
 												goodListSix, _ := service.GetSumGoodList(item.OrgId, item.StorehouseId, item.GoodId)
 												var flush_count int64
 					projects := items["project"].([]interface{})
 					if len(projects) > 0 {
 						for _, project := range projects {
+
 							var p models.HisPrescriptionProject
 							p.PrescriptionId = tempPrescription.ID
 							p.Ctime = time.Now().Unix()
 								c.ServeFailJSONWithSGJErrorCode(errcode)
 								return
 							}
-
+							fmt.Println("projext22222222222222", p.ID)
+							if p.ID == 0 {
+								p.IsOut = 2
+							}
+							if p.ID > 0 {
+								projectDetail, _ := service.GetHisPrescriptonProjectById(p.ID)
+								p.IsOut = projectDetail.IsOut
+							}
 							service.CreateHisProjectTwo(&p)
 							projectList = append(projectList, p)
 							var randNum int
 						}
 						sum_count += its.StockMaxNumber + its.StockMinNumber
 					}
+					//更新基础库存
 					service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
 					//剩余库存
 					service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeConfig.DrugStorehouseOut, sum_count)
 		for _, item := range projects {
 			service.DeletePrintInfo(item.ID) //删除打印信息
 			if stockConfig.IsOpen == 1 {
-				if item.Type == 3 {
+				if item.Type == 3 && item.IsOut == 1 {
 					good, _ := service.FindGoodInfoByIdTwo(item.ProjectId)
 					f_count, _ := strconv.ParseFloat(item.Count, 64)
 					good.Total = good.Total + f_count
 					manufacturer, _ := service.GetManufactureById(info.Manufacturer)
 					deaerler, _ := service.GetDealerById(info.Dealer)
 
-					//查询今日该患者开了多少耗材
-					//projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
-					//
 					var total_count int64
-					//var cha_count int64
-					//for _, item := range projectList {
-					//  count, _ := strconv.ParseInt(item.Count, 10, 64)
-					//  total_count += count
-					//}
 					count, _ := strconv.ParseInt(item.Count, 10, 64)
 					total_count += count
-					//回退库存
-					service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, total_count, info.PatientId, info.SysRecordTime, info.ProjectId)
-					goodList, _ := service.GetSumGoodList(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, info.ProjectId)
+
+					goodList, _ := service.GetSumGoodList(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId)
 					var flush_count int64
 					for _, it := range goodList {
 						flush_count += it.StockCount
 					}
 					if info.ID > 0 {
-						cancelStockInfo := models.CancelStockInfo{
-							GoodId:          item.ProjectId,
-							CancelStockId:   cancel.ID,
-							GoodTypeId:      good.GoodTypeId,
-							Count:           prescribingNumber,
-							Price:           info.Price,
-							Total:           0,
-							ProductDate:     info.ProductDate,
-							ExpiryDate:      info.ExpiryDate,
-							Ctime:           time.Now().Unix(),
-							Status:          1,
-							OrgId:           c.GetAdminUserInfo().CurrentOrgId,
-							OrderNumber:     cancel.OrderNumber,
-							Type:            0,
-							Dealer:          deaerler.DealerName,
-							Manufacturer:    manufacturer.ManufacturerName,
-							Number:          info.Number,
-							RegisterAccount: "",
-							Remark:          "",
-							WarehouseInfoId: info.WarehouseInfotId,
-							PatientId:       info.PatientId,
-							RecordDate:      info.SysRecordTime,
-							StorehouseId:    houseConfig.StorehouseOutInfo,
-							IsCheck:         1,
+						if info.Count >= total_count {
+
+							//回退库存
+							service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, total_count, info.PatientId, info.SysRecordTime, item.ProjectId)
+							cancelStockInfo := models.CancelStockInfo{
+								GoodId:          item.ProjectId,
+								CancelStockId:   cancel.ID,
+								GoodTypeId:      good.GoodTypeId,
+								Count:           prescribingNumber,
+								Price:           info.Price,
+								Total:           0,
+								ProductDate:     info.ProductDate,
+								ExpiryDate:      info.ExpiryDate,
+								Ctime:           time.Now().Unix(),
+								Status:          1,
+								OrgId:           c.GetAdminUserInfo().CurrentOrgId,
+								OrderNumber:     cancel.OrderNumber,
+								Type:            0,
+								Dealer:          deaerler.DealerName,
+								Manufacturer:    manufacturer.ManufacturerName,
+								Number:          info.Number,
+								RegisterAccount: "",
+								Remark:          "",
+								WarehouseInfoId: info.WarehouseInfotId,
+								PatientId:       info.PatientId,
+								RecordDate:      info.SysRecordTime,
+								StorehouseId:    houseConfig.StorehouseOutInfo,
+								IsCheck:         1,
+							}
+
+							service.CreateCancelStockInfoOne(&cancelStockInfo)
+
+							cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(item.ProjectId)
+
+							flow := models.VmStockFlow{
+								WarehousingId:           info.WarehouseInfotId,
+								GoodId:                  item.ProjectId,
+								Number:                  info.Number,
+								LicenseNumber:           info.LicenseNumber,
+								Count:                   prescribingNumber,
+								UserOrgId:               c.GetAdminUserInfo().CurrentOrgId,
+								PatientId:               item.PatientId,
+								SystemTime:              info.SysRecordTime,
+								ConsumableType:          7,
+								IsSys:                   0,
+								WarehousingOrder:        "",
+								WarehouseOutId:          info.WarehouseOutId,
+								WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
+								IsEdit:                  0,
+								CancelStockId:           cancel.ID,
+								CancelOrderNumber:       cancel.OrderNumber,
+								Manufacturer:            manufacturer.ID,
+								Dealer:                  0,
+								Creator:                 c.GetAdminUserInfo().CurrentOrgId,
+								UpdateCreator:           0,
+								Status:                  1,
+								Ctime:                   time.Now().Unix(),
+								Mtime:                   0,
+								Price:                   info.Price,
+								WarehousingDetailId:     info.WarehouseInfotId,
+								WarehouseOutDetailId:    info.ID,
+								CancelOutDetailId:       cancelInfo.ID,
+								ProductDate:             info.ProductDate,
+								ExpireDate:              info.ExpiryDate,
+								StorehouseId:            houseConfig.StorehouseOutInfo,
+								OverCount:               flush_count,
+							}
+							service.CreateStockFlowOne(flow)
+
+							//退库数量增加
+							service.UpdateSumAddCancelCount(c.GetAdminUserInfo().CurrentOrgId, item.ProjectId, houseConfig.StorehouseOutInfo, total_count)
+							//出库数量减少
+							service.UpdateSumCount(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, total_count)
 						}
 
-						service.CreateCancelStockInfoOne(&cancelStockInfo)
-
-						cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(item.ProjectId)
-
-						flow := models.VmStockFlow{
-							WarehousingId:           info.WarehouseInfotId,
-							GoodId:                  item.ProjectId,
-							Number:                  info.Number,
-							LicenseNumber:           info.LicenseNumber,
-							Count:                   prescribingNumber,
-							UserOrgId:               c.GetAdminUserInfo().CurrentOrgId,
-							PatientId:               item.PatientId,
-							SystemTime:              info.SysRecordTime,
-							ConsumableType:          7,
-							IsSys:                   0,
-							WarehousingOrder:        "",
-							WarehouseOutId:          info.WarehouseOutId,
-							WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
-							IsEdit:                  0,
-							CancelStockId:           cancel.ID,
-							CancelOrderNumber:       cancel.OrderNumber,
-							Manufacturer:            manufacturer.ID,
-							Dealer:                  0,
-							Creator:                 c.GetAdminUserInfo().CurrentOrgId,
-							UpdateCreator:           0,
-							Status:                  1,
-							Ctime:                   time.Now().Unix(),
-							Mtime:                   0,
-							Price:                   info.Price,
-							WarehousingDetailId:     info.WarehouseInfotId,
-							WarehouseOutDetailId:    info.ID,
-							CancelOutDetailId:       cancelInfo.ID,
-							ProductDate:             info.ProductDate,
-							ExpireDate:              info.ExpiryDate,
-							StorehouseId:            houseConfig.StorehouseOutInfo,
-							OverCount:               flush_count,
+						if info.Count < total_count {
+							//回退库存
+							service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, info.Count, info.PatientId, info.SysRecordTime, item.ProjectId)
+							cancelStockInfo := models.CancelStockInfo{
+								GoodId:          item.ProjectId,
+								CancelStockId:   cancel.ID,
+								GoodTypeId:      good.GoodTypeId,
+								Count:           info.Count,
+								Price:           info.Price,
+								Total:           0,
+								ProductDate:     info.ProductDate,
+								ExpiryDate:      info.ExpiryDate,
+								Ctime:           time.Now().Unix(),
+								Status:          1,
+								OrgId:           c.GetAdminUserInfo().CurrentOrgId,
+								OrderNumber:     cancel.OrderNumber,
+								Type:            0,
+								Dealer:          deaerler.DealerName,
+								Manufacturer:    manufacturer.ManufacturerName,
+								Number:          info.Number,
+								RegisterAccount: "",
+								Remark:          "",
+								WarehouseInfoId: info.WarehouseInfotId,
+								PatientId:       info.PatientId,
+								RecordDate:      info.SysRecordTime,
+								StorehouseId:    houseConfig.StorehouseOutInfo,
+								IsCheck:         1,
+							}
+
+							service.CreateCancelStockInfoOne(&cancelStockInfo)
+
+							cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(item.ProjectId)
+
+							flow := models.VmStockFlow{
+								WarehousingId:           info.WarehouseInfotId,
+								GoodId:                  item.ProjectId,
+								Number:                  info.Number,
+								LicenseNumber:           info.LicenseNumber,
+								Count:                   info.Count,
+								UserOrgId:               c.GetAdminUserInfo().CurrentOrgId,
+								PatientId:               item.PatientId,
+								SystemTime:              info.SysRecordTime,
+								ConsumableType:          7,
+								IsSys:                   0,
+								WarehousingOrder:        "",
+								WarehouseOutId:          info.WarehouseOutId,
+								WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
+								IsEdit:                  0,
+								CancelStockId:           cancel.ID,
+								CancelOrderNumber:       cancel.OrderNumber,
+								Manufacturer:            manufacturer.ID,
+								Dealer:                  0,
+								Creator:                 c.GetAdminUserInfo().CurrentOrgId,
+								UpdateCreator:           0,
+								Status:                  1,
+								Ctime:                   time.Now().Unix(),
+								Mtime:                   0,
+								Price:                   info.Price,
+								WarehousingDetailId:     info.WarehouseInfotId,
+								WarehouseOutDetailId:    info.ID,
+								CancelOutDetailId:       cancelInfo.ID,
+								ProductDate:             info.ProductDate,
+								ExpireDate:              info.ExpiryDate,
+								StorehouseId:            houseConfig.StorehouseOutInfo,
+								OverCount:               flush_count,
+							}
+							service.CreateStockFlowOne(flow)
+
+							//退库数量增加
+							service.UpdateSumAddCancelCount(c.GetAdminUserInfo().CurrentOrgId, item.ProjectId, houseConfig.StorehouseOutInfo, info.Count)
+							//出库数量减少
+							service.UpdateSumCount(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, info.Count)
 						}
-						service.CreateStockFlowOne(flow)
 
 						//查询已出库数量
-						dialysisInfo, _ := service.GetGoodDialysisOutInfo(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
+						dialysisInfo, _ := service.GetGoodDialysisOutInfoSix(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
 
 						if prescribingNumber < dialysisInfo.Count {
 							//改变数量
 							service.UpdateAutoGood(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId, item.ID, prescribingNumber)
 						}
 
-						if prescribingNumber == dialysisInfo.Count {
+						if prescribingNumber >= dialysisInfo.Count {
 							//删除出库表
 							service.DeleteAutoRedeceDetailTen(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
 						}
 
-						////删除出库表
-						//service.DeleteAutoRedeceDetailTen(c.GetAdminUserInfo().CurrentOrgId, info.PatientId, info.SysRecordTime, item.ProjectId)
-
-						//退库数量增加
-						service.UpdateSumAddCancelCount(c.GetAdminUserInfo().CurrentOrgId, item.ProjectId, houseConfig.StorehouseOutInfo, total_count)
-						//出库数量减少
-						service.UpdateSumCount(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, total_count)
-
 						//更新库存
 						service.UpdateSumGood(c.GetAdminUserInfo().CurrentOrgId, houseConfig.StorehouseOutInfo, item.ProjectId, flush_count)
 
+						//更新基础库库存
+						service.UpdateGoodInfoSumCountSix(item.ProjectId, flush_count, c.GetAdminUserInfo().CurrentOrgId)
 						//查询今日该耗材退库数量
 						//cancelInfoOne, _ := service.GetCancelStockInfoByPatientId(info.PatientId, item.ProjectId, info.SysRecordTime)
 						//var cancel_Count int64
 			fmt.Println(err)
 		}
 
-		if project.Type == 3 {
+		if project.Type == 3 && project.IsOut == 1 {
 			houseConfig, _ := service.GetAllStoreHouseConfig(c.GetAdminUserInfo().CurrentOrgId)
 			good, _ := service.FindGoodInfoByIdTwo(project.ProjectId)
 			f_count, _ := strconv.ParseFloat(project.Count, 64)
 			manufacturer, _ := service.GetManufactureById(info.Manufacturer)
 			deaerler, _ := service.GetDealerById(info.Dealer)
 			if info.ID > 0 {
-				cancelStockInfo := models.CancelStockInfo{
-					GoodId:          project.ProjectId,
-					CancelStockId:   cancel.ID,
-					GoodTypeId:      good.GoodTypeId,
-					Count:           prescribingNumber,
-					Price:           info.Price,
-					Total:           0,
-					ProductDate:     info.ProductDate,
-					ExpiryDate:      info.ExpiryDate,
-					Ctime:           time.Now().Unix(),
-					Status:          1,
-					OrgId:           adminInfo.CurrentOrgId,
-					OrderNumber:     cancel.OrderNumber,
-					Type:            0,
-					Dealer:          deaerler.DealerName,
-					Manufacturer:    manufacturer.ManufacturerName,
-					Number:          info.Number,
-					RegisterAccount: "",
-					Remark:          "",
-					WarehouseInfoId: info.WarehouseInfotId,
-					PatientId:       info.PatientId,
-					RecordDate:      info.SysRecordTime,
-					StorehouseId:    houseConfig.StorehouseOutInfo,
-					IsCheck:         1,
-				}
-
-				service.CreateCancelStockInfoOne(&cancelStockInfo)
-
 				cancelInfo, _ := service.GetLastCancelStockInfoByGoodId(project.ProjectId)
+				if info.Count >= prescribingNumber {
+					cancelStockInfo := models.CancelStockInfo{
+						GoodId:          project.ProjectId,
+						CancelStockId:   cancel.ID,
+						GoodTypeId:      good.GoodTypeId,
+						Count:           prescribingNumber,
+						Price:           info.Price,
+						Total:           0,
+						ProductDate:     info.ProductDate,
+						ExpiryDate:      info.ExpiryDate,
+						Ctime:           time.Now().Unix(),
+						Status:          1,
+						OrgId:           adminInfo.CurrentOrgId,
+						OrderNumber:     cancel.OrderNumber,
+						Type:            0,
+						Dealer:          deaerler.DealerName,
+						Manufacturer:    manufacturer.ManufacturerName,
+						Number:          info.Number,
+						RegisterAccount: "",
+						Remark:          "",
+						WarehouseInfoId: info.WarehouseInfotId,
+						PatientId:       info.PatientId,
+						RecordDate:      info.SysRecordTime,
+						StorehouseId:    houseConfig.StorehouseOutInfo,
+						IsCheck:         1,
+					}
+
+					service.CreateCancelStockInfoOne(&cancelStockInfo)
+					//回退库存
+					service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, prescribingNumber, info.PatientId, info.SysRecordTime, project.ProjectId)
+					//退库数量增加
+					service.UpdateSumAddCancelCount(adminInfo.CurrentOrgId, project.ProjectId, houseConfig.StorehouseOutInfo, prescribingNumber)
+					//出库数量减少
+					service.UpdateSumCount(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, prescribingNumber)
+				}
+				if info.Count < prescribingNumber {
+					cancelStockInfo := models.CancelStockInfo{
+						GoodId:          project.ProjectId,
+						CancelStockId:   cancel.ID,
+						GoodTypeId:      good.GoodTypeId,
+						Count:           info.Count,
+						Price:           info.Price,
+						Total:           0,
+						ProductDate:     info.ProductDate,
+						ExpiryDate:      info.ExpiryDate,
+						Ctime:           time.Now().Unix(),
+						Status:          1,
+						OrgId:           adminInfo.CurrentOrgId,
+						OrderNumber:     cancel.OrderNumber,
+						Type:            0,
+						Dealer:          deaerler.DealerName,
+						Manufacturer:    manufacturer.ManufacturerName,
+						Number:          info.Number,
+						RegisterAccount: "",
+						Remark:          "",
+						WarehouseInfoId: info.WarehouseInfotId,
+						PatientId:       info.PatientId,
+						RecordDate:      info.SysRecordTime,
+						StorehouseId:    houseConfig.StorehouseOutInfo,
+						IsCheck:         1,
+					}
+
+					service.CreateCancelStockInfoOne(&cancelStockInfo)
+					//回退库存
+					service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, info.Count, info.PatientId, info.SysRecordTime, project.ProjectId)
+					//退库数量增加
+					service.UpdateSumAddCancelCount(adminInfo.CurrentOrgId, project.ProjectId, houseConfig.StorehouseOutInfo, info.Count)
+					//出库数量减少
+					service.UpdateSumCount(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, info.Count)
+				}
 
-				//回退库存
-				service.UpDateWarehouseInfoByStockDelete(info.WarehouseInfotId, prescribingNumber, info.PatientId, info.SysRecordTime, project.ProjectId)
 				goodList, _ := service.GetSumGoodList(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId)
 				var over_count int64
 				for _, it := range goodList {
 					over_count += it.StockCount
 				}
-				flow := models.VmStockFlow{
-					WarehousingId:           info.WarehouseInfotId,
-					GoodId:                  project.ProjectId,
-					Number:                  info.Number,
-					LicenseNumber:           info.LicenseNumber,
-					Count:                   prescribingNumber,
-					UserOrgId:               adminInfo.CurrentOrgId,
-					PatientId:               project.PatientId,
-					SystemTime:              time.Now().Unix(),
-					ConsumableType:          7,
-					IsSys:                   0,
-					WarehousingOrder:        "",
-					WarehouseOutId:          info.WarehouseOutId,
-					WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
-					IsEdit:                  0,
-					CancelStockId:           cancel.ID,
-					CancelOrderNumber:       cancel.OrderNumber,
-					Manufacturer:            manufacturer.ID,
-					Dealer:                  0,
-					Creator:                 adminInfo.AdminUser.Id,
-					UpdateCreator:           0,
-					Status:                  1,
-					Ctime:                   time.Now().Unix(),
-					Mtime:                   0,
-					Price:                   info.Price,
-					WarehousingDetailId:     info.WarehouseInfotId,
-					WarehouseOutDetailId:    info.ID,
-					CancelOutDetailId:       cancelInfo.ID,
-					ProductDate:             info.ProductDate,
-					ExpireDate:              info.ExpiryDate,
-					StorehouseId:            houseConfig.StorehouseOutInfo,
-					OverCount:               over_count,
+				if info.Count >= prescribingNumber {
+					flow := models.VmStockFlow{
+						WarehousingId:           info.WarehouseInfotId,
+						GoodId:                  project.ProjectId,
+						Number:                  info.Number,
+						LicenseNumber:           info.LicenseNumber,
+						Count:                   prescribingNumber,
+						UserOrgId:               adminInfo.CurrentOrgId,
+						PatientId:               project.PatientId,
+						SystemTime:              info.SysRecordTime,
+						ConsumableType:          7,
+						IsSys:                   0,
+						WarehousingOrder:        "",
+						WarehouseOutId:          info.WarehouseOutId,
+						WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
+						IsEdit:                  0,
+						CancelStockId:           cancel.ID,
+						CancelOrderNumber:       cancel.OrderNumber,
+						Manufacturer:            manufacturer.ID,
+						Dealer:                  0,
+						Creator:                 adminInfo.AdminUser.Id,
+						UpdateCreator:           0,
+						Status:                  1,
+						Ctime:                   time.Now().Unix(),
+						Mtime:                   0,
+						Price:                   info.Price,
+						WarehousingDetailId:     info.WarehouseInfotId,
+						WarehouseOutDetailId:    info.ID,
+						CancelOutDetailId:       cancelInfo.ID,
+						ProductDate:             info.ProductDate,
+						ExpireDate:              info.ExpiryDate,
+						StorehouseId:            houseConfig.StorehouseOutInfo,
+						OverCount:               over_count,
+					}
+					service.CreateStockFlowOne(flow)
+				}
+
+				if info.Count < prescribingNumber {
+					flow := models.VmStockFlow{
+						WarehousingId:           info.WarehouseInfotId,
+						GoodId:                  project.ProjectId,
+						Number:                  info.Number,
+						LicenseNumber:           info.LicenseNumber,
+						Count:                   info.Count,
+						UserOrgId:               adminInfo.CurrentOrgId,
+						PatientId:               project.PatientId,
+						SystemTime:              info.SysRecordTime,
+						ConsumableType:          7,
+						IsSys:                   0,
+						WarehousingOrder:        "",
+						WarehouseOutId:          info.WarehouseOutId,
+						WarehouseOutOrderNumber: info.WarehouseOutOrderNumber,
+						IsEdit:                  0,
+						CancelStockId:           cancel.ID,
+						CancelOrderNumber:       cancel.OrderNumber,
+						Manufacturer:            manufacturer.ID,
+						Dealer:                  0,
+						Creator:                 adminInfo.AdminUser.Id,
+						UpdateCreator:           0,
+						Status:                  1,
+						Ctime:                   time.Now().Unix(),
+						Mtime:                   0,
+						Price:                   info.Price,
+						WarehousingDetailId:     info.WarehouseInfotId,
+						WarehouseOutDetailId:    info.ID,
+						CancelOutDetailId:       cancelInfo.ID,
+						ProductDate:             info.ProductDate,
+						ExpireDate:              info.ExpiryDate,
+						StorehouseId:            houseConfig.StorehouseOutInfo,
+						OverCount:               over_count,
+					}
+					service.CreateStockFlowOne(flow)
 				}
-				service.CreateStockFlowOne(flow)
 
 				//查询已出库数量
-				dialysisInfo, _ := service.GetGoodDialysisOutInfo(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
+				dialysisInfo, _ := service.GetGoodDialysisOutInfoSix(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
 
 				if prescribingNumber < dialysisInfo.Count {
 					//改变数量
 					service.UpdateAutoGood(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId, id, prescribingNumber)
 				}
 
-				if prescribingNumber == dialysisInfo.Count {
+				if prescribingNumber >= dialysisInfo.Count {
 					//删除出库表
 					service.DeleteAutoRedeceDetailTen(adminInfo.CurrentOrgId, info.PatientId, info.SysRecordTime, project.ProjectId)
 				}
 
-				//退库数量增加
-				service.UpdateSumAddCancelCount(adminInfo.CurrentOrgId, project.ProjectId, houseConfig.StorehouseOutInfo, prescribingNumber)
-				//出库数量减少
-				service.UpdateSumCount(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, prescribingNumber)
-
 				//更新剩余库存
 				service.UpdateSumGood(adminInfo.CurrentOrgId, houseConfig.StorehouseOutInfo, project.ProjectId, over_count)
+
 				//查询今日该患者开了多少耗材
 				//projectList, _ := service.GetHisPrepscritionByPatientId(info.PatientId, project.ProjectId, info.SysRecordTime)
 				//
 			}
 			err := service.DelelteProject(id, c.GetAdminUserInfo().CurrentOrgId)
 			fmt.Println(err)
+		} else {
+			err := service.DelelteProject(id, c.GetAdminUserInfo().CurrentOrgId)
+			fmt.Println(err)
 		}
 
 	}

controllers/his_config_api_controller.go

 
 func HisConfigApiRegistRouters() {
 	beego.Router("/api/his/patient/list", &HisConfigApiController{}, "get:GetAllHisPatientsList")
+	beego.Router("/api/his/patient/getpatientlisttwenty", &HisConfigApiController{}, "get:GetPatientListTwenty")
 	beego.Router("/api/his/prescriptiontemplate/list", &HisConfigApiController{}, "get:GetPrescriptionTemplateList")
 	beego.Router("/api/his/prescriptiontemplate/info", &HisConfigApiController{}, "get:GetPrescriptionTemplateInfo")
 	beego.Router("/api/his/prescriptiontemplate/create", &HisConfigApiController{}, "post:CreatePrescriptionTemplate") //批量添加
 	})
 }
 
+func (c *HisConfigApiController) GetPatientListTwenty() {
+	patients, _, _ := service.GetAllPatientListTwenty(c.GetAdminUserInfo().CurrentOrgId)
+	c.ServeSuccessJSON(map[string]interface{}{
+		"list": patients,
+	})
+}
+
 func (c *HisConfigApiController) GetPrescriptionTemplateList() {
 	patient_id, _ := c.GetInt64("patient_id", 0)
 	page, _ := c.GetInt64("page", 0)

controllers/mobile_api_controllers/check_weight_api_controller.go

 			newprescribe.DewaterAmount = dewater_amount
 			newprescribe.TargetUltrafiltration = dewater_amount
 			newprescribe.Status = 1
+			newprescribe.Remark = dialysisSolution.Remark
+			if adminUserInfo.Org.Id == 10340 {
+				newprescribe.TargetUltrafiltration = 0
+			}
 			//插入透析处方
 			err := service.AddSigleRecord(&newprescribe)
 			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
 				newprescribe.DewaterAmount = dewater_amount
 				newprescribe.TargetUltrafiltration = dewater_amount
 				newprescribe.Status = 1
-
+				newprescribe.Remark = lastDialysisPrescribe.Remark
+				if adminUserInfo.Org.Id == 10340 {
+					newprescribe.TargetUltrafiltration = 0
+				}
 				err := service.AddSigleRecord(&newprescribe)
 				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
 				redis := service.RedisClient()
 				newprescribe.TargetUltrafiltration = dewater_amount
 				newprescribe.Status = 1
 
-				fmt.Println(newprescribe.DewaterAmount)
-				fmt.Println(newprescribe.TargetUltrafiltration)
-
+				if adminUserInfo.Org.Id == 10340 {
+					newprescribe.TargetUltrafiltration = 0
+				}
 				err := service.AddSigleRecord(&newprescribe)
 				key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
 				redis := service.RedisClient()
 			dialysisPrescribe.DewaterAmount = dewater_amount
 			dialysisPrescribe.TargetUltrafiltration = dewater_amount
 			dialysisPrescribe.Status = 1
-
+			if adminUserInfo.Org.Id == 10340 {
+				dialysisPrescribe.TargetUltrafiltration = 0
+			}
 			updateErr := service.UpDateDialysisPrescription(dialysisPrescribe)
 			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(theAssessmentDateTime, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_prescribe"
 			redis := service.RedisClient()

controllers/mobile_api_controllers/dialysis_api_controller.go

 	defer redis.Close()
 
 	key := "scheduals_" + schedualDate + "_" + strconv.FormatInt(orgID, 10)
-	fmt.Println("key22332323232232323", key)
 	scheduals_json_str, _ := redis.Get(key).Result()
-	redis.Set(key, "", time.Second)
+	redis.Set(scheduals_json_str, "", time.Second)
 	patients, _ := service.GetAllPatientListSix(orgID)
 	if len(scheduals_json_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		scheduals, err := service.MobileGetDialysisScheduals(orgID, date.Unix(), schedualType)
 			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
 		} else {
 			if len(scheduals) > 0 {
-
 				devices, _ := service.GetAllDevicetByListSix(orgID)
 				advices, _ := service.GetAllAdvicestByList(orgID, date.Unix())
 				prescriptions, _ := service.GetAllPrescriptionsByList(orgID, date.Unix())
 				assessmentBefores, _ := service.GetAllAssessmentBeforesByList(orgID, date.Unix())
 				dialysisOrders, _ := service.GetAllDialysisOrdersByList(orgID, date.Unix())
-
 				treatmentSummarys, _ := service.GetAllTreatmentSummarysByList(orgID, date.Unix())
 				AssessmentAfterDislysis, _ := service.GetAllAssessmentAfterDislysisByList(orgID, date.Unix())
 				hisAdvices, _ := service.GetAllHisAdvicesByList(orgID, date.Unix())
 			project, _ = service.GetAllHisProjectPrescription(orgID, date.Unix())
 		}
 
-		//获取今日透析准备的数据
-		//goodList, err := service.MobileGetDialysisGoodsSeven(orgID, date.Unix())
-		//fmt.Println("goodlist23323232323233232332233223323233", goodList, err)
-		//
-		//list, err := service.MobileGetDialysisGoodsSix(orgID, date.Unix())
-		//
-		//for _, item := range goodList {
-		//	for _, it := range list {
-		//		if item.RecordDate == it.RecordDate && item.PatientId == it.PatientId {
-		//			item.Children = append(item.Children, it)
-		//		}
-		//	}
-		//}
-		//autoList, _ := service.GetMobileAutoReduce(orgID, date.Unix())
 		this.ServeSuccessJSON(map[string]interface{}{
 			"scheduals": dat,
 			"redis":     "true",
 			"date":      schedualDate,
 			"project":   project,
-			//"goodList":  goodList,
-			//"autoList":  autoList,
 		})
 
 	}
 		his_advices, _ = service.GetAllHisDoctorAdvice(adminInfo.Org.Id, patientID, date.Unix())
 	}
 	fmt.Println("doctorAdvices23344334344433434334343434wode", doctorAdvices)
+
+	lastOrder, _ := service.GetLastDilysisOrder(adminInfo.Org.Id, patientID, date.Unix())
 	returnData := map[string]interface{}{
 		"patient":                        patient,
 		"schedual":                       schedual,
 		"team_projects":                  team_projects,
 		"is_advice_open":                 is_advice_open,
 		"prescription_open":              prescriptionConfig.IsOpen,
+		"lastOrder":                      lastOrder,
 	}
 	this.ServeSuccessJSON(returnData)
 }
 
 	admission_number := c.GetString("admission_number")
 	tumble, _ := c.GetInt64("tumble")
-
+	diacrisis := c.GetString("diacrisis")
+	his_department := c.GetString("his_department")
+	his_bed := c.GetString("his_bed")
 	if id <= 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 		PsychologicalOther:           psychological_other,
 		AdmissionNumber:              admission_number,
 		Tumble:                       tumble,
+		Diacrisis:                    diacrisis,
+		HisBed:                       his_bed,
+		HisDepartment:                his_department,
 	}
 
 	if receiveTreatment.ID == 0 { //新增
 	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.GetString("is_water")
+	var is_war int64
+	if is_water == "是" {
+		is_war = 1
+	}
+	if is_water == "否" {
+		is_war = 2
+	}
+	if is_water == "请选择" {
+		is_war = 0
+	}
+	drhy_water := c.GetString("drhy_water")
+
+	dry_water_hour := c.GetString("dry_water_hour")
+
+	water_machine := c.GetString("water_machine")
 	appRole, _ := service.FindAdminRoleTypeById(adminUserInfo.Org.Id, adminUserInfo.AdminUser.Id, adminUserInfo.App.Id)
 
 	//template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
 		Epo:                        epo,
 		EpoCount:                   epo_count,
 		MaxUltrafiltrationRate:     max_ultrafiltration_rate,
+		AdminUserId:                admin_user_id,
+		IsWater:                    is_war,
+		DrhyWater:                  drhy_water,
+		DryWaterHour:               dry_water_hour,
+		WaterMachine:               water_machine,
 	}
 
 	//查询最近透析准备表里是否存在 透析器 灌流器
 	internal_fistula := c.GetString("blood_access_internal_fistula")
 	catheter := c.GetString("catheter")
 	cruor := c.GetString("cruor")
+	mission := c.GetString("mission")
 	if id <= 0 || nurseID <= 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 		//获取最后一条透析处方数据
 		prescription, _ := service.GetLastDialysisPrescriptionByPatientIdTwo(adminUserInfo.Org.Id, id, recordDate.Unix())
 		evaluation, _ := service.MobileGetPredialysisEvaluationTwo(adminUserInfo.Org.Id, id, recordDate.Unix())
-		tempassessmentAfterDislysis.WeightAfter = evaluation.WeightBefore - prescription.TargetUltrafiltration
+		tempassessmentAfterDislysis.WeightAfter = evaluation.WeightBefore - prescription.TargetUltrafiltration/1000
 	}
 
 	if dialysisOrder.Stage == 1 {
 
 	}
 
-	if adminUserInfo.Org.Id == 10101 || adminUserInfo.Org.Id == 9671 || adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 9675 || adminUserInfo.Org.Id == 10215 || adminUserInfo.Org.Id == 10233 || adminUserInfo.Org.Id == 10223 || adminUserInfo.Org.Id == 10243 || adminUserInfo.Org.Id == 10340 {
+	if adminUserInfo.Org.Id == 10101 || adminUserInfo.Org.Id == 9671 || adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 9675 || adminUserInfo.Org.Id == 10215 || adminUserInfo.Org.Id == 10233 || adminUserInfo.Org.Id == 10223 || adminUserInfo.Org.Id == 10243 || adminUserInfo.Org.Id == 10340 || adminUserInfo.Org.Id == 10414 || adminUserInfo.Org.Id == 10430 {
 		evaluation, _ := service.MobileGetPredialysisEvaluationOne(adminUserInfo.Org.Id, id, recordDate.Unix())
 		if evaluation.SystolicBloodPressure == 0 {
 			evaluation.SystolicBloodPressure = fmonitorRecords.SystolicBloodPressure
 		return
 	}
 	if dialysisOrder.Stage == 1 {
-		err := service.ModifyDialysisRecord(dialysisOrder.ID, nurseID, endDate.Unix(), adminUserInfo.AdminUser.Id, puncture_point_haematoma, internal_fistula, catheter, cruor)
+		err := service.ModifyDialysisRecord(dialysisOrder.ID, nurseID, endDate.Unix(), adminUserInfo.AdminUser.Id, puncture_point_haematoma, internal_fistula, catheter, cruor, mission)
 
 		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(id, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":dialysis_order"
 		redis := service.RedisClient()
 	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")
+	puncture_needle := this.GetString("puncture_needle")
+	puncture_way := this.GetString("puncture_way")
+	dialysis_dialyszers := this.GetString("dialysis_dialyszers")
+	dialysis_irrigation := this.GetString("dialysis_irrigation")
+	blood_access_id, _ := this.GetInt64("blood_access_id")
 	zone_id, _ := this.GetInt64("zone_id")
+	elecsign := this.GetString("url")
+	nuclein_date_str := this.GetString("nuclein_date_str")
 
 	if patientID <= 0 || len(recordDateStr) == 0 || nurseID <= 0 || bedID <= 0 {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 	schedulestartTime := theStartTime.Unix()
 	scheduleendTime := theEndTime.Unix()
 
+	var theNucleinDate int64
+	timeLayoutOne := "2006-01-02"
+	if len(nuclein_date_str) > 0 {
+		theTime, err := time.ParseInLocation(timeLayoutOne+" 15:04:05", nuclein_date_str+" 00:00:00", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+		}
+		theNucleinDate = theTime.Unix()
+	}
+	fmt.Println("wo2o3o23o2o2323oo232o3swo", theNucleinDate)
 	template, _ := service.GetOrgInfoTemplate(adminUserInfo.Org.Id)
 
 	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机
 		DifficultPunctureNurse: difficult_puncture_nurse,
 		NewFistulaNurse:        new_fistula_nurse,
 		ZoneId:                 zone_id,
+		QualityNurseId:         quality_nurse_id,
+		PunctureNeedle:         puncture_needle,
+		PunctureWay:            puncture_way,
+		DialysisIrrigation:     dialysis_irrigation,
+		DialysisDialyszers:     dialysis_dialyszers,
+		BloodAccessId:          blood_access_id,
+		Url:                    elecsign,
+		NucleinDate:            theNucleinDate,
 	}
 	//查询该床位是否有人用了
 	_, errorscode := service.GetDialysisOrderByBedId(adminUserInfo.Org.Id, schedulestartTime, bedID, schedual_type)
 	if errorscode == gorm.ErrRecordNotFound {
+
 		createErr := service.MobileCreateDialysisOrder(adminUserInfo.Org.Id, patientID, dialysisRecord)
 
 		redis := service.RedisClient()
 
 	// 如果当天有插入数据，则不再往透析纪录里插入数据
 	if newdialysisRecord.ID > 0 {
+		if adminUserInfo.Org.Id == 10340 || adminUserInfo.Org.Id == 9671 || adminUserInfo.Org.Id == 9675 {
+			record.Temperature = 36.5
+			record.ArterialPressure = -100
+			record.DialysateTemperature = 36.5
+			record.Conductivity = 14
+			record.BreathingRate = "20"
+			record.VenousPressure = 80
+			record.TransmembranePressure = 60
+		}
 		err := service.CreateMonitor(&record)
 		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(recordDate.Unix(), 10) + ":monitor_records"
 
 	max_ultrafiltration_rate, _ := c.GetFloat("max_ultrafiltration_rate")
 	pre_impulse := c.GetString("pre_impulse")
 	impulse, _ := strconv.ParseFloat(pre_impulse, 64)
+	admin_user_id, _ := c.GetInt64("admin_user_id")
+
+	is_water := c.GetString("is_water")
+	var is_war int64
+	if is_water == "是" {
+		is_war = 1
+	}
+	if is_water == "否" {
+		is_war = 2
+	}
+	if is_water == "请选择" {
+		is_war = 0
+	}
+	drhy_water := c.GetString("drhy_water")
+	dry_water_hour := c.GetString("dry_water_hour")
+	water_machine := c.GetString("water_machine")
 	if mode_id > 0 {
 		service.ModifyScheduleMode(mode_id, patient.ID, recordDate.Unix(), adminUserInfo.Org.Id)
 	}
 		EpoCount:                   epo_count,
 		MaxUltrafiltrationRate:     max_ultrafiltration_rate,
 		PreImpulse:                 impulse,
+		AdminUserId:                admin_user_id,
+		IsWater:                    is_war,
+		DrhyWater:                  drhy_water,
+		DryWaterHour:               dry_water_hour,
+		WaterMachine:               water_machine,
 	}
 
 	_, dialysisPrescription := service.FindDialysisPrescriptionByReordDate(id, recordDate.Unix(), adminUserInfo.Org.Id)
 			if template.TemplateId == 6 && adminInfo.Org.Id != 9538 {
 				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration / float64(totalMin) * 60 * 1000)
 				record.UltrafiltrationRate = ultrafiltration_rate
+
 			}
-			//if template.TemplateId == 6 && adminInfo.Org.Id ==9671{
-			//  dehydration, _ := strconv.ParseFloat(evaluation.Dehydration, 64)
-			//  ultrafiltration_rate = math.Floor((prescription.TargetUltrafiltration + dehydration) / float64(totalMin) * 60 * 1000)
-			//  record.UltrafiltrationRate = ultrafiltration_rate
-			//}
 
 			if template.TemplateId == 32 || template.TemplateId == 34 || template.TemplateId == 36 {
 
 				ultrafiltration_rate = value
 				record.UltrafiltrationRate = ultrafiltration_rate
 			}
-			fmt.Println("hhh23232323223232323323232323", template.TemplateId)
+
 			if template.TemplateId == 41 || template.TemplateId == 47 {
 				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration * 60 / float64(totalMin) * 1000)
-				fmt.Println("prescritpin2332322323232323223", ultrafiltration_rate)
 				record.UltrafiltrationRate = ultrafiltration_rate
 			}
 
 				record.UltrafiltrationRate = ultrafiltration_rate
 			}
 
+			if adminInfo.Org.Id == 10395 || adminInfo.Org.Id == 10138 || adminInfo.Org.Id == 10278 || adminInfo.Org.Id == 10340 {
+				ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration * 60 / 1000 / float64(totalMin) * 1000)
+				fmt.Println("ultrafiltration_rate2332323223322332q", ultrafiltration_rate)
+				record.UltrafiltrationRate = ultrafiltration_rate
+			}
 			//if template.TemplateId == 47 {
 			//	ultrafiltration_rate = math.Floor(prescription.TargetUltrafiltration * 60 / float64(totalMin))
 			//	record.UltrafiltrationRate = ultrafiltration_rate
 		}
 	}
 
+	if adminInfo.Org.Id == 10395 || adminInfo.Org.Id == 10138 || adminInfo.Org.Id == 10278 || adminInfo.Org.Id == 10340 {
+
+		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
 	}
 	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")
 	patient_id, _ := this.GetInt64("patient_id")
 	record_date, _ := this.GetInt64("record_date")
+	puncture_needle := this.GetString("puncture_needle")
+	puncture_way := this.GetString("puncture_way")
+	dialysis_dialyszers := this.GetString("dialysis_dialyszers")
+	dialysis_irrigation := this.GetString("dialysis_irrigation")
+	blood_access_id, _ := this.GetInt64("blood_access_id")
+	nuclein_date_str := this.GetString("nuclein_date_str")
 	if record_id == 0 {
 		this.ErrorLog("id:%v", record_id)
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 	schedulestartTime := theStartTime.Unix()
 	scheduleendTime := theEndTime.Unix()
 
+	var theNucleinDate int64
+	timeLayoutOne := "2006-01-02"
+	if len(nuclein_date_str) > 0 {
+		theTime, err := time.ParseInLocation(timeLayoutOne+" 15:04:05", nuclein_date_str+" 00:00:00", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+		}
+		theNucleinDate = theTime.Unix()
+	}
+
 	//查询更改的机号，是否有人用了,如果只是排班了，但是没上机，直接替换，如果排班且上机了，就提示他无法上机
 
 	schedule, err := service.GetDayScheduleByBedid(adminUserInfo.Org.Id, schedulestartTime, bedID, schedual_type)
 		ChangeNurse:            change_nurse,
 		DifficultPunctureNurse: difficult_puncture_nurse,
 		NewFistulaNurse:        new_fistula_nurse,
+		QualityNurseId:         quality_nurse_id,
+		PunctureNeedle:         puncture_needle,
+		PunctureWay:            puncture_way,
+		DialysisDialyszers:     dialysis_dialyszers,
+		DialysisIrrigation:     dialysis_irrigation,
+		BloodAccessId:          blood_access_id,
+		NucleinDate:            theNucleinDate,
 	}
 
 	updateErr := service.ModifyStartDialysisOrder(dialysisRecord)
 	blood_access_internal_fistula := c.GetString("blood_access_internal_fistula")
 	catheter := c.GetString("catheter")
 	cruor := c.GetString("cruor")
+	mission := c.GetString("mission")
 	if record_id <= 0 || nurseID <= 0 {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 		BloodAccessInternalFistula: blood_access_internal_fistula,
 		Catheter:                   catheter,
 		Cruor:                      cruor,
+		Mission:                    mission,
 	}
 
 	updateErr := service.ModifyFinishDialysisOrder(dialysisRecord)
 	schedual_type, _ := c.GetInt64("schedual_type")
 	adminUserInfo := c.GetMobileAdminUserInfo()
 
-	//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.Org.Id, scheduleTime, schedual_type)
 	list, _ := service.GetAllBedNumberSeven(adminUserInfo.Org.Id)
 
 	var newBeforePrepares []*models.NewDialysisBeforePrepareGoods
 
+	var cancelbefor []*models.DialysisBeforePrepareGoods
+	var outbefor []*models.DialysisBeforePrepareGoods
+
 	//判断是否开启自动出库
 	_, record := service.FindAutomaticReduceRecordByOrgId(adminInfo.Org.Id)
 
 					goodInfo, _ := service.GetLastGoodListByPatientIdOne(record_time, patient_id, item.GoodId, item.GoodTypeId)
 					//判断当前出库数量和最后一次出库数量的大小
 					//如果当前出库数量小于最后一次出库数量 正常出库后 需要退库操作
-
 					if item.Count < goodInfo.Count {
-						//退库
-						err = ConsumablesDeliveryTotalSeven(adminInfo.Org.Id, patient_id, record_time, beforePrepares, adminInfo.AdminUser.Id, item.Count)
-
-						//查询默认仓库
-						storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
-						stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, adminInfo.Org.Id)
-						var total_count int64
-						for _, it := range stockList {
-							total_count += it.StockCount
-						}
-						//基础库插入数据
-						service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, adminInfo.Org.Id)
-						//更新剩余库存
-						goodList, _ := service.GetSumGoodList(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId)
-						var flush_count int64
-						for _, it := range goodList {
-							flush_count += it.StockCount
-						}
-						service.UpdateSumGood(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId, flush_count)
-						break
+						cancelbefor = append(cancelbefor, item)
 					}
 
-					var last_total int64
-
 					//如果当前出库数量大于 最后一次出库数量，那么则需要去查询当前批次耗材的库存是否足够
 					if item.Count > goodInfo.Count {
 
-						//计算当前出库和最后一次出库数据相差数据
-						last_total = item.Count - goodInfo.Count
-
-						//查询该批次剩余库存
-						lastInfo, _ := service.GetLastStockOut(goodInfo.WarehouseInfotId)
-
-						if lastInfo.StockCount == 0 {
-							//查询该耗材的总库存
-							wareinfo, _ := service.GetStockGoodCount(item.GoodId)
-							if wareinfo.StockCount == 0 {
-								goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
-								c.ServeSuccessJSON(map[string]interface{}{
-									"message":            "1",
-									"good_name":          goodObj.GoodName,
-									"specification_name": goodObj.SpecificationName,
-								})
-								return
+						outbefor = append(outbefor, item)
+					}
+
+					//处理编辑耗材新增不了的问题
+					if goodInfo.Count == item.Count {
+						lastCount, _ := service.GetAutoGoodLastCount(item.GoodId, item.Count, record_time, patient_id)
+						service.UpdateLastAutoCount(lastCount.ID, item.Count)
+					}
+
+				}
+
+				fmt.Println("退库长度", len(cancelbefor))
+				fmt.Println("出库长度", len(outbefor))
+				//退库
+				for _, item := range cancelbefor {
+					warehouseOut, _ := service.FindStockOutByIsSys(adminInfo.Org.Id, 1, record_time)
+					creater := adminInfo.AdminUser.Id
+					//退库
+					//err = ConsumablesDeliveryTotalSeven(adminInfo.Org.Id, patient_id, record_time, cancelbefor, adminInfo.AdminUser.Id, item.Count)
+					//查询该患者当天已经出库的耗材信息
+
+					warehouseOutInfos, _ := service.FindStockOutInfoByStockTwo(adminInfo.Org.Id, item.GoodTypeId, item.GoodId, record_time, patient_id)
+
+					var delete_count int64 = 0
+
+					delete_count = warehouseOutInfos.Count - item.Count
+
+					houseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
+
+					// 在出库记录表里记录退库详情
+					warehouseOutInfo := &models.WarehouseOutInfo{
+						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+						WarehouseOutId:          warehouseOut.ID,
+						Status:                  1,
+						Ctime:                   time.Now().Unix(),
+						OrgId:                   adminInfo.Org.Id,
+						Type:                    1,
+						IsSys:                   1,
+						SysRecordTime:           record_time,
+						GoodTypeId:              item.GoodTypeId,
+						GoodId:                  item.GoodId,
+						PatientId:               patient_id,
+						ConsumableType:          2,
+						StorehouseId:            houseConfig.StorehouseOutInfo,
+						IsCheck:                 1,
+					}
+					warehouseOutInfo.Count = item.Count
+
+					stockInInfo, _ := service.FindLastStockInInfoRecord(item.GoodId, adminInfo.Org.Id)
+					warehouseOutInfo.Price = stockInInfo.Price
+					warehouseOutInfo.Dealer = stockInInfo.Dealer
+					warehouseOutInfo.Manufacturer = stockInInfo.Manufacturer
+					warehouseOutInfo.ExpiryDate = stockInInfo.ExpiryDate
+					warehouseOutInfo.ProductDate = stockInInfo.ProductDate
+					warehouseOutInfo.Number = warehouseOutInfos.Number
+					warehouseOutInfo.LicenseNumber = stockInInfo.LicenseNumber
+					warehouseOutInfo.WarehouseInfotId = stockInInfo.ID
+					//查找当天是否存在出库记录
+
+					_, errcod := service.GetWarehouseOutInfoIsExistOne(item.GoodId, patient_id, record_time, 0)
+
+					if errcod == gorm.ErrRecordNotFound {
+						service.AddSigleWarehouseOutInfo(warehouseOutInfo)
+						//插入详情明细表
+						stockFlow := models.VmStockFlow{
+							WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+							WarehouseOutId:          warehouseOut.ID,
+							GoodId:                  item.GoodId,
+							Number:                  warehouseOutInfos.Number,
+							ProductDate:             stockInInfo.ProductDate,
+							ExpireDate:              stockInInfo.ExpiryDate,
+							Count:                   item.Count,
+							Price:                   stockInInfo.Price,
+							Status:                  1,
+							Ctime:                   time.Now().Unix(),
+							UserOrgId:               adminInfo.Org.Id,
+							Manufacturer:            stockInInfo.Manufacturer,
+							Dealer:                  stockInInfo.Dealer,
+							LicenseNumber:           stockInInfo.LicenseNumber,
+							IsEdit:                  2,
+							Creator:                 creater,
+							SystemTime:              record_time,
+							ConsumableType:          3,
+							WarehousingDetailId:     0,
+							IsSys:                   1,
+							UpdateCreator:           creater,
+							PatientId:               patient_id,
+							StorehouseId:            houseConfig.StorehouseOutInfo,
+						}
+						exsit, errflow := service.GetStockFlowIsExsit(warehouseOutInfos.WarehouseInfotId, patient_id, record_time, item.GoodId)
+						if errflow == gorm.ErrRecordNotFound {
+							//创建流水表
+							err := service.CreateStockFlowOne(stockFlow)
+							fmt.Println("err", err)
+						} else if errflow == nil {
+							//插入详情明细表
+							stockFlow := models.VmStockFlow{
+								ID:                      exsit.ID,
+								WarehousingId:           warehouseOutInfos.WarehouseInfotId,
+								WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+								WarehouseOutId:          warehouseOut.ID,
+								GoodId:                  item.GoodId,
+								Number:                  warehouseOutInfos.Number,
+								ProductDate:             stockInInfo.ProductDate,
+								ExpireDate:              stockInInfo.ExpiryDate,
+								Count:                   exsit.Count - delete_count,
+								Price:                   stockInInfo.Price,
+								Status:                  1,
+								Ctime:                   time.Now().Unix(),
+								UserOrgId:               adminInfo.Org.Id,
+								Manufacturer:            stockInInfo.Manufacturer,
+								Dealer:                  stockInInfo.Dealer,
+								LicenseNumber:           stockInInfo.LicenseNumber,
+								IsEdit:                  2,
+								Creator:                 creater,
+								SystemTime:              record_time,
+								ConsumableType:          3,
+								WarehousingDetailId:     0,
+								IsSys:                   1,
+								UpdateCreator:           creater,
+								PatientId:               patient_id,
+								StorehouseId:            houseConfig.StorehouseOutInfo,
 							}
 
+							service.UpdatedStockFlowOne(stockFlow, warehouseOut.ID, patient_id, record_time, item.GoodId)
 						}
 
-						//比较剩余库存 和 当前相差的数量,库存剩余量大于则正常出库
+					} else if errcod == nil {
+						service.UpdatedWarehouseOutInfo(warehouseOutInfo, item.GoodId, patient_id, record_time, 0)
+						//插入详情明细表
+						stockFlow := models.VmStockFlow{
+							WarehousingId:           warehouseOutInfos.WarehouseInfotId,
+							WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+							WarehouseOutId:          warehouseOut.ID,
+							GoodId:                  item.GoodId,
+							Number:                  warehouseOutInfos.Number,
+							ProductDate:             stockInInfo.ProductDate,
+							ExpireDate:              stockInInfo.ExpiryDate,
+							Count:                   item.Count,
+							Price:                   stockInInfo.Price,
+							Status:                  1,
+							Ctime:                   time.Now().Unix(),
+							UserOrgId:               adminInfo.Org.Id,
+							Manufacturer:            stockInInfo.Manufacturer,
+							Dealer:                  stockInInfo.Dealer,
+							LicenseNumber:           stockInInfo.LicenseNumber,
+							IsEdit:                  2,
+							Creator:                 creater,
+							SystemTime:              record_time,
+							ConsumableType:          3,
+							WarehousingDetailId:     0,
+							IsSys:                   1,
+							UpdateCreator:           creater,
+							PatientId:               patient_id,
+							ReturnCount:             delete_count,
+							StorehouseId:            houseConfig.StorehouseOutInfo,
+						}
+						exsit, errflows := service.GetStockFlowIsExsit(warehouseOutInfos.WarehouseInfotId, patient_id, record_time, item.GoodId)
+						if errflows == gorm.ErrRecordNotFound {
+							//创建流水表
+							service.CreateStockFlowOne(stockFlow)
+						} else if errflows == nil {
+							stockFlow := models.VmStockFlow{
+								WarehousingId:           warehouseOutInfos.WarehouseInfotId,
+								ID:                      exsit.ID,
+								WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+								WarehouseOutId:          warehouseOut.ID,
+								GoodId:                  item.GoodId,
+								Number:                  warehouseOutInfos.Number,
+								ProductDate:             stockInInfo.ProductDate,
+								ExpireDate:              stockInInfo.ExpiryDate,
+								Count:                   exsit.Count - delete_count,
+								Price:                   stockInInfo.Price,
+								Status:                  1,
+								Ctime:                   time.Now().Unix(),
+								UserOrgId:               adminInfo.Org.Id,
+								Manufacturer:            stockInInfo.Manufacturer,
+								Dealer:                  stockInInfo.Dealer,
+								LicenseNumber:           stockInInfo.LicenseNumber,
+								IsEdit:                  2,
+								Creator:                 creater,
+								SystemTime:              record_time,
+								ConsumableType:          3,
+								WarehousingDetailId:     0,
+								IsSys:                   1,
+								UpdateCreator:           creater,
+								PatientId:               patient_id,
+								ReturnCount:             delete_count,
+								StorehouseId:            houseConfig.StorehouseOutInfo,
+							}
+							service.UpdatedStockFlowOne(stockFlow, warehouseOut.ID, patient_id, record_time, item.GoodId)
+						}
+
+					}
+
+					//更改自动出库的表格
+					details := models.BloodAutomaticReduceDetail{
+						WarehouseOutId:          warehouseOutInfo.ID,
+						WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
+						PatientId:               patient_id,
+						Ctime:                   time.Now().Unix(),
+						Mtime:                   time.Now().Unix(),
+						Status:                  1,
+						RecordTime:              record_time,
+						OrgId:                   adminInfo.Org.Id,
+						GoodId:                  item.GoodId,
+						GoodTypeId:              item.GoodTypeId,
+						Count:                   item.Count,
+						StorehouseId:            houseConfig.StorehouseOutInfo,
+					}
+					//查询当天耗材是否已经存在数据
+					_, errcode := service.GetAutoMaticReduceDetail(adminInfo.Org.Id, patient_id, record_time, item.GoodId, item.GoodTypeId)
+
+					if errcode == gorm.ErrRecordNotFound {
+						service.CreateAutoReduceRecord(&details)
+
+					} else if errcode == nil {
+						service.DeleteAutoRedeceDetailTwo(adminInfo.Org.Id, patient_id, record_time, item.GoodId, item.GoodTypeId)
+						service.CreateAutoReduceRecord(&details)
+
+					}
+
+					service.ModifyGoodAddInformation(item.GoodId, delete_count, adminInfo.Org.Id)
 
+					//增加出库库存数量
+					service.ModifyReduceGoodSumCount(houseConfig.StorehouseOutInfo, delete_count, adminInfo.Org.Id, item.GoodId)
+
+					errOne := service.UpDateWarehouStockFlowByStockDelete(warehouseOutInfos.WarehouseInfotId, record_time, item.GoodId, delete_count, patient_id)
+					fmt.Println("errOne", errOne)
+					// 删除出库完成后，要增加对应批次的库存数量
+
+					service.UpDateWarehouseInfoByStockDelete(warehouseOutInfos.WarehouseInfotId, delete_count, patient_id, record_time, item.GoodId)
+
+					//查询默认仓库
+					storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
+					stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, adminInfo.Org.Id)
+					var total_count int64
+					for _, it := range stockList {
+						total_count += it.StockCount
+					}
+					//基础库插入数据
+					service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, adminInfo.Org.Id)
+					//更新剩余库存
+					goodList, _ := service.GetSumGoodList(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId)
+					var flush_count int64
+					for _, it := range goodList {
+						flush_count += it.StockCount
+					}
+					service.UpdateSumGood(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId, flush_count)
+				}
+
+				//出库
+				for _, item := range outbefor {
+					fmt.Println("出库ID", item.GoodId)
+					var last_total int64
+					//1.查看该患者该耗材型号最后一次出库数量
+					goodInfoOne, _ := service.GetLastGoodListByPatientIdOne(record_time, patient_id, item.GoodId, item.GoodTypeId)
+					//计算当前出库和最后一次出库数据相差数据
+					last_total = item.Count - goodInfoOne.Count
+
+					//查询该批次剩余库存
+					lastInfo, _ := service.GetLastStockOut(goodInfoOne.WarehouseInfotId)
+
+					if lastInfo.StockCount == 0 {
 						//查询该耗材的总库存
 						wareinfo, _ := service.GetStockGoodCount(item.GoodId)
-						// 如果库存差大于剩余库存则提示库存不足
-						if last_total > wareinfo.StockCount {
+						if wareinfo.StockCount == 0 {
 							goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
 							c.ServeSuccessJSON(map[string]interface{}{
 								"message":            "1",
 								"specification_name": goodObj.SpecificationName,
 							})
 							return
-						} else {
+						}
+
+					}
 
-							//出库
-							err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, beforePrepares, newBeforePrepares, adminInfo.AdminUser.Id)
+					//比较剩余库存 和 当前相差的数量,库存剩余量大于则正常出库
 
-							storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
-							stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, adminInfo.Org.Id)
-							var total_count int64
-							for _, it := range stockList {
-								total_count += it.StockCount
-							}
-							//基础库插入数据
-							service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, adminInfo.Org.Id)
-							//剩余库存
+					//查询该耗材的总库存
+					wareinfo, _ := service.GetStockGoodCount(item.GoodId)
+					// 如果库存差大于剩余库存则提示库存不足
+					if last_total > wareinfo.StockCount {
+						goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
+						c.ServeSuccessJSON(map[string]interface{}{
+							"message":            "1",
+							"good_name":          goodObj.GoodName,
+							"specification_name": goodObj.SpecificationName,
+						})
+						return
+					} else {
 
-							goodList, _ := service.GetSumGoodList(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId)
-							var flush_count int64
-							for _, it := range goodList {
-								flush_count += it.StockCount
+						fmt.Println("出库2o2o2o2o2oo2o2o2o2o2o2o", item.GoodId)
+
+						out, err := service.FindStockOutByIsSys(adminInfo.Org.Id, 1, record_time)
+						houseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
+						if err == gorm.ErrRecordNotFound {
+							//没有记录，则创建出库单
+							timeStr := time.Now().Format("2006-01-02")
+							timeArr := strings.Split(timeStr, "-")
+							total, _ := service.FindAllWarehouseOut(adminInfo.Org.Id)
+							total = total + 1
+							warehousing_out_order := strconv.FormatInt(adminInfo.Org.Id, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
+							number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
+							number = number + total
+							warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
+							warehouseOut := models.WarehouseOut{
+								WarehouseOutOrderNumber: warehousing_out_order,
+								OperationTime:           time.Now().Unix(),
+								OrgId:                   adminInfo.Org.Id,
+								Creater:                 adminInfo.AdminUser.Id,
+								Ctime:                   time.Now().Unix(),
+								Status:                  1,
+								WarehouseOutTime:        record_time,
+								Dealer:                  0,
+								Manufacturer:            0,
+								Type:                    1,
+								IsSys:                   1,
+								StorehouseId:            houseConfig.StorehouseOutInfo,
+								IsCheck:                 1,
 							}
-							service.UpdateSumGood(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId, flush_count)
-							break
+							service.AddSigleWarehouseOut(&warehouseOut)
+
 						}
-					}
+						//出库
+						//err = ConsumablesDeliveryTotalSix(adminInfo.Org.Id, patient_id, record_time, outbefor, newBeforePrepares, adminInfo.AdminUser.Id)
+						//houseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
+						//1.查看该患者该耗材型号最后一次出库数量
+						goodInfoTwo, _ := service.GetLastGoodListByPatientIdOne(record_time, patient_id, item.GoodId, item.GoodTypeId)
+
+						fmt.Println("count2323323222323wi", item.Count)
+						prepare := models.DialysisBeforePrepare{
+							UserOrgId:    adminInfo.Org.Id,
+							PatientId:    patient_id,
+							RecordDate:   record_time,
+							GoodId:       item.GoodId,
+							GoodTypeId:   item.GoodTypeId,
+							Count:        item.Count - goodInfoTwo.Count,
+							Ctime:        time.Now().Unix(),
+							Mtime:        0,
+							Creater:      adminInfo.AdminUser.Id,
+							Modifier:     adminInfo.AdminUser.Id,
+							Status:       1,
+							CommdityCode: "",
+							NewCount:     0,
+							ProjectId:    0,
+							StorehouseId: houseConfig.StorehouseOutInfo,
+						}
+						fmt.Println("prepare", prepare.Count)
+						fmt.Println("count", item.Count)
+						service.ConsumablesGoodDelivery(adminInfo.Org.Id, patient_id, record_time, &prepare, &out, item.Count)
+						//增加出库数量
+						service.ModifyGoodSumCount(houseConfig.StorehouseOutInfo, prepare.Count, adminInfo.Org.Id, item.GoodId)
+
+						storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminInfo.Org.Id)
+						stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, adminInfo.Org.Id)
+						var total_count int64
+						for _, it := range stockList {
+							total_count += it.StockCount
+						}
+						//基础库插入数据
+						service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, adminInfo.Org.Id)
+						//剩余库存
 
+						goodList, _ := service.GetSumGoodList(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId)
+						var flush_count int64
+						for _, it := range goodList {
+							flush_count += it.StockCount
+						}
+						service.UpdateSumGood(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, item.GoodId, flush_count)
+					}
 				}
 
 				//查询今日出库数据
 						flush_count += it.StockCount
 					}
 					service.UpdateSumGood(adminInfo.Org.Id, storeHouseConfig.StorehouseOutInfo, it.GoodId, flush_count)
-					if err != nil {
-						goodObj, _ := service.GetGoodInformationByGoodId(it.GoodId)
-						c.ServeSuccessJSON(map[string]interface{}{
-							"message":            "2",
-							"good_name":          goodObj.GoodName,
-							"specification_name": goodObj.SpecificationName,
-						})
-						return
-					}
+					//if err != nil {
+					//	goodObj, _ := service.GetGoodInformationByGoodId(it.GoodId)
+					//	c.ServeSuccessJSON(map[string]interface{}{
+					//		"message":            "2",
+					//		"good_name":          goodObj.GoodName,
+					//		"specification_name": goodObj.SpecificationName,
+					//	})
+					//	return
+					//}
 				}
 			}
 		}
 
 	project, _ := service.GetHisPrescriptionProject(adminUser.Org.Id, patient_id, date.Unix())
 
+	_, config := service.FindXTHisRecordByOrgId(adminUser.Org.Id)
 	//获取当天该病人的透析处方
 	prescribe, parseDateErr := service.GetDialysisPrescribe(adminUser.Org.Id, patient_id, date.Unix())
 	good_info, _ := service.FindAllGoodInfo(adminUser.Org.Id)
 			"prescribe":        prescribe,
 			"good_info":        good_info,
 			"warehouseOutList": warehouseOutList,
+			"config":           config,
 		})
 		return
 
 				"good_info":        good_info,
 				"project":          project,
 				"warehouseOutList": warehouseOutList,
+				"config":           config,
 			})
 			return
 
 	prescribe, parseDateErr := service.GetDialysisPrescribe(adminUser.Org.Id, patient_id, date.Unix())
 
 	outInfo, _ := service.GetGoodWarehouseOutInfo(adminUser.Org.Id, patient_id, date.Unix())
+
+	_, configs := service.FindXTHisRecordByOrgId(adminUser.Org.Id)
 	c.ServeSuccessJSON(map[string]interface{}{
 		"good_type":      goodTypes,
 		"good_user":      goodUser,
 		"project":        project,
 		"prescription":   prescribe,
 		"outInfo":        outInfo,
+		"configs":        configs,
 	})
 	return
 
 	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
 	// goods 这个数据就是需要出库的耗材的数据(新增的数据)
 
+	fmt.Println("剩余需要出库的", len(goods))
 	if len(goods) > 0 {
 		out, err := service.FindStockOutByIsSys(orgID, 1, record_time)
 		houseConfig, _ := service.GetAllStoreHouseConfig(orgID)
 				StorehouseId: houseConfig.StorehouseOutInfo,
 			}
 
-			fmt.Println("出库数量23333333333333333333333332😯😯😯😯", prepare.Count)
 			service.ConsumablesGoodDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
 
 			//增加出库数量
 		} else {
 			delete_count = ware.Count
 		}
-		// 在出库记录表里记录退库详情
+
 		warehouseOutInfo := &models.WarehouseOutInfo{
 			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 			WarehouseOutId:          warehouseOut.ID,
 
 func ConsumablesDeliveryDeleteNew(orgID int64, record_time int64, good_yc *models.BloodAutomaticReduceDetail, warehouseOut *models.WarehouseOut, patient_id int64, creater int64, count int64) (err error) {
 
+	fmt.Println("退库222322232322332232332322332232332233wo", good_yc.GoodId)
 	// 先根据相关信息查询当天该耗材的出库信息
 	warehouseOutInfos, err := service.FindStockOutInfoByStockTwo(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time, good_yc.PatientId)
 
 	//增加退库数量
 	service.UpdateSumAddCancelCount(orgID, good_yc.GoodId, houseConfig.StorehouseOutInfo, delete_count)
 
-	//扣减出库数量鸡
+	//扣减出库数量
 	service.ModifyAddGoodSumCount(houseConfig.StorehouseOutInfo, delete_count, orgID, good_yc.GoodId)
 	//查询剩余库存
 	goodList, _ := service.GetAllGoodSumCount(good_yc.GoodId, orgID)
 	})
 }
 
+func (this *DialysisAPIController) GetScheduleByPatient() {
+
+	patient_id, _ := this.GetInt64("patient_id")
+	schedule_date, _ := this.GetInt64("schedule_date")
+	orgid := this.GetMobileAdminUserInfo().Org.Id
+	schedule, _ := service.GetScheduleByPatient(patient_id, schedule_date, orgid)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"schedule": schedule,
+	})
+
+}
+
+func (this *DialysisAPIController) GetDialysisRecordOrder() {
+
+	org_id := this.GetMobileAdminUserInfo().Org.Id
+	patient_id, _ := this.GetInt64("patient_id")
+	schedule_date, _ := this.GetInt64("schedule_date")
+	order, _ := service.GetDialysisRecordOrder(org_id, patient_id, schedule_date)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"order": order,
+	})
+}
+
 func (this *DialysisAPIController) CheckSchedule() {
 
 	patientID, _ := this.GetInt64("patient_id")

controllers/mobile_api_controllers/mobile_api_router_register.go

 
 	beego.Router("/m/api/checksch/get", &DialysisAPIController{}, "Get:CheckSchedule")
 
+	beego.Router("/m/api/patient/getschedulebypatient", &DialysisAPIController{}, "Get:GetScheduleByPatient")
+
+	beego.Router("/m/api/getdialysisrecordeorder", &DialysisAPIController{}, "Get:GetDialysisRecordOrder")
 }

controllers/mobile_api_controllers/patient_api_controller.go

 		privateDrugConfig, _ := service.GetDrugSetByUserOrgId(adminUserInfo.Org.Id)
 
 		storeHouseConfig, _ := service.GetAllStoreHouseConfig(adminUserInfo.Org.Id)
+		fmt.Println("drugStockConfig.IsOpen32232323232", drugStockConfig.IsOpen)
 		if drugStockConfig.IsOpen == 1 {
 			if groupno > 0 {
 				advices, _ := service.FindAllDoctorAdviceByGoroupNo(adminUserInfo.Org.Id, groupno)
 				if isHasWay {
 					var total int64
 					var prescribing_number_total int64
+					fmt.Println("advicesssssssssssssssss", len(advices))
 					for _, item := range advices {
 						if item.Way == 1 {
 							houseConfig, _ := service.GetAllStoreHouseConfig(item.UserOrgId)
 								total = list.Count*medical.MinNumber + list.StockMinNumber
 								prescribing_number_total = count
 							}
-
+							fmt.Println("meiddidididssddssddsdsds", medical.IsUse)
 							if medical.IsUse == 1 {
 								c.ServeSuccessJSON(map[string]interface{}{
 									"msg":    "1",
 											stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 											var sum_count int64
 											for _, its := range stockInfo {
-												sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+												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)
 										}
 									}
 								} else {
 										stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 										var sum_count int64
 										for _, its := range stockInfo {
-											sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+											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)
 									}
 								}
 							}
 						}
 					}
+
 				}
-				c.ServeSuccessJSON(map[string]interface{}{
-					"msg":    "1",
-					"advice": advice,
-					"ids":    ids,
-				})
-				return
 			} else {
 
 				advices, _ := service.FindDoctorAdviceByIds(adminUserInfo.Org.Id, ids)
 									stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 									var sum_count int64
 									for _, its := range stockInfo {
-										sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+										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)
-									c.ServeSuccessJSON(map[string]interface{}{
-										"msg":    "1",
-										"advice": advice,
-										"ids":    ids,
-									})
-									return
+									//剩余库存
+									service.UpdateDrugStockCount(item.DrugId, item.UserOrgId, storeHouseConfig.DrugStorehouseOut, sum_count)
 								}
 								if medical.IsUse == 1 {
 									c.ServeSuccessJSON(map[string]interface{}{
 					}
 				}
 			}
+
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":    "1",
+				"advice": advice,
+				"ids":    ids,
+			})
+			return
 		}
 
 		if privateDrugConfig != nil && privateDrugConfig.DrugStart == 1 {
 									stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 									var sum_count int64
 									for _, its := range stockInfo {
-										sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+										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)
 								}
 
 							}
 						}
 					}
+
+					//if config.IsOpen == 1 && item.UserOrgId == 10028 {
+					//
+					//	service.HisDrugsDelivery(adminInfo.Org.Id, creater, &advice)
+					//	//更新字典里面的库存
+					//	stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
+					//	var sum_count int64
+					//	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)
+					//}
+
 				}
 			}
 			for _, item := range advices {
 
 		evaluation.WeightBeforRemake = weight_befor_remake
 	}
+
+	if dataBody["height"] != nil && reflect.TypeOf(dataBody["height"]).String() == "string" {
+		height := dataBody["height"].(string)
+
+		evaluation.Height = height
+	}
+
+	if dataBody["age"] != nil && reflect.TypeOf(dataBody["age"]).String() == "string" {
+		age := dataBody["age"].(string)
+
+		evaluation.Age = age
+	}
+
+	if dataBody["his_department"] != nil && reflect.TypeOf(dataBody["his_department"]).String() == "string" {
+		his_department := dataBody["his_department"].(string)
+
+		evaluation.HisDepartment = his_department
+	}
+
+	if dataBody["his_bed"] != nil && reflect.TypeOf(dataBody["his_bed"]).String() == "string" {
+		his_bed := dataBody["his_bed"].(string)
+
+		evaluation.HisBed = his_bed
+	}
 	return
 }
 
 		if dataBody["drug_name_id"] != nil || reflect.TypeOf(dataBody["drug_name_id"]).String() == "float64" {
 			drug_name_id := int64(dataBody["drug_name_id"].(float64))
 			advice.DrugNameId = drug_name_id
-			fmt.Println("0000000000", advice.DrugNameId)
+
 		}
 	}
 

controllers/new_mobile_api_controllers/new_dialysis_api_controller.go

 	fmt.Print(birth)
 	phone := dataBody["phone"].(string)
 	relative_phone := dataBody["relative_phone"].(string)
-	fmt.Print("电话号码", phone)
+
 	patientType := dataBody["result"].([]interface{})
 	fmt.Print("患者标签", patientType)
 	dialysis := dataBody["dialysis"].(string)
 
 	treatmentmethod := int64(dataBody["treatmentMethod"].(float64))
 
+	remark := dataBody["remark"].(string)
+
+	treatment_plan := dataBody["treatment_plan"].(string)
 	//查询身份证号码是否存在
 	thisPatientOne, _ := service.FindPatientByIdCardNoFive(orgid, idCard)
 	if thisPatientOne.ID > 0 {
 			IsInfectious:      is_infectious,
 			RegistrarsId:      adminInfo.AdminUser.Id,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.CreateOldPatient(&patients)
 		fmt.Print("报错", err)
 			IdCardNo:          idCard,
 			RegistrarsId:      adminInfo.AdminUser.Id,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.CreateNewPatient(&patientsNew)
 		key := strconv.FormatInt(orgid, 10) + ":" + strconv.FormatInt(patient.ID, 10) + ":patient_info"
 			"patient": patientsNew,
 		})
 	}
-
-	fmt.Print("slowpatient", slowpatient)
 	//如果是慢病病人
 	if slowpatient == 1 {
 		_, errcodetwo := service.GetSlowPatientData(phone, orgid)
-		fmt.Print("查询慢慢是吧", errcodetwo)
 		if errcodetwo == gorm.ErrRecordNotFound {
 			patients := models.CdmPatients{
 				Name:        name,
 					IsInfectious:      is_infectious,
 					IdCardNo:          idCard,
 					EquitmentId:       requipmentId,
+					Remark:            "",
+					SchRemark:         remark,
+					TreatmentPlan:     treatment_plan,
 				}
 				err = service.CreateNewPatient(&patientsNew)
 				if err != nil {
 					"patient": patientsNew,
 				})
 			} else if errcodetwo == nil {
-				fmt.Print("病人已存在")
+
 				if memberpatient == 1 {
-					fmt.Print("进来没有", memberpatient)
 					_, errmembercode := service.GetMemberPatientInfo(orgid, phone)
 					if errmembercode == gorm.ErrRecordNotFound {
 						customer := models.SgjUserCustomer{
 								MemberPatienttype: patient_type,
 								MemberTreatement:  treatmentmethod,
 								RelativePhone:     relative_phone,
+								SchRemark:         remark,
+								Remark:            "",
+								TreatmentPlan:     treatment_plan,
 							}
 							err = service.CreateNewPatient(&patientsNew)
 							fmt.Print("报错", err)
 	}
 
 	if memberpatient == 1 {
-		fmt.Print("进来没有", memberpatient)
 		_, errmembercode := service.GetMemberPatientInfo(orgid, phone)
 		if errmembercode == gorm.ErrRecordNotFound {
 			customer := models.SgjUserCustomer{
 					MemberPatienttype: patient_type,
 					MemberTreatement:  treatmentmethod,
 					RelativePhone:     relative_phone,
+					Remark:            "",
+					SchRemark:         remark,
+					TreatmentPlan:     treatment_plan,
 				}
 				err = service.CreateNewPatient(&patientsNew)
 				fmt.Print("报错", err)
 
 	out_reason := dataBody["out_reason"].(string)
 
+	remark := dataBody["remark"].(string)
+
+	treatment_plan := dataBody["treatment_plan"].(string)
 	fmt.Print(fisttime)
 	//如果是血透病人
 	if bloodPatient == 1 {
 			DeathTime:         death_time,
 			OutReason:         out_reason,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.UpdatedPatient(patients, patient.BloodId)
 		key := strconv.FormatInt(orgid, 10) + ":" + strconv.FormatInt(patient.BloodId, 10) + ":patient_info"
 			OutReason:         out_reason,
 			DeathTime:         death_time,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.UpdateXtPatientNew(patientsNew, id)
 		if err != nil {
 			OutReason:         out_reason,
 			DeathTime:         death_time,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.UpdateXtPatientNew(xtPatientsNew, id)
 		fmt.Print("更新失败", err)
 			OutReason:         out_reason,
 			DeathTime:         death_time,
 			RelativePhone:     relative_phone,
+			Remark:            "",
+			SchRemark:         remark,
+			TreatmentPlan:     treatment_plan,
 		}
 		err = service.UpdateXtPatientNewOne(patientsNew, id)
 		if err != nil {

controllers/new_mobile_api_controllers/new_manage_api_controller.go

 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 	}
-	fmt.Println("recordDate2222222", recordDate.Unix())
 	//查询今日所有设备使用登记
 	information, err := service.GetDeviceInfomation(orgid, recordDate.Unix())
 	if err != nil {

controllers/new_mobile_api_controllers/staff_schedule_api_controller.go

 	theEndTime, _ := time.ParseInLocation(timeLayout, weekEndTime, loc)
 	weekStart := theStarTime.Unix()
 	weekEnd := theEndTime.Unix()
-
-	patients, _ := service.GetPatientWithScheduleAndSolution(adminInfo.Org.Id, keywords, weekStart, weekEnd, schedule, contagion)
+	patients, _ := service.GetPatientWithScheduleAndSolutionTwo(adminInfo.Org.Id, keywords, weekStart, weekEnd, schedule, contagion)
 
 	this.ServeSuccessJSON(map[string]interface{}{
 		"patients": patients,
 		"schedule": schedule,
 	})
 }
+
+func (c *StaffScheduleApiController) GetAllBedList() {
+
+	orgId := c.GetMobileAdminUserInfo().Org.Id
+	partition_id, _ := c.GetInt64("partition_id")
+	list, _ := service.GetAllBedNumberTen(orgId, partition_id)
+	c.ServeSuccessJSON(map[string]interface{}{
+		"list": list,
+	})
+}
+
+func (c *StaffScheduleApiController) ChangeScheduleById() {
+
+	id, _ := c.GetInt64("id")
+	mode_id, _ := c.GetInt64("mode_id")
+	schedule_date, _ := c.GetInt64("schedule_date")
+	patient_id, _ := c.GetInt64("patient_id")
+	org_id := c.GetMobileAdminUserInfo().Org.Id
+	err := service.ChangeScheduleById(id, mode_id)
+	fmt.Println("9999999999999999", err)
+	err = service.ChangeDialysisSolution(patient_id, schedule_date, org_id, mode_id)
+	c.ServeSuccessJSON(map[string]interface{}{
+		"msg": "ok",
+	})
+}
+
+func (c *StaffScheduleApiController) ChangeScheduleType() {
+
+	schedule_type, _ := c.GetInt64("schedule_type")
+	schedule_date, _ := c.GetInt64("schedule_date")
+	patient_id, _ := c.GetInt64("patient_id")
+	bed_id, _ := c.GetInt64("bed_id")
+	schedule_week, _ := c.GetInt64("schedule_week")
+	mode_id, _ := c.GetInt64("mode_id")
+	id, _ := c.GetInt64("id")
+	org_id := c.GetMobileAdminUserInfo().Org.Id
+	//查询该班次该床位是否已经存在患者
+	schedule, _ := service.GetScheduleByClassType(schedule_type, schedule_date, bed_id, org_id)
+	//查询该床位所属分区
+	numberlist, _ := service.GetPartionId(bed_id, org_id)
+	//存在
+	if schedule.ID > 0 {
+
+		//调换位置
+		sch := models.Schedule{
+			PatientId: schedule.PatientId,
+			ModeId:    schedule.ModeId,
+		}
+		service.UpdateScheduleById(id, sch)
+
+		schedu := models.Schedule{
+			PatientId: patient_id,
+			ModeId:    mode_id,
+		}
+		service.UpdateScheduleById(schedule.ID, schedu)
+
+	} else {
+		xtSchedule := models.Schedule{
+			UserOrgId:    org_id,
+			PartitionId:  numberlist.ZoneId,
+			BedId:        bed_id,
+			PatientId:    patient_id,
+			ScheduleDate: schedule_date,
+			ScheduleType: schedule_type,
+			ScheduleWeek: schedule_week,
+			ModeId:       mode_id,
+			Status:       1,
+			CreatedTime:  time.Now().Unix(),
+			UpdatedTime:  0,
+			IsExport:     0,
+		}
+		service.CreateSchedule(&xtSchedule)
+	}
+	c.ServeSuccessJSON(map[string]interface{}{
+		"msg": "ok",
+	})
+}
+
+func (c *StaffScheduleApiController) ChangeScheduleBed() {
+
+	fmt.Println("jin23323232233222323323232")
+	schedule_type, _ := c.GetInt64("schedule_type")
+	schedule_date, _ := c.GetInt64("schedule_date")
+	patient_id, _ := c.GetInt64("patient_id")
+	bed_id, _ := c.GetInt64("bed_id")
+	schedule_week, _ := c.GetInt64("schedule_week")
+	mode_id, _ := c.GetInt64("mode_id")
+	id, _ := c.GetInt64("id")
+	org_id := c.GetMobileAdminUserInfo().Org.Id
+
+	//查询该班次该床位是否已经存在患者
+	schedule, _ := service.GetScheduleByClassType(schedule_type, schedule_date, bed_id, org_id)
+	//查询该床位所属分区
+	numberlist, _ := service.GetPartionId(bed_id, org_id)
+	//存在
+	if schedule.ID > 0 {
+
+		//调换位置
+		sch := models.Schedule{
+			PatientId: schedule.PatientId,
+			ModeId:    schedule.ModeId,
+		}
+		service.UpdateScheduleById(id, sch)
+
+		schedu := models.Schedule{
+			PatientId: patient_id,
+			ModeId:    mode_id,
+		}
+		service.UpdateScheduleById(schedule.ID, schedu)
+	} else {
+		xtSchedule := models.Schedule{
+			UserOrgId:    org_id,
+			PartitionId:  numberlist.ZoneId,
+			BedId:        bed_id,
+			PatientId:    patient_id,
+			ScheduleDate: schedule_date,
+			ScheduleType: schedule_type,
+			ScheduleWeek: schedule_week,
+			ModeId:       mode_id,
+			Status:       1,
+			CreatedTime:  time.Now().Unix(),
+			UpdatedTime:  0,
+			IsExport:     0,
+		}
+		service.DeleteSchedule(id)
+		service.CreateSchedule(&xtSchedule)
+	}
+	c.ServeSuccessJSON(map[string]interface{}{
+		"msg": "ok",
+	})
+}

controllers/new_mobile_api_controllers/staff_schedule_api_router.go

 	beego.Router("m/api/schedule/patients", &StaffScheduleApiController{}, "Get:GetSchedulePatient")
 	beego.Router("/m/api/schedule/create", &StaffScheduleApiController{}, "Post:CreateMobileSchedulePatient")
 	beego.Router("m/api/schedule/getsolutionschedule", &StaffScheduleApiController{}, "Get:GetSolutionSchedule")
+
+	beego.Router("m/api/schedule/getallbedlist", &StaffScheduleApiController{}, "Get:GetAllBedList")
+
+	beego.Router("m/api/schedule/changeschedulebyid", &StaffScheduleApiController{}, "Get:ChangeScheduleById")
+
+	beego.Router("m/api/schedule/changescheduletype", &StaffScheduleApiController{}, "Get:ChangeScheduleType")
+
+	beego.Router("m/api/schedule/changeschedulebed", &StaffScheduleApiController{}, "Get:ChangeScheduleBed")
 }

controllers/patient_api_controller.go

 		UserSysBeforeCount:           patient.UserSysBeforeCount,
 		TrobleShoot:                  patient.TrobleShoot,
 		TreatmentPlan:                patient.TreatmentPlan,
+		Doctor:                       patient.Doctor,
 	}
 
 	err = service.CreatePatientsNew(&patientsNew)
 	patient.UpdatedTime = time.Now().Unix()
 	patient.IsInfectious = is_infectious
 	patient.RemindCycle = remind_cycle
-	fmt.Println("hhhhh2h32322323332323232323232322323", patient.RemindCycle)
 	err := service.UpdatePatient(&patient, contagions, diseases)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeUpdatePatient)
 		BloodPatients:             1,
 		Lapseto:                   patient.Lapseto,
 		TrobleShoot:               patient.TrobleShoot,
+		SchRemark:                 patient.SchRemark,
 	}
 	//	//更新病人ID获取新表病人ID
 	err = service.UpdatepatientTwo(&patientsNew, id)
 
 	err = service.EditPatientLapseto(&patient, &lapseto)
 
-	if lapseto.LapsetoType == 3 || lapseto.LapsetoType == 2 {
-		timeStr := time.Now().Format("2006-01-02")
-		timeLayout := "2006-01-02 15:04:05"
-		timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
-		timenow := timeStringToTime.Unix()
-		service.UpdateScheduleByDeathTime(id, timenow)
-		service.UpdateScheduleItemByPatientId(id)
-	}
+	//if lapseto.LapsetoType == 3 || lapseto.LapsetoType == 2 {
+	//	timeStr := time.Now().Format("2006-01-02")
+	//	timeLayout := "2006-01-02 15:04:05"
+	//	timeStringToTime, _ := utils.ParseTimeStringToTime(timeLayout, timeStr+" 00:00:00")
+	//	timenow := timeStringToTime.Unix()
+	//	service.UpdateScheduleByDeathTime(id, timenow)
+	//	service.UpdateScheduleItemByPatientId(id)
+	//}
 
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeEditLapsetoFail)
 					var sum_count int64
 					stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 					for _, its := range stockInfo {
-						sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+						if its.MaxUnit == medical.MaxUnit {
+							its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+						}
+						sum_count += its.StockMaxNumber + its.StockMinNumber
 					}
+
 					service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
 					break
 					c.ServeSuccessJSON(map[string]interface{}{
 								//更新字典里面的库存
 								stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 								for _, its := range stockInfo {
-									sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+									if its.MaxUnit == medical.MaxUnit {
+										its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+									}
+									sum_count += its.StockMaxNumber + its.StockMinNumber
 								}
+
 								service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
 								break
 								c.ServeSuccessJSON(map[string]interface{}{
 							var sum_count int64
 							stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 							for _, its := range stockInfo {
-								sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+								if its.MaxUnit == medical.MaxUnit {
+									its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+								}
+								sum_count += its.StockMaxNumber + its.StockMinNumber
 							}
 							service.UpdateBaseDrugSumTwo(item.DrugId, sum_count, item.UserOrgId)
 							break
 
 						if medical.IsUse == 2 {
 							if config.IsOpen != 1 {
-								fmt.Println("pharmacyConfig23232332322323", pharmacyConfig.IsOpen, medical.IsPharmacy)
 								if pharmacyConfig.IsOpen == 1 && medical.IsPharmacy == 0 {
 									service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
 
 								var sum_count int64
 								stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.DrugId)
 								for _, its := range stockInfo {
-									sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+									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)
 
 		treatment_plan := patientBody["treatment_plan"].(string)
 		patient.TreatmentPlan = treatment_plan
 	}
+
+	if patientBody["doctor"] != nil && reflect.TypeOf(patientBody["doctor"]).String() == "float64" {
+		doctor := int64(patientBody["doctor"].(float64))
+		patient.Doctor = doctor
+	}
 	return
 }
 

controllers/secondary_order_api_contorller.go

 					stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.ProjectId)
 					var sum_count int64
 					for _, its := range stockInfo {
-						sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+						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.ProjectId, sum_count, item.UserOrgId)
 				}
 			var sum_count int64
 			stockInfo, _ := service.GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, item.UserOrgId, item.ProjectId)
 			for _, its := range stockInfo {
-				sum_count += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+				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.ProjectId, sum_count, item.UserOrgId)
 		}

controllers/self_drug_api_congtroller.go

 	beego.Router("/api/stock/tosendgoodinfomation", &SelfDrugApiController{}, "Get:GetSendGoodInformation")
 	//药品脚本
 	beego.Router("/api/drug/getdruginitdatalist", &SelfDrugApiController{}, "Get:GetDrugInitDetailList")
+
+	//新数据
+	beego.Router("/api/stock/getnewpurchasestockquery", &SelfDrugApiController{}, "Get:GetGoodNewPurchaseStockQuery")
+	beego.Router("/api/stock/getpurchasenewdrugquery", &SelfDrugApiController{}, "Get:GetPurchaseNewDrugQuery")
+	beego.Router("/api/stock/getgoodovercount", &SelfDrugApiController{}, "Get:GetGoodOverCount")
+	beego.Router("/api/stock/getdrugovercount", &SelfDrugApiController{}, "Get:GetDrugOverCount")
+
+	beego.Router("/api/stock/getdruginfolist", &SelfDrugApiController{}, "Get:GetDrugInventoryWarehouseInfoList")
 }
 
 func (this *SelfDrugApiController) GetCurrentPatient() {
 				MaxUnit:                 min_unit,
 				MinUnit:                 min_unit,
 				StorehouseId:            storehouse_id,
+				OverCount:               sum_count,
 			}
 			if ord_total != new_total {
 				service.CreateDrugFlowOne(flow)
 	keyword := this.GetString("keyword")
 	page, _ := this.GetInt64("page")
 	limit, _ := this.GetInt64("limit")
-	//start_time := this.GetString("start_time")
-	//end_time := this.GetString("end_time")
-	//timeLayout := "2006-01-02"
-	//loc, _ := time.LoadLocation("Local")
-	//var startTime int64
-	//if len(start_time) > 0 {
-	//	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
-	//	if err != nil {
-	//		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-	//		return
-	//	}
-	//	startTime = theTime.Unix()
-	//}
-	//var endTime int64
-	//if len(end_time) > 0 {
-	//	theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
-	//	if err != nil {
-	//		utils.ErrorLog(err.Error())
-	//		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-	//		return
-	//	}
-	//	endTime = theTime.Unix()
-	//}
 
 	// 查询该机构所有耗材入库信息
 	goodList, _ := service.GetAllGoodListSeven(orgId)
 		service.UpdateGoodInformation(it.ID, orgId, sum_total)
 	}
 
-	//查询删除的耗材数据
-	//listOne, _ := service.GetHisPrescriptionProjectByOrgId(orgId)
-	//for _, item := range listOne {
-	// //查询流水
-	// flowDetail, _ := service.GetPatientStockFlow(item.PatientId, item.RecordDate, item.ProjectId)
-	// formatInt, _ := strconv.ParseInt(item.Count, 10, 64)
-	// vmFlow := models.VmStockFlow{
-	//   Count:  formatInt,
-	// }
-	// service.ModifyPatientStockFlow(flowDetail.ID,vmFlow)
-	//}
-
 	var ids []int64
 	var goodIds []int64
 	manufacturerList, _ := service.GetManufacturerListByKeyword(orgId, keyword)
 	for _, it := range infoList {
 		goodIds = append(goodIds, it.GoodId)
 	}
-	//list, _, err := service.GetGoodNewQuery(orgId, storehouse_id, good_type, keyword, page, limit, ids, goodIds, startTime, endTime)
 
 	stockList, total, err := service.GetGoodStockList(orgId, storehouse_id, good_type, keyword, page, limit, ids)
-	//for _,item :=range list{
-	// //查询入库信息分组
-	//  warehouseInfo, _ := service.FindGoodWarehouseInfoGroup(item.ID, orgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range warehouseInfo {
-	//    item.WarehousingInfo = append(item.WarehousingInfo, it)
-	//  }
-	//  //查询入库信息
-	//  info, _ := service.FindGoodWarehouseInfo(item.ID, orgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range info {
-	//    item.StWarehousingInfo = append(item.StWarehousingInfo, it)
-	//  }
-	//  //出库数据
-	//  outInfo, _ := service.FindGoodWarehouseOutInfo(item.ID, orgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range outInfo {
-	//    item.WarehouseOutInfo = append(item.WarehouseOutInfo, it)
-	//  }
-	//  //出库流水
-	//  outFlow, _ := service.FindGoodStockOutFlow(item.ID, item.OrgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range outFlow {
-	//    item.FlowOutInfo = append(item.FlowOutInfo, it)
-	//  }
-	//  //退库流水
-	//  cancelFlow, _ := service.FindGoodCancelFlow(item.ID, item.OrgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range cancelFlow {
-	//    item.FlowCancelInfo = append(item.FlowCancelInfo, it)
-	//  }
-	//  //退库数据
-	//  cancelInfo, _ := service.FindCancelStockInfo(item.ID, orgId, storehouse_id, startTime, endTime)
-	//  for _,it :=range cancelInfo {
-	//    item.CancelStockInfo = append(item.CancelStockInfo, it)
-	//  }
-	//}
 
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取查询信息失败")
 	}
 
 	this.ServeSuccessJSON(map[string]interface{}{
-		"total": total,
-		//"list":  list,
+		"total":     total,
 		"stockList": stockList,
 	})
 }
 	for _, it := range drug {
 		var sum_count int64
 		var limit_count int64
-
+		fmt.Println("it233323323232323223", it.DrugName)
 		drugInfo, _ := service.GetDrugWarehouseInfoName(it.ID, orgId)
 		for _, item := range drugInfo {
+
 			sum_count += item.StockMaxNumber*it.MinNumber + item.StockMinNumber
 		}
-		limit_count = it.DrugStockLimitCount * it.MinNumber
+		stockInt, _ := strconv.ParseInt(it.DrugStockLimit, 10, 64)
+		limit_count = stockInt * it.MinNumber
 		service.UpdateDrugById(it.ID, orgId, limit_count, sum_count)
 	}
 
 		"msg": "1",
 	})
 }
+
+func (this *SelfDrugApiController) GetGoodNewPurchaseStockQuery() {
+
+	good_type, _ := this.GetInt64("good_type")
+
+	keyword := this.GetString("keyword")
+
+	page, _ := this.GetInt64("page")
+
+	limit, _ := this.GetInt64("limit")
+
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	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()
+	}
+
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	var ids []int64
+	var goodIds []int64
+	infoList, _ := service.GetGoodWarehouseInfoByOrgIdTwo(orgId)
+	for _, it := range infoList {
+		goodIds = append(goodIds, it.GoodId)
+	}
+
+	manufacturers, _ := service.GetManufacturerListByKeyword(orgId, keyword)
+	for _, it := range manufacturers {
+		ids = append(ids, it.ID)
+	}
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	list, total, err := service.GetGoodNewPurchaseStockQuery(good_type, keyword, page, limit, orgId, ids, goodIds)
+
+	for _, item := range list {
+
+		//获取期初结余
+		low, _ := service.GetStartLastFLow(item.ID, orgId, startTime)
+
+		item.GoodStartFlowInfo = low
+
+		//获取期末结余
+		flow, _ := service.GetEndLastFlow(item.ID, orgId, endTime)
+
+		item.GoodEndFlowInfo = flow
+
+		//获取期初结余数量
+		//infoList, _ := service.GetStartGoodWarehouseInfoList(item.ID, orgId, startTime)
+		//for _, it := range infoList {
+		//  item.WarehousingInfoStart = append(item.WarehousingInfoStart, it)
+		//}
+		//
+		////获取期末结余数量
+		//warehouseInfoList, _ := service.GetEndGoodWarehouseInfoList(item.ID, orgId, endTime)
+		//for _, it := range warehouseInfoList {
+		//  item.WarehousingInfoEnd = append(item.WarehousingInfoEnd, it)
+		//}
+
+		//获取期间增加
+		goodWarehouseInfoList, _ := service.GetAddGoodWarehouseInfoList(item.ID, orgId, startTime, endTime)
+		for _, it := range goodWarehouseInfoList {
+			item.WarehousingInfoOne = append(item.WarehousingInfoOne, it)
+		}
+
+		//获取本期增加
+		WarehouseInfoFlowList, _ := service.GetAddStartFlow(item.ID, orgId, startTime, endTime)
+		for _, it := range WarehouseInfoFlowList {
+			item.StartFlowWarehouseInfo = append(item.StartFlowWarehouseInfo, it)
+		}
+		//获取本期减少
+		reduceWarehouseInfoList, _ := service.GetReduceWarehouseInfoList(item.ID, orgId, startTime, endTime)
+		for _, it := range reduceWarehouseInfoList {
+			item.WarehouseOutInfoStart = append(item.WarehouseOutInfoStart, it)
+		}
+
+		//获取期中减少退库
+		lowInfo, _ := service.GetStartEndCancelFLowInfo(item.ID, orgId, startTime, endTime)
+		for _, it := range lowInfo {
+			item.StartEndCancelFLowInfo = append(item.StartEndCancelFLowInfo, it)
+		}
+		//
+		outInfo, _ := service.FindeWarehouseOutInfo(item.ID, orgId, startTime)
+		for _, it := range outInfo {
+			item.WarehouseOutInfoEnd = append(item.WarehouseOutInfoEnd, it)
+		}
+
+		////获取期初结余
+		//info, _ := service.FindeStartFlowInfo(item.ID, orgId, startTime)
+		//for _, it := range info {
+		//  item.StartFlowInfo = append(item.StartFlowInfo, it)
+		//}
+		////获取期初结余
+		//flowOutInfo, _ := service.FindeStartFlowOutInfo(item.ID, orgId, startTime)
+		//for _, it := range flowOutInfo {
+		//  item.StartOutFlowInfo = append(item.StartOutFlowInfo, it)
+		//}
+		//
+		////获取期初退库
+		//cancelInfo, _ := service.FindeStartCancelInfo(item.ID, orgId, startTime)
+		//for _, it := range cancelInfo {
+		//  item.StartCancelFlowInfo = append(item.StartCancelFlowInfo, it)
+		//}
+
+		////获取期末结余
+		//flowInfo, _ := service.FindEndStartFlowInfo(item.ID, orgId, endTime)
+		//for _, it := range flowInfo {
+		//  item.EndFlowInfo = append(item.EndFlowInfo, it)
+		//}
+		//
+		////获取期末出库
+		//lowOutInfo, _ := service.FindeEndFLowOutInfo(item.ID, orgId, endTime)
+		//for _, it := range lowOutInfo {
+		//  item.EndFlowOutInfo = append(item.EndFlowOutInfo, it)
+		//}
+		//
+		////获取期末退库
+		//endCancelInfo, _ := service.FindEndCancelInfo(item.ID, orgId, endTime)
+		//for _, it := range endCancelInfo {
+		//  item.EndCancelFLowInfo = append(item.EndCancelFLowInfo, it)
+		//}
+
+		////期初盘赢
+		//inventory, _ := service.FindeStartStockInventoryProfit(item.ID, orgId, startTime)
+		//for _, it := range inventory {
+		//  item.WareStartStockInventoryProfit = append(item.WareStartStockInventoryProfit, it)
+		//}
+		////期初盘亏
+		//stockInventory, _ := service.FindStartStockInventoryLosses(item.ID, orgId, startTime)
+		//for _, it := range stockInventory {
+		//  item.WareStartStockInventoryLosses = append(item.WareStartStockInventoryLosses, it)
+		//}
+
+		////期末盘盈
+		//inventoryProfit, _ := service.FindeStartStockInventoryProfit(item.ID, orgId, endTime)
+		//for _, it := range inventoryProfit {
+		//  item.WareEndStockInventoryProfit = append(item.WareEndStockInventoryProfit, it)
+		//}
+		////期末盘亏
+		//inventoryLosses, _ := service.FindStartStockInventoryLosses(item.ID, orgId, endTime)
+		//for _, it := range inventoryLosses {
+		//  item.WareEndStockInventoryLosses = append(item.WareEndStockInventoryLosses, it)
+		//}
+
+		//期中盘盈
+		profit, _ := service.FindeEndStokInventoryProfit(item.ID, orgId, startTime, endTime)
+		for _, it := range profit {
+			item.WareStartEndStockInventoryProfit = append(item.WareStartEndStockInventoryProfit, it)
+		}
+		//期中盘亏
+		losses, _ := service.FindeEndStockInventoryLosses(item.ID, orgId, startTime, endTime)
+		for _, it := range losses {
+			item.WareStartEndStockInventoryLosses = append(item.WareStartEndStockInventoryLosses, it)
+		}
+	}
+
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取患者信息失败")
+		return
+	}
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"manufacturerList": manufacturerList,
+		"total":            total,
+	})
+}
+
+func (this *SelfDrugApiController) GetPurchaseNewDrugQuery() {
+
+	good_type, _ := this.GetInt64("good_type")
+
+	keyword := this.GetString("keyword")
+
+	page, _ := this.GetInt64("page")
+
+	limit, _ := this.GetInt64("limit")
+
+	start_time := this.GetString("start_time")
+	end_time := this.GetString("end_time")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	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()
+	}
+
+	var endTime int64
+	if len(end_time) > 0 {
+		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", end_time+" 23:59:59", loc)
+		if err != nil {
+			utils.ErrorLog(err.Error())
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+			return
+		}
+		endTime = theTime.Unix()
+	}
+	var ids []int64
+	var infoIds []int64
+
+	manufacturers, _ := service.GetManufacturerListByKeyword(orgId, keyword)
+	for _, it := range manufacturers {
+		ids = append(ids, it.ID)
+	}
+	infoList, _ := service.GetDrugWarehouseInfoByOrgIdTwo(orgId)
+	for _, it := range infoList {
+		infoIds = append(infoIds, it.DrugId)
+	}
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	list, total, err := service.GetDrugNewPurchaseStockQuery(good_type, keyword, page, limit, orgId, startTime, endTime, ids, infoIds)
+
+	for _, item := range list {
+
+		//获取期初结余
+		flow, _ := service.GetDrugStartFlow(item.ID, orgId, startTime)
+
+		item.DrugStatFlow = flow
+
+		//获取期末结余
+		endFlow, _ := service.GetDrugEndFlow(item.ID, orgId, endTime)
+
+		item.DrugEndFlow = endFlow
+		//获取期初结余入库数量
+		//startDrugInfo, _ := service.GetDrugWarehouseInfoStart(item.ID, orgId, startTime)
+		//for _, it := range startDrugInfo {
+		//  item.DrugWarehouseInfoStart = append(item.DrugWarehouseInfoStart, it)
+		//}
+		//
+		////获取期初结余出库数量
+		//flowOutList, _ := service.GetDrugFlowOut(item.ID, orgId, startTime)
+		//for _, it := range flowOutList {
+		//  item.DrugWarehouseOutInfoStart = append(item.DrugWarehouseOutInfoStart, it)
+		//}
+		//
+		////获取期初结余退库数量
+		//cancelInfo, _ := service.GetStartDrugFlowCancelInfo(item.ID, orgId, startTime)
+		//for _, it := range cancelInfo {
+		//  item.WareStartStockCancelInfo = append(item.WareStartStockCancelInfo, it)
+		//}
+		//
+		////获取期末结余入库数量
+		//drugwarehouseinfoend, _ := service.DrugWarehouseInfoEnd(item.ID, orgId, endTime)
+		//for _, it := range drugwarehouseinfoend {
+		//  item.DrugWarehouseInfoEnd = append(item.DrugWarehouseInfoEnd, it)
+		//}
+
+		////获取期末出库结余
+		//endDrugInfo, _ := service.DrugWarehouseOutInfoEnd(item.ID, orgId, endTime)
+		//for _, it := range endDrugInfo {
+		//  item.DrugWarehouseOutInfoEnd = append(item.DrugWarehouseOutInfoEnd, it)
+		//}
+		//
+		////获取期末退库数量
+		//flowCancelInfo, _ := service.GetEndDrugFlowCancelInfo(item.ID, orgId, endTime)
+		//for _, it := range flowCancelInfo {
+		//  item.WareEndStockCancelInfo = append(item.WareEndStockCancelInfo, it)
+		//}
+
+		//期中增加
+		drugWarehouse, _ := service.GetDrugWarehouseStartEnd(item.ID, orgId, startTime, endTime)
+		for _, it := range drugWarehouse {
+			item.DrugWarehouseInfoStartEnd = append(item.DrugWarehouseInfoStartEnd, it)
+		}
+
+		//期中减少
+		outInfo, _ := service.FindeDrugWarehouseOutInfo(item.ID, item.OrgId, startTime, endTime)
+		for _, it := range outInfo {
+			item.DrugWarehouseOutInfoStartEnd = append(item.DrugWarehouseOutInfoStartEnd, it)
+		}
+
+		//期中退库
+		cancelstartInfo, _ := service.FindStartEndDrugWarehouseOutInfo(item.ID, item.OrgId, startTime, endTime)
+		for _, it := range cancelstartInfo {
+			item.WareStartEndStockCancelInfo = append(item.WareStartEndStockCancelInfo, it)
+		}
+
+		////获取期初盘盈
+		//startProfit, _ := service.GetDrugFlowStartProfit(item.ID, orgId, startTime)
+		//for _, it := range startProfit {
+		//  item.WareStartStockInventoryProfit = append(item.WareStartStockInventoryProfit, it)
+		//}
+		////获取期初盘亏
+		//startLosses, _ := service.GetDrugFlowStartLosses(item.ID, orgId, startTime)
+		//for _, it := range startLosses {
+		//  item.WareStartStockInventoryLosses = append(item.WareStartStockInventoryLosses, it)
+		//}
+		////获取期末盘盈
+		//endProfit, _ := service.GetDrugFlowEndProfit(item.ID, orgId, endTime)
+		//for _, it := range endProfit {
+		//  item.WareEndStockInventoryProfit = append(item.WareEndStockInventoryProfit, it)
+		//}
+		////获取期末盘亏
+		//losses, _ := service.GetDrugFlowEndLosses(item.ID, orgId, endTime)
+		//for _, it := range losses {
+		//  item.WareEndStockInventoryLosses = append(item.WareEndStockInventoryLosses, it)
+		//}
+
+		//获取期中盘盈
+		profit, _ := service.GetDrugFlowStartEndProfit(item.ID, orgId, startTime, endTime)
+		for _, it := range profit {
+			item.WareStartEndStockInventoryProfit = append(item.WareStartEndStockInventoryProfit, it)
+		}
+
+		//获取期中盘亏
+		endLosses, _ := service.GetDrugFlowStartEndLosses(item.ID, orgId, startTime, endTime)
+		for _, it := range endLosses {
+			item.WareStartEndStockInventoryLosses = append(item.WareStartEndStockInventoryLosses, it)
+		}
+	}
+	if err != nil {
+		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取患者信息失败")
+		return
+	}
+	var drugType = "药品类型"
+	drugTypeParent, _ := service.GetDrugDataConfig(0, drugType)
+	drugTypeList, _ := service.GetParentDataConfig(drugTypeParent.ID, orgId)
+
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"manufacturerList": manufacturerList,
+		"total":            total,
+		"drugTypeList":     drugTypeList,
+	})
+}
+
+func (this *SelfDrugApiController) GetGoodOverCount() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+
+	list, _ := service.GetAllStockCount(orgId)
+	for _, item := range list {
+		flow, _ := service.GetLastStockFlow(item.GoodId)
+		service.ModifyStockFlowById(flow.ID, item.FlushCount)
+	}
+	returnData := make(map[string]interface{}, 0)
+	returnData["msg"] = "ok"
+	this.ServeSuccessJSON(returnData)
+	return
+}
+
+func (this *SelfDrugApiController) GetDrugOverCount() {
+
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	list, _ := service.GetAllDrugCount(orgId)
+	for _, item := range list {
+		service.GetLastDrugFlow(item.DrugId)
+		service.ModifyDrugFlowById(item.ID, item.FlushCount)
+	}
+	returnData := make(map[string]interface{}, 0)
+	returnData["msg"] = "ok"
+	this.ServeSuccessJSON(returnData)
+	return
+}
+
+func (this *SelfDrugApiController) GetDrugInventoryWarehouseInfoList() {
+
+	storehouse_id, _ := this.GetInt64("storehouse_id")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	list, _ := service.GetDrugInventoryWarehouseInfoList(orgId, storehouse_id)
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	dealerList, _ := service.GetAllDealerList(orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"manufacturerList": manufacturerList,
+		"dealerList":       dealerList,
+	})
+}

controllers/stock_in_api_controller.go

 	beego.Router("/api/stock/checkreturnstockwarehouseinfo", &StockManagerApiController{}, "Get:CheckReturnStockWarehouseInfo")
 	beego.Router("/api/stock/getprintlist", &StockManagerApiController{}, "Get:GetPrintList")
 
+	beego.Router("/api/stock/getwarehouseinfolist", &StockManagerApiController{}, "Get:GetInvetoryWarehouseInfoList")
+
 	//结算成功后调用操作库存相关接口
 	beego.Router("/api/settle/stock", &StockManagerApiController{}, "Get:HandleSettleStock")
 	beego.Router("/api/settle/cancelstock", &StockManagerApiController{}, "Get:HandleRefundStock")
 			}
 		}
 	}
-
 	warehouseList, total, err := service.FindAllWarehousingList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids, storehouse_id, check_type)
 	houselist, _ := service.GetAllStoreHouseList(adminUserInfo.CurrentOrgId)
 	if err == nil {
 
 				stock_count := items["stock_count"].(string)
 
+				register_number := items["register_number"].(string)
+
 				timeLayout := "2006-01-02"
 				loc, _ := time.LoadLocation("Local")
 				var expiryDate int64
 					BuyPrice:                buy_price,
 					StockCount:              stock_count,
 					IsCheck:                 2,
+					RegisterNumber:          register_number,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 			StockCount:              it.StockCount,
 			Count:                   it.Count,
 			IsCheck:                 2,
+			RegisterNumber:          it.RegisterNumber,
 		}
 		if it.ID == 0 {
 			service.AddSigleWarehouseOutInfo(warehouseOutInfo)
 
 				stock_count := items["stock_count"].(string)
 
+				register_number := items["register_number"].(string)
+
 				var productDate int64
 				if len(product_date) > 0 {
 					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", product_date+" 00:00:00", loc)
 						StorehouseId:            storehouse_id,
 						AdminUserId:             admin_user_id,
 						StockCount:              stock_count,
+						RegisterNumber:          register_number,
 					}
 					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 						StorehouseId:            storehouse_id,
 						AdminUserId:             admin_user_id,
 						StockCount:              stock_count,
+						RegisterNumber:          register_number,
 					}
 					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
 				}
 }
 func (this *StockManagerApiController) DeleteCancelStockInfo() {
 	id, _ := this.GetInt64("id", 0)
-	fmt.Println(id)
+	//fmt.Println(id)
 	if id == 0 {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return
 func (this *StockManagerApiController) GetOrderDetialByOrderId() {
 
 	ids := this.GetString("id")
+
 	idsArray := strings.Split(ids, ",")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
 	order, _ := service.GetWarehouseOutOrder(idsArray, orgId)
 		err := service.ConsumablesDeliveryThirty(orgId, item.SysRecordTime, item, &warehouseOut, item.Count, creater)
 		if err != nil {
 			goodErrcode := models.XtGoodErrcode{
-				UserOrgId:      item.OrgId,
+				UserOrgId:      orgId,
 				Errcode:        "调用出库接口报错",
 				GoodId:         item.GoodId,
 				Status:         1,
 		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
 		if errs != nil {
 			goodErrcode := models.XtGoodErrcode{
-				UserOrgId:      item.OrgId,
+				UserOrgId:      orgId,
 				Errcode:        "手动出库更新剩余出库失败",
 				GoodId:         item.GoodId,
 				Status:         1,
 		errsum := service.UpdateGoodInfoReduceSumCount(item.GoodId, total_count, orgId)
 		if errsum != nil {
 			goodErrcode := models.XtGoodErrcode{
-				UserOrgId:      item.OrgId,
+				UserOrgId:      orgId,
 				Errcode:        "基础库扣减库存报错",
 				GoodId:         item.GoodId,
 				Status:         1,
 
 	warehousing_info_id, _ := this.GetInt64("warehousing_info_id")
 	orgId := this.GetAdminUserInfo().CurrentOrgId
+	Creator := this.GetAdminUserInfo().AdminUser.Id
 	//查询默认仓库
 	storeHouseConfig, _ := service.GetAllStoreHouseConfig(orgId)
 	//更改审核状态
 	err := service.UpdateCheckWarehouseInfo(warehousing_info_id)
 	if err == nil {
 		list, _ := service.GetWarehouseInfoList(warehousing_info_id, orgId)
-		Creator := this.GetAdminUserInfo().AdminUser.Id
+
 		for _, item := range list {
 			service.UpdateWarehouseInfoByIdList(item.WarehousingCount, item.ID)
+
+			//查询该耗材剩余库存库
+			stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
+			var total_count int64
+			var sum_in_count int64
+			for _, it := range stockList {
+				total_count += it.StockCount
+				sum_in_count += it.WarehousingCount
+			}
+			//基础库插入数据
+			service.UpdateGoodInfoAddSumCount(item.GoodId, total_count, orgId, sum_in_count)
+
+			//查询该仓库是否有数据
+			_, errcode := service.GetGoodStockCount(orgId, item.StorehouseId, item.GoodId)
+			goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+			var flush_count int64
+			for _, it := range goodList {
+				flush_count += it.StockCount
+			}
 			stockFlow := models.VmStockFlow{
 				WarehousingId:           item.WarehousingId,
 				GoodId:                  item.GoodId,
 				StockCount:              "",
 				BatchNumberCount:        item.WarehousingCount,
 				IsCheck:                 1,
+				OverCount:               flush_count,
 			}
 			//创建出库流水
 			service.CreateStockFlowOne(stockFlow)
 
-			orgId := this.GetAdminUserInfo().CurrentOrgId
-			//查询该耗材剩余库存库
-			stockList, _ := service.GetStockCountByGoodId(item.GoodId, storeHouseConfig.StorehouseOutInfo, orgId)
-			var total_count int64
-			var sum_in_count int64
-			for _, it := range stockList {
-				total_count += it.StockCount
-				sum_in_count += it.WarehousingCount
-			}
-			//基础库插入数据
-			service.UpdateGoodInfoAddSumCount(item.GoodId, total_count, orgId, sum_in_count)
-
-			//查询该仓库是否有数据
-			_, errcode := service.GetGoodStockCount(orgId, item.StorehouseId, item.GoodId)
-			goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
-			var flush_count int64
-			for _, it := range goodList {
-				flush_count += it.StockCount
-			}
 			if errcode == gorm.ErrRecordNotFound {
 
 				goodCount := models.XtGoodStockCount{
 	var out_total_count int64
 	var dealer_id int64
 	for _, item := range list {
-		for _, items := range manufacturerlist {
-			if item.Manufacturer == items.ManufacturerName {
-				manufacturer_id = items.ID
-			}
-		}
-		for _, it := range dealerList {
-			if item.Dealer == it.DealerName {
-				dealer_id = it.ID
-			}
-		}
+
 		//查询该药品该批次的出库数量是否满足退库需求
 		outList, _ := service.GetWarehouseOutList(item.OrgId, item.GoodId, item.WarehouseInfoId)
 		for _, it := range outList {
 			})
 			return
 		}
+	}
+
+	cancelStock := models.CancelStock{
+		IsCheck: 1,
+	}
+	service.CheckCancelStock(cancelStock, cancel_stock_id, orgId)
+
+	//回退库存
+	cancellist, _ := service.GetCancelStockInfoById(cancel_stock_id, orgId)
+	for _, item := range cancellist {
+		for _, items := range manufacturerlist {
+			if item.Manufacturer == items.ManufacturerName {
+				manufacturer_id = items.ID
+			}
+		}
+		for _, it := range dealerList {
+			if item.Dealer == it.DealerName {
+				dealer_id = it.ID
+			}
+		}
+		//回退库存
+		service.UpdateCancelStockNumber(item.Count, item.WarehouseInfoId, orgId)
+		//更新基础库库存
+		service.UpdateGoodSumCount(item.Count, item.GoodId, orgId)
+		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
+		//退库数量增加
+		service.UpdateSumAddCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)
+		var flush_count int64
+		for _, it := range goodList {
+			flush_count += it.StockCount
+		}
 
 		stockFlow := models.VmStockFlow{
 			ID:                        0,
 			AdminUserId:               0,
 			BuyPrice:                  item.Price,
 			StockCount:                "",
+			OverCount:                 flush_count,
 		}
+		//创建流水
 		service.CreateStockFlowOne(stockFlow)
-		service.ModifyAddCancelCount(item.Count, item.GoodId)
-	}
-
-	cancelStock := models.CancelStock{
-		IsCheck: 1,
-	}
-	service.CheckCancelStock(cancelStock, cancel_stock_id, orgId)
-
-	//回退库存
-	cancellist, _ := service.GetCancelStockInfoById(cancel_stock_id, orgId)
-	for _, item := range cancellist {
-		service.UpdateCancelStockNumber(item.Count, item.WarehouseInfoId, orgId)
-
-		service.UpdateGoodSumCount(item.Count, item.GoodId, orgId)
-		goodList, _ := service.GetSumGoodList(orgId, item.StorehouseId, item.GoodId)
-
-		service.UpdateSumAddCancelCount(orgId, item.GoodId, item.StorehouseId, item.Count)
-		var flush_count int64
-		for _, it := range goodList {
-			flush_count += it.StockCount
-		}
+		//更新剩余库存
 		errs := service.UpdateSumGood(orgId, item.StorehouseId, item.GoodId, flush_count)
 
 		//出库数量减少
 		"houseList": houseList,
 	})
 }
+
+func (this *StockManagerApiController) GetInvetoryWarehouseInfoList() {
+
+	storehouse_id, _ := this.GetInt64("storehouse_id")
+	orgId := this.GetAdminUserInfo().CurrentOrgId
+	list, _ := service.GetInvetoryWarehouseInfoList(orgId, storehouse_id)
+	manufacturerList, _ := service.GetAllManufacturerList(orgId)
+	dealerList, _ := service.GetAllDealerList(orgId)
+	this.ServeSuccessJSON(map[string]interface{}{
+		"list":             list,
+		"manufacturerList": manufacturerList,
+		"dealerList":       dealerList,
+	})
+}

controllers/supply_order_api_contorller.go

 			sum_in_count += item.WarehousingCount
 		}
 		service.UpdateGoodByGoodId(item.GoodId, sum_count, sum_in_count, item.OrgId)
-		//增加入库数量
-		service.AddGoodSumInCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, item.WarehousingCount)
+		fmt.Println("入库数量23333333333333333333333wo", item.WarehousingCount)
+		//查询是否有该耗材
+		goodStock, _ := service.GetGoodSumCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId)
+		if goodStock.ID > 0 {
+			//增加入库数量
+			service.AddGoodSumInCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, item.WarehousingCount)
+		}
+		if goodStock.ID == 0 {
+			stock := models.XtGoodStockCount{
+				UserOrgId:        item.OrgId,
+				GoodId:           item.GoodId,
+				StorehouseId:     storeConfig.StorehouseOutInfo,
+				Status:           1,
+				Ctime:            time.Now().Unix(),
+				Mtime:            0,
+				StockInCount:     item.WarehousingCount,
+				StockOutCount:    0,
+				StockCancelCount: 0,
+				FlushCount:       sum_count,
+				StockActOutCount: 0,
+			}
+			service.CreateGoodStockCount(stock)
+		}
 
 		//更新剩余库存
 		service.UpdateGoodFlushCount(storeConfig.StorehouseOutInfo, item.GoodId, item.OrgId, sum_count)
 		list, _ := service.GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId)
 		var sum_count int64
 		var sum_in_count int64
+		var sum_waresing_count int64
+		baseDrug, _ := service.GetBaseDrugMedical(items.DrugId)
 		for _, it := range list {
-			baseDrug, _ := service.GetBaseDrugMedical(it.DrugId)
 			if it.MaxUnit == baseDrug.MaxUnit {
 				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
 				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
 			sum_count += it.StockMaxNumber + it.StockMinNumber
 			sum_in_count += it.WarehousingCount
 		}
+		if items.MaxUnit == baseDrug.MaxUnit {
+			sum_waresing_count = items.WarehousingCount * baseDrug.MinNumber
+		}
+		if items.MaxUnit == baseDrug.MinUnit {
+			sum_waresing_count = items.WarehousingCount
+		}
+
 		service.UpdateMedicalSumCount(items.DrugId, sum_count, sum_in_count, items.OrgId)
 
-		//更新入库数量和剩余库存
-		service.UpdateDrugCount(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId, sum_in_count, sum_count)
+		//查询是否有
+		drugStock, _ := service.GetDrugStockCountSix(houseConfig.DrugStorehouseOut, items.DrugId, items.OrgId)
+		fmt.Println("drugStockwoowowowowoowowowo", drugStock.ID)
+		if drugStock.ID == 0 {
+			drug := models.XtDrugStockCount{
+				UserOrgId:      items.OrgId,
+				StorehouseId:   houseConfig.DrugStorehouseOut,
+				SumInCount:     sum_waresing_count,
+				SumOutCount:    0,
+				SumCancelCount: 0,
+				DrugId:         items.DrugId,
+				Ctime:          time.Now().Unix(),
+				Mtime:          0,
+				Status:         1,
+				FlushCount:     sum_count,
+				SumActOutCount: 0,
+			}
+			service.CreateDrugStock(drug)
+		}
+		if drugStock.ID > 0 {
+			//更新入库数量和剩余库存
+			service.UpdateDrugCount(houseConfig.DrugStorehouseOut, items.OrgId, items.DrugId, sum_in_count, sum_count)
+		}
+
 	}
 	fmt.Println(errs)
 	for _, items := range drugFlow {
 
 				//更改库存
 				err := service.UpdateWarehousingInfoById(item.ProjectId, item.SupplyWarehouseDetailInfo, info)
-
+				fmt.Println("更改库存3232323223322332")
 				service.ModifyGoodAddInformation(item.ProjectId, item.SupplyCount, item.UserOrgId)
 
 				//扣减出库数量

enums/error_code.go

 	ErrorCodeHisPatientNoRegException = 4000000
 
 	ErrorCodeCantDeleteScheduleBeforeNow = 40000001
+
+	ErrorCodeSchedule = 50000000
 )
 
 var ErrCodeMsgs = map[int]string{
 	ErrorCodeCantSetScheduleAgainOneDay:     "同一天不可有两次排班",
 	ErrorCodeCantSetScheduleBeforeNow:       "不能给今天之前的日期排班",
 	ErrorCodeCantDeleteScheduleBeforeNow:    "不能删除今天之前的日期排班",
-	ErrorCodeScheduleNotExist:               "排班不存go在",
+	ErrorCodeScheduleNotExist:               "排班不存在",
 	ErrorCodePointScheduleExist:             "所先位置排班已经存在",
 	ErrorCodeDeleteScheduleFail:             "取消排班失败",
 	ErrorCodeChangeScheduleFail:             "修改排班失败",
 	ErrorCodeDeletePChargeWrongTwo: "该医嘱所属处方已经收费或已经上传的处方,无法删除",
 
 	ErrorCodeHisPatientNoRegException: "该患者尚未挂号，请先挂号",
+	ErrorCodeSchedule:                 "该班次该床位已有患者",
 }
 
 type SGJError struct {

models/device_models.go

 	Number     string     `gorm:"column:number" json:"number"`
 	GroupID    int64      `gorm:"column:group_id" json:"group_id"`
 	ZoneID     int64      `gorm:"column:zone_id" json:"zone_id"`
-	Status     int8       `json:"-"`
+	Status     int64      `gorm:"column:status" json:"status" form:"status"`
 	CreateTime int64      `gorm:"column:ctime" json:"-"`
 	ModifyTime int64      `gorm:"column:mtime" json:"-"`
 	Sort       int64      `gorm:"column:sort" json:"sort" form:"sort"`
 	CvcA                            float64 `gorm:"column:cvc_a" json:"cvc_a" form:"cvc_a"`
 	CvcV                            float64 `gorm:"column:cvc_v" json:"cvc_v" form:"cvc_v"`
 	Channel                         int64   `gorm:"column:channel" json:"channel" form:"channel"`
+	SealingFluidDispose             string  `gorm:"column:sealing_fluid_dispose" json:"sealing_fluid_dispose" form:"sealing_fluid_dispose"`
 }
 
 func (XtAssessmentAfterDislysis) TableName() string {
 func (SgjDeviceNumber) TableName() string {
 	return "xt_device_number"
 }
+
+type XtScheduleSix struct {
+	ID           int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId    int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId  int64 `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId        int64 `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId    int64 `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate int64 `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType int64 `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek int64 `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId       int64 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Status       int64 `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime  int64 `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime  int64 `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	IsExport     int64 `gorm:"column:is_export" json:"is_export" form:"is_export"`
+}
+
+func (XtScheduleSix) TableName() string {
+
+	return "xt_schedule"
+}

models/dialysis.go

 	UreaBefor                      string  `gorm:"column:urea_befor" json:"urea_befor" form:"urea_befor"`
 	Suction                        string  `gorm:"column:suction" json:"suction" form:"suction"`
 	WeightBeforRemake              string  `gorm:"column:weight_befor_remake" json:"weight_befor_remake" form:"weight_befor_remake"`
+	Height                         string  `gorm:"column:height" json:"height" form:"height"`
+	Age                            string  `gorm:"column:age" json:"age" form:"age"`
+	HisDepartment                  string  `gorm:"column:his_department" json:"his_department" form:"his_department"`
+	HisBed                         string  `gorm:"column:his_bed" json:"his_bed" form:"his_bed"`
 }
 
 func (PredialysisEvaluation) TableName() string {
 	Cruor                      string        `gorm:"column:cruor" json:"cruor" form:"cruor"`
 	Url                        string        `gorm:"column:url" json:"url" form:"url"`
 	Hash                       string        `gorm:"column:hash" json:"hash" form:"hash"`
+	QualityNurseId             int64         `gorm:"column:quality_nurse_id" json:"quality_nurse_id" form:"quality_nurse_id"`
+	PunctureNeedle             string        `gorm:"column:puncture_needle" json:"puncture_needle" form:"puncture_needle"`
+	PunctureWay                string        `gorm:"column:puncture_way" json:"puncture_way" form:"puncture_way"`
+	DialysisDialyszers         string        `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation         string        `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	BloodAccessId              int64         `gorm:"column:blood_access_id" json:"blood_access_id" form:"blood_access_id"`
+	Mission                    string        `gorm:"column:mission" json:"mission" form:"mission"`
+	NucleinDate                int64         `gorm:"column:nuclein_date" json:"nuclein_date" form:"nuclein_date"`
 }
 
 func (DialysisOrder) TableName() string {
 	UserName       string `gorm:"column:user_name" json:"user_name" form:"user_name"`
 	WashpipeNurse  int64  `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
 	ModeId         int64  `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	QualityNurseId int64  `gorm:"column:quality_nurse_id" json:"quality_nurse_id" form:"quality_nurse_id"`
 }
 
 type TreatmentMode struct {
 	PsychologicalOther           string `gorm:"column:psychological_other" json:"psychological_other"`
 	IsPrecaution                 int64  `gorm:"column:is_precaution" json:"is_precaution"`
 	AdmissionNumber              string `gorm:"column:admission_number" json:"admission_number" form:"admission_number"`
+	Diacrisis                    string `gorm:"column:diacrisis" json:"diacrisis" form:"diacrisis"`
 	Tumble                       int64  `gorm:"column:tumble" json:"tumble" form:"tumble"`
+	HisDepartment                string `gorm:"column:his_department" json:"his_department" form:"his_department"`
+	HisBed                       string `gorm:"column:his_bed" json:"his_bed" form:"his_bed"`
 }
 
 func (ReceiveTreatmentAsses) TableName() string {
 func (HisDoctorAdvice) TableName() string {
 	return "his_doctor_advice_info"
 }
+
+type DialysisScheduleSix struct {
+	ID           int64  `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId    int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId  int64  `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId        int64  `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId    int64  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate int64  `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType int64  `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek int64  `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId       int64  `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Status       int64  `gorm:"column:status" json:"status" form:"status"`
+	Name         string `gorm:"column:name" json:"name" form:"name"`
+}
+
+type DialysisScheduleSeven struct {
+	ID           int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId    int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId  int64 `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	ScheduleType int64 `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	Status       int64 `gorm:"column:status" json:"status" form:"status"`
+}
+
+func (DialysisScheduleSeven) TableName() string {
+	return "xt_schedule"
+}

models/drug.go

 }
 
 type BaseDrugLibTwenty struct {
-	ID                  int64  `gorm:"column:id" json:"id" form:"id"`
-	DrugName            string `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
-	Status              int64  `gorm:"column:status" json:"status" form:"status"`
-	OrgId               int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
-	MaxUnit             string `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
-	MinNumber           int64  `gorm:"column:min_number" json:"min_number" form:"min_number"`
-	MinUnit             string `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
-	DrugStockLimitCount int64  `gorm:"column:drug_stock_limit_count" json:"drug_stock_limit_count" form:"drug_stock_limit_count"`
+	ID             int64  `gorm:"column:id" json:"id" form:"id"`
+	DrugName       string `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Status         int64  `gorm:"column:status" json:"status" form:"status"`
+	OrgId          int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	MaxUnit        string `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber      int64  `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit        string `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	DrugStockLimit string `gorm:"column:drug_stock_limit" json:"drug_stock_limit_count" form:"drug_stock_limit"`
 }
 
 func (BaseDrugLibTwenty) TableName() string {

models/drug_stock.go

 	PackingUnit             string  `json:"packing_unit"`
 	Dosage                  int64   `json:"dosage"`
 	ExpireDate              int64   `json:"expire_date"`
+	ConsumableType          int64   `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
 }
 
 type DrugFlow struct {
-	ID                        int64                `gorm:"column:id" json:"id" form:"id"`
-	WarehousingId             int64                `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
-	DrugId                    int64                `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
-	Number                    string               `gorm:"column:number" json:"number" form:"number"`
-	BatchNumber               string               `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
-	Count                     int64                `gorm:"column:count" json:"count" form:"count"`
-	UserOrgId                 int64                `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	PatientId                 int64                `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
-	SystemTime                int64                `gorm:"column:system_time" json:"system_time" form:"system_time"`
-	ConsumableType            int64                `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
-	IsSys                     int64                `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
-	WarehousingOrder          string               `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
-	WarehouseOutId            int64                `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
-	WarehouseOutOrderNumber   string               `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
-	IsEdit                    int64                `gorm:"column:is_edit" json:"is_edit" form:"is_edit"`
-	CancelStockId             int64                `gorm:"column:cancel_stock_id" json:"cancel_stock_id" form:"cancel_stock_id"`
-	CancelOrderNumber         string               `gorm:"column:cancel_order_number" json:"cancel_order_number" form:"cancel_order_number"`
-	Manufacturer              int64                `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
-	Dealer                    int64                `gorm:"column:dealer" json:"dealer" form:"dealer"`
-	Creator                   int64                `gorm:"column:creator" json:"creator" form:"creator"`
-	UpdateCreator             int64                `gorm:"column:update_creator" json:"update_creator" form:"update_creator"`
-	Status                    int64                `gorm:"column:status" json:"status" form:"status"`
-	Ctime                     int64                `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                     int64                `gorm:"column:mtime" json:"mtime" form:"mtime"`
-	Price                     float64              `gorm:"column:price" json:"price" form:"price"`
-	WarehousingDetailId       int64                `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
-	WarehouseOutDetailId      int64                `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
-	CancelOutDetailId         int64                `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
-	ExpireDate                int64                `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
-	ProductDate               int64                `gorm:"column:product_date" json:"product_date" form:"product_date"`
-	MaxUnit                   string               `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
-	MinUnit                   string               `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
-	StockMaxNumber            int64                `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
-	StockMinNumber            int64                `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
-	LastStockMaxNumber        int64                `gorm:"column:last_stock_max_number" json:"last_stock_max_number" form:"last_stock_max_number"`
-	LastStockMinNumber        int64                `gorm:"column:last_stock_min_number" json:"last_stock_min_number" form:"last_stock_min_number"`
-	DrugWarehouseInfo         []*DrugWarehouseInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:DrugId" `
-	BaseDrugLib               BaseDrugLib          `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId" `
-	AdviceId                  int64                `gorm:"column:advice_id" json:"advice_id" form:"advice_id"`
-	SupplyWarehouseId         int64                `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
-	SupplyCancelOutId         int64                `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
-	SupplyWarehouseDetailInfo int64                `gorm:"column:supply_warehouse_detail_info" json:"supply_warehouse_detail_info" form:"supply_warehouse_detail_info"`
-	StorehouseId              int64                `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
-	SecondWarehouseInfoId     int64                `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
-	AdminUserId               int64                `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
-	LastPrice                 float64              `gorm:"column:last_price" json:"last_price" form:"last_price"`
-	StockCount                string               `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
-	PharmacyId                int64                `gorm:"column:pharmacy_id" json:"pharmacy_id" form:"pharmacy_id"`
-	DrugWarehouseInfoOne      DrugWarehouseInfo    `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingDetailId"json:"xt_drug_warehouse_info" `
-	IsRead                    int64                `gorm:"column:is_read" json:"is_read" form:"is_read"`
-	IsCheck                   int64                `gorm:"column:is_check" json:"is_check" form:"is_check"`
-	OverCount                 int64                `gorm:"column:over_count" json:"over_count" form:"over_count"`
-	RetailPrice               float64              `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	ID                        int64                  `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId             int64                  `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	DrugId                    int64                  `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Number                    string                 `gorm:"column:number" json:"number" form:"number"`
+	BatchNumber               string                 `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
+	Count                     int64                  `gorm:"column:count" json:"count" form:"count"`
+	UserOrgId                 int64                  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId                 int64                  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	SystemTime                int64                  `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	ConsumableType            int64                  `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	IsSys                     int64                  `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
+	WarehousingOrder          string                 `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
+	WarehouseOutId            int64                  `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	WarehouseOutOrderNumber   string                 `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	IsEdit                    int64                  `gorm:"column:is_edit" json:"is_edit" form:"is_edit"`
+	CancelStockId             int64                  `gorm:"column:cancel_stock_id" json:"cancel_stock_id" form:"cancel_stock_id"`
+	CancelOrderNumber         string                 `gorm:"column:cancel_order_number" json:"cancel_order_number" form:"cancel_order_number"`
+	Manufacturer              int64                  `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Dealer                    int64                  `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Creator                   int64                  `gorm:"column:creator" json:"creator" form:"creator"`
+	UpdateCreator             int64                  `gorm:"column:update_creator" json:"update_creator" form:"update_creator"`
+	Status                    int64                  `gorm:"column:status" json:"status" form:"status"`
+	Ctime                     int64                  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                     int64                  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Price                     float64                `gorm:"column:price" json:"price" form:"price"`
+	WarehousingDetailId       int64                  `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
+	WarehouseOutDetailId      int64                  `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
+	CancelOutDetailId         int64                  `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
+	ExpireDate                int64                  `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
+	ProductDate               int64                  `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	MaxUnit                   string                 `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit                   string                 `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	StockMaxNumber            int64                  `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
+	StockMinNumber            int64                  `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
+	LastStockMaxNumber        int64                  `gorm:"column:last_stock_max_number" json:"last_stock_max_number" form:"last_stock_max_number"`
+	LastStockMinNumber        int64                  `gorm:"column:last_stock_min_number" json:"last_stock_min_number" form:"last_stock_min_number"`
+	DrugWarehouseInfo         []*DrugWarehouseInfo   `gorm:"ForeignKey:DrugId;AssociationForeignKey:DrugId" `
+	BaseDrugLib               BaseDrugLib            `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId" `
+	AdviceId                  int64                  `gorm:"column:advice_id" json:"advice_id" form:"advice_id"`
+	SupplyWarehouseId         int64                  `gorm:"column:supply_warehouse_id" json:"supply_warehouse_id" form:"supply_warehouse_id"`
+	SupplyCancelOutId         int64                  `gorm:"column:supply_cancel_out_id" json:"supply_cancel_out_id" form:"supply_cancel_out_id"`
+	SupplyWarehouseDetailInfo int64                  `gorm:"column:supply_warehouse_detail_info" json:"supply_warehouse_detail_info" form:"supply_warehouse_detail_info"`
+	StorehouseId              int64                  `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	SecondWarehouseInfoId     int64                  `gorm:"column:second_warehouse_info_id" json:"second_warehouse_info_id" form:"second_warehouse_info_id"`
+	AdminUserId               int64                  `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	LastPrice                 float64                `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	StockCount                string                 `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	PharmacyId                int64                  `gorm:"column:pharmacy_id" json:"pharmacy_id" form:"pharmacy_id"`
+	DrugWarehouseInfoOne      DrugWarehouseInfo      `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingDetailId"json:"xt_drug_warehouse_info" `
+	IsRead                    int64                  `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	IsCheck                   int64                  `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	OverCount                 int64                  `gorm:"column:over_count" json:"over_count" form:"over_count"`
+	RetailPrice               float64                `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	XtDrugWarehouseOutInfo    XtDrugWarehouseOutInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehouseOutDetailId"json:"xt_drug_warehouse_out_info" `
 }
 
 func (DrugFlow) TableName() string {

models/good_models.go

 	Number         int64  `gorm:"column:number" json:"number"`
 	OutStock       int64  `gorm:"column:out_stock" json:"out_stock" form:"out_stock"`
 	StockAttribute int64  `gorm:"column:stock_attribute" json:"stock_attribute" form:"stock_attribute"`
+	IsOpen         int64  `gorm:"column:is_open" json:"is_open" form:"is_open"`
 }
 
 func (GoodsType) TableName() string {
 }
 
 type GoodsTypeOne struct {
-	ID             int64       `gorm:"column:id" json:"id"`
-	TypeCode       string      `gorm:"column:type_code" json:"type_code"`
-	TypeName       string      `gorm:"column:type_name" json:"type_name"`
-	Remark         string      `gorm:"column:remark" json:"remark"`
-	Ctime          int64       `gorm:"column:ctime" json:"ctime"`
-	Mtime          int64       `gorm:"column:mtime" json:"mtime"`
-	Creater        int64       `gorm:"column:creater" json:"creater"`
-	Modifier       int64       `gorm:"column:modifier" json:"modifier"`
-	OrgId          int64       `gorm:"column:org_id" json:"org_id"`
-	Status         int64       `gorm:"column:status" json:"status"`
-	Type           int64       `gorm:"column:type" json:"type"`
-	Number         int64       `gorm:"column:number" json:"number"`
-	OutStock       int64       `gorm:"column:out_stock" json:"out_stock" form:"out_stock"`
-	StockAttribute int64       `gorm:"column:stock_attribute" json:"stock_attribute" form:"stock_attribute"`
-	GoodInfo       []*GoodInfo `gorm:"ForeignKey:GoodTypeId;AssociationForeignKey:ID" json:"GoodInfo"`
+	ID             int64                    `gorm:"column:id" json:"id"`
+	TypeCode       string                   `gorm:"column:type_code" json:"type_code"`
+	TypeName       string                   `gorm:"column:type_name" json:"type_name"`
+	Remark         string                   `gorm:"column:remark" json:"remark"`
+	Ctime          int64                    `gorm:"column:ctime" json:"ctime"`
+	Mtime          int64                    `gorm:"column:mtime" json:"mtime"`
+	Creater        int64                    `gorm:"column:creater" json:"creater"`
+	Modifier       int64                    `gorm:"column:modifier" json:"modifier"`
+	OrgId          int64                    `gorm:"column:org_id" json:"org_id"`
+	Status         int64                    `gorm:"column:status" json:"status"`
+	Type           int64                    `gorm:"column:type" json:"type"`
+	Number         int64                    `gorm:"column:number" json:"number"`
+	OutStock       int64                    `gorm:"column:out_stock" json:"out_stock" form:"out_stock"`
+	StockAttribute int64                    `gorm:"column:stock_attribute" json:"stock_attribute" form:"stock_attribute"`
+	GoodInfo       []*GoodInformationThirty `gorm:"ForeignKey:GoodTypeId;AssociationForeignKey:ID" json:"GoodInfo"`
 }
 
 func (GoodsTypeOne) TableName() string {
 func (XtCancelStockInfo) TableName() string {
 	return "xt_cancel_stock_info"
 }
+
+type BloodGoodsType struct {
+	ID             int64  `gorm:"column:id" json:"id"`
+	TypeCode       string `gorm:"column:type_code" json:"type_code"`
+	TypeName       string `gorm:"column:type_name" json:"type_name"`
+	Remark         string `gorm:"column:remark" json:"remark"`
+	Ctime          int64  `gorm:"column:ctime" json:"ctime"`
+	Mtime          int64  `gorm:"column:mtime" json:"mtime"`
+	Creater        int64  `gorm:"column:creater" json:"creater"`
+	Modifier       int64  `gorm:"column:modifier" json:"modifier"`
+	OrgId          int64  `gorm:"column:org_id" json:"org_id"`
+	Status         int64  `gorm:"column:status" json:"status"`
+	Type           int64  `gorm:"column:type" json:"type"`
+	Number         int64  `gorm:"column:number" json:"number"`
+	OutStock       int64  `gorm:"column:out_stock" json:"out_stock" form:"out_stock"`
+	StockAttribute int64  `gorm:"column:stock_attribute" json:"stock_attribute" form:"stock_attribute"`
+	IsOpen         int64  `gorm:"column:is_open" json:"is_open" form:"is_open"`
+}
+
+func (BloodGoodsType) TableName() string {
+	return "xt_goods_type"
+}
+
+type GoodInformationThirty struct {
+	ID                          int64   `gorm:"column:id" json:"id" form:"id"`
+	GoodCode                    string  `gorm:"column:good_code" json:"good_code" form:"good_code"`
+	SpecificationName           string  `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	GoodTypeId                  int64   `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+	GoodUnit                    int64   `gorm:"column:good_unit" json:"good_unit" form:"good_unit"`
+	BuyPrice                    float64 `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	SellPrice                   float64 `gorm:"column:sell_price" json:"sell_price" form:"sell_price"`
+	Remark                      string  `gorm:"column:remark" json:"remark" form:"remark"`
+	Ctime                       int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Manufacturer                int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Dealer                      int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	ExpiryDateWarnDayCount      int64   `gorm:"column:expiry_date_warn_day_count" json:"expiry_date_warn_day_count" form:"expiry_date_warn_day_count"`
+	StockWarnCount              int64   `gorm:"column:stock_warn_count" json:"stock_warn_count" form:"stock_warn_count"`
+	IsReuse                     int64   `gorm:"column:is_reuse" json:"is_reuse" form:"is_reuse"`
+	Status                      int64   `gorm:"column:status" json:"status" form:"status"`
+	FilmArea                    string  `gorm:"column:film_area" json:"film_area" form:"film_area"`
+	IsUse                       int64   `gorm:"column:is_use" json:"is_use" form:"is_use"`
+	FilmMaterialQuality         string  `gorm:"column:film_material_quality" json:"film_material_quality" form:"film_material_quality"`
+	OrgId                       int64   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	Modifier                    int64   `gorm:"column:modifier" json:"modifier" form:"modifier"`
+	Creater                     int64   `gorm:"column:creater" json:"creater" form:"creater"`
+	GoodName                    string  `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	Pinyin                      string  `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string  `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	GoodKind                    int64   `gorm:"column:good_kind" json:"good_kind" form:"good_kind"`
+	MedicalInsuranceLevel       int64   `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	RetailPrice                 float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MedicalInsuranceNumber      string  `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	IsSpecialDiseases           int64   `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64   `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	StatisticsCategory          int64   `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	GoodStatus                  string  `gorm:"column:good_status" json:"good_status" form:"good_status"`
+	DefaultCount                int64   `gorm:"column:default_count" json:"default_count" form:"default_count"`
+	IsDefault                   int64   `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargeUse                 int64   `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	IsChargePredict             int64   `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64   `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	Sign                        int64   `gorm:"column:sign" json:"sign" form:"sign"`
+	Sort                        int64   `gorm:"column:sort" json:"sort" form:"sort"`
+	IsDoctorUse                 int64   `gorm:"column:is_doctor_use" json:"is_doctor_use" form:"is_doctor_use"`
+	Agent                       string  `gorm:"column:agent" json:"agent" form:"agent"`
+	GoodNumber                  string  `gorm:"column:good_number" json:"good_number" form:"good_number"`
+	CommdityCode                string  `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
+	SocialSecurityDirectoryCode string  `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	ProductionType              string  `gorm:"column:production_type" json:"production_type" form:"production_type"`
+	SpecialMedical              string  `gorm:"column:special_medical" json:"special_medical" form:"special_medical"`
+	IsMark                      int64   `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	Total                       float64 `gorm:"column:total" json:"total" form:"total"`
+	MinNumber                   int64   `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	PackingUnit                 string  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	PackingPrice                float64 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	DefaultCountUnit            string  `gorm:"column:default_count_unit" json:"default_count_unit" form:"default_count_unit"`
+	MinUnit                     string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	RegisterNumber              string  `gorm:"column:register_number" json:"register_number" form:"register_number"`
+	ProvincesCode               string  `gorm:"column:provinces_code" json:"provinces_code" form:"provinces_code"`
+	IsUser                      int64   `gorm:"column:is_user" json:"is_user" form:"is_user"`
+	Number                      string  `gorm:"column:number" json:"number" form:"number"`
+	IsWarehouse                 string  `gorm:"column:is_warehouse" json:"is_warehouse" form:"is_warehouse"`
+	BatchRetaiPrice             float64 `gorm:"column:batch_retai_price" json:"batch_retai_price" form:"batch_retai_price"`
+	SumCount                    int64   `gorm:"column:sum_count" json:"sum_count" form:"sum_count"`
+	SumInCount                  int64   `gorm:"column:sum_in_count" json:"sum_in_count" form:"sum_in_count"`
+	TotalCount                  int64   `gorm:"column:total_count" json:"total_count" form:"total_count"`
+	SumOutCount                 int64   `gorm:"column:sum_out_count" json:"sum_out_count" form:"sum_out_count"`
+	SumCancelCount              int64   `gorm:"column:sum_cancel_count" json:"sum_cancel_count" form:"sum_cancel_count"`
+}
+
+func (GoodInformationThirty) TableName() string {
+	return "xt_good_information"
+}

models/his_models.go

 	IsCheckTeam          int64        `gorm:"-" json:"is_check_team" form:"is_check_team"`
 	HisOrderInfo         HisOrderInfo `gorm:"ForeignKey:ProjectId;AssociationForeignKey:ID" json:"order_info"`
 	ExecutionFrequencyId int64        `gorm:"column:execution_frequency_id" json:"execution_frequency_id" form:"execution_frequency_id"`
+	IsOut                int64        `gorm:"column:is_out" json:"is_out" form:"is_out"` //新增字段
 }
 
 func (HisPrescriptionProject) TableName() string {

models/new_stock_models.go

 }
 
 type XtDialysisSetting struct {
-	ID                    int64 `gorm:"column:id" json:"id" form:"id"`
-	UserOrgId             int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	Status                int64 `gorm:"column:status" json:"status" form:"status"`
-	DeviceNumber          int64 `gorm:"column:device_number" json:"device_number" form:"device_number"`
-	DeviceType            int64 `gorm:"column:device_type" json:"device_type" form:"device_type"`
-	Name                  int64 `gorm:"column:name" json:"name" form:"name"`
-	AdmissionNumber       int64 `gorm:"column:admission_number" json:"admission_number" form:"admission_number"`
-	DialysisNo            int64 `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
-	WeightBefor           int64 `gorm:"column:weight_befor" json:"weight_befor" form:"weight_befor"`
-	DryWeight             int64 `gorm:"column:dry_weight" json:"dry_weight" form:"dry_weight"`
-	BloodPressure         int64 `gorm:"column:blood_pressure" json:"blood_pressure" form:"blood_pressure"`
-	UltrafiltrationVolume int64 `gorm:"column:ultrafiltration_volume" json:"ultrafiltration_volume" form:"ultrafiltration_volume"`
-	InternalFistula       int64 `gorm:"column:internal_fistula" json:"internal_fistula" form:"internal_fistula"`
-	BloodFlowVolume       int64 `gorm:"column:blood_flow_volume" json:"blood_flow_volume" form:"blood_flow_volume"`
-	Anticoagulant         int64 `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
-	SealingFluidDispose   int64 `gorm:"column:sealing_fluid_dispose" json:"sealing_fluid_dispose" form:"sealing_fluid_dispose"`
-	ModeId                int64 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
-	DialysisTime          int64 `gorm:"column:dialysis_time" json:"dialysis_time" form:"dialysis_time"`
-	DialysisDialyszers    int64 `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
-	DialysisIrrigation    int64 `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
-	Gaijiliang            int64 `gorm:"column:gaijiliang" json:"gaijiliang" form:"gaijiliang"`
-	Kalium                int64 `gorm:"column:kalium" json:"kalium" form:"kalium"`
-	DisplaceLiquiValue    int64 `gorm:"column:displace_liqui_value" json:"displace_liqui_value" form:"displace_liqui_value"`
-	Bicarbonate           int64 `gorm:"column:bicarbonate" json:"bicarbonate" form:"bicarbonate"`
-	Glucose               int64 `gorm:"column:glucose" json:"glucose" form:"glucose"`
-	Ctime                 int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
-	Mtime                 int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	ID                         int64 `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                  int64 `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Status                     int64 `gorm:"column:status" json:"status" form:"status"`
+	DeviceNumber               int64 `gorm:"column:device_number" json:"device_number" form:"device_number"`
+	DeviceType                 int64 `gorm:"column:device_type" json:"device_type" form:"device_type"`
+	Name                       int64 `gorm:"column:name" json:"name" form:"name"`
+	AdmissionNumber            int64 `gorm:"column:admission_number" json:"admission_number" form:"admission_number"`
+	DialysisNo                 int64 `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
+	WeightBefor                int64 `gorm:"column:weight_befor" json:"weight_befor" form:"weight_befor"`
+	DryWeight                  int64 `gorm:"column:dry_weight" json:"dry_weight" form:"dry_weight"`
+	BloodPressure              int64 `gorm:"column:blood_pressure" json:"blood_pressure" form:"blood_pressure"`
+	UltrafiltrationVolume      int64 `gorm:"column:ultrafiltration_volume" json:"ultrafiltration_volume" form:"ultrafiltration_volume"`
+	InternalFistula            int64 `gorm:"column:internal_fistula" json:"internal_fistula" form:"internal_fistula"`
+	BloodFlowVolume            int64 `gorm:"column:blood_flow_volume" json:"blood_flow_volume" form:"blood_flow_volume"`
+	Anticoagulant              int64 `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
+	SealingFluidDispose        int64 `gorm:"column:sealing_fluid_dispose" json:"sealing_fluid_dispose" form:"sealing_fluid_dispose"`
+	ModeId                     int64 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	DialysisTime               int64 `gorm:"column:dialysis_time" json:"dialysis_time" form:"dialysis_time"`
+	DialysisDialyszers         int64 `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation         int64 `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	Gaijiliang                 int64 `gorm:"column:gaijiliang" json:"gaijiliang" form:"gaijiliang"`
+	Kalium                     int64 `gorm:"column:kalium" json:"kalium" form:"kalium"`
+	DisplaceLiquiValue         int64 `gorm:"column:displace_liqui_value" json:"displace_liqui_value" form:"displace_liqui_value"`
+	Bicarbonate                int64 `gorm:"column:bicarbonate" json:"bicarbonate" form:"bicarbonate"`
+	Glucose                    int64 `gorm:"column:glucose" json:"glucose" form:"glucose"`
+	Ctime                      int64 `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                      int64 `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Sodium                     int64 `gorm:"column:sodium" json:"sodium" form:"sodium"`
+	Calcium                    int64 `gorm:"column:calcium" json:"calcium" form:"calcium"`
+	BloodAccess                int64 `gorm:"column:blood_access" json:"blood_access" form:"blood_access"`
+	DialyzerPerfusionApparatus int64 `gorm:"column:dialyzer_perfusion_apparatus" json:"dialyzer_perfusion_apparatus" form:"dialyzer_perfusion_apparatus"`
+	DisplaceLiquiPart          int64 `gorm:"column:displace_liqui_part" json:"displace_liqui_part" form:"displace_liqui_part"`
 }
 
 func (XtDialysisSetting) TableName() string {
 	return "xt_dialysis_setting"
 }
+
+type VmStockFlowTwenty struct {
+	ID                  int64           `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId       int64           `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	GoodId              int64           `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	Count               int64           `gorm:"column:count" json:"count" form:"count"`
+	UserOrgId           int64           `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId           int64           `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	SystemTime          int64           `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	ConsumableType      int64           `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	IsSys               int64           `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
+	Price               float64         `gorm:"column:price" json:"price" form:"price"`
+	WarehousingDetailId int64           `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
+	BuyPrice            float64         `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	IsRead              int64           `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	OverCount           int64           `gorm:"column:over_count" json:"over_count" form:"over_count"`
+	Ctime               int64           `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	WarehousingInfo     WarehousingInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingId" json:"xt_warehouse_info"`
+}
+
+func (VmStockFlowTwenty) TableName() string {
+	return "xt_stock_flow"
+}
+
+type GoodInfoTwenty struct {
+	ID                     int64                   `gorm:"column:id" json:"id" form:"id"`
+	SpecificationName      string                  `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	GoodTypeId             int64                   `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+	BuyPrice               float64                 `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	Manufacturer           int64                   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Status                 int64                   `gorm:"column:status" json:"status" form:"status"`
+	OrgId                  int64                   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	GoodName               string                  `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	RetailPrice            float64                 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	Ctime                  int64                   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	PackingUnit            string                  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	PackingPrice           float64                 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	StWarehousingInfo      []*StWarehousingInfo    `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_warehouse_info"`
+	WarehousingInfoOne     []*StartWarehousingInfo `gorm:"json:"warehouse_info"` //期间增加
+	WarehousingInfoStart   []*StartWarehousingInfo `gorm:"json:"warehouse_info_start"`
+	WarehousingInfoEnd     []*StartWarehousingInfo `gorm:"json:"warehouse_info_end"`
+	WarehouseOutInfoEnd    []*VmStockFlowTwenty
+	WarehouseOutInfoStart  []*VmStockFlowTwenty
+	WarehouseInfoEnd       []*VmStockFlowTwenty //期末入库量
+	StartFlowWarehouseInfo []*VmStockFlowTwenty //本期增加
+	//期初结余
+	StartFlowInfo    []*VmStockFlowTwenty
+	StartOutFlowInfo []*VmStockFlowTwenty
+	//期末结余
+	EndFlowInfo    []*VmStockFlowTwenty
+	EndFlowOutInfo []*VmStockFlowTwenty
+	//期初退库
+	StartCancelFlowInfo []*VmStockFlowTwenty
+	//期末退库
+	EndCancelFLowInfo []*VmStockFlowTwenty
+
+	StartEndCancelFLowInfo []*VmStockFlowTwenty
+
+	WareStartStockInventoryProfit []*VmStockFlowTwenty //期初盘盈
+	WareStartStockInventoryLosses []*VmStockFlowTwenty //期初盘亏
+
+	WareEndStockInventoryProfit []*VmStockFlowTwenty //期末盘盈
+	WareEndStockInventoryLosses []*VmStockFlowTwenty //期末盘亏
+
+	WareStartEndStockInventoryProfit []*VmStockFlowTwenty //期间盘盈
+	WareStartEndStockInventoryLosses []*VmStockFlowTwenty //期间盘亏
+
+	//期初结余
+	GoodStartFlowInfo VmStockFlowTwenty
+	//期末结余
+	GoodEndFlowInfo VmStockFlowTwenty
+}
+
+func (GoodInfoTwenty) TableName() string {
+	return "xt_good_information"
+}
+
+type CancelStockInfoTwenty struct {
+	ID              int64   `gorm:"column:id" json:"id"`
+	GoodId          int64   `gorm:"column:good_id" json:"good_id"`
+	Count           int64   `gorm:"column:count" json:"count"`
+	Price           float64 `gorm:"column:price" json:"price"`
+	Ctime           int64   `gorm:"column:ctime" json:"ctime"`
+	Mtime           int64   `gorm:"column:mtime" json:"mtime"`
+	Status          int64   `gorm:"column:status" json:"status"`
+	OrgId           int64   `gorm:"column:org_id" json:"org_id"`
+	Number          string  `gorm:"column:number" json:"number" form:"number"`
+	WarehouseInfoId int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
+	PatientId       int64   `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	RecordDate      int64   `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	IsCheck         int64   `gorm:"column:is_check" json:"is_check" form:"is_check"`
+}
+
+func (CancelStockInfoTwenty) TableName() string {
+	return "xt_cancel_stock_info"
+}
+
+type WarehouseOutInfoTwenty struct {
+	ID               int64           `gorm:"column:id" json:"id"`
+	WarehouseOutId   int64           `gorm:"column:warehouse_out_id" json:"warehouse_out_id"`
+	WarehouseInfotId int64           `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
+	GoodId           int64           `gorm:"column:good_id" json:"good_id"`
+	Count            int64           `gorm:"column:count" json:"count"`
+	Price            float64         `gorm:"column:price" json:"price"`
+	TotalPrice       float64         `gorm:"column:total_price" json:"total_price"`
+	Mtime            int64           `gorm:"column:mtime" json:"mtime"`
+	Ctime            int64           `gorm:"column:ctime" json:"ctime"`
+	Status           int64           `gorm:"column:status" json:"status"`
+	OrgId            int64           `gorm:"column:org_id" json:"org_id"`
+	IsSys            int64           `gorm:"column:is_sys" json:"is_sys"`
+	SysRecordTime    int64           `gorm:"column:sys_record_time" json:"sys_record_time"`
+	PatientId        int64           `gorm:"column:patient_id" json:"patient_id"`
+	ConsumableType   int64           `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	ProjectId        int64           `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	StorehouseId     int64           `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	BuyPrice         float64         `gorm:"column:buy_price" json:"buy_price" form:"buy_price"`
+	StockCount       string          `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	IsCheck          int64           `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	WarehousingInfo  WarehousingInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehouseInfotId" `
+	OverCount        int64           `gorm:"column:over_count" json:"over_count" form:"over_count"`
+}
+
+func (WarehouseOutInfoTwenty) TableName() string {
+	return "xt_warehouse_out_info"
+}
+
+type WarehousingInfoTwenty struct {
+	ID               int64   `gorm:"column:id" json:"id"`
+	WarehousingId    int64   `gorm:"column:warehousing_id" json:"warehousing_id"`
+	GoodId           int64   `gorm:"column:good_id" json:"good_id"`
+	WarehousingCount int64   `gorm:"column:warehousing_count" json:"warehousing_count"`
+	Price            float64 `gorm:"column:price" json:"price"`
+	TotalPrice       float64 `gorm:"column:total_price" json:"total_price"`
+	Dealer           int64   `gorm:"column:dealer" json:"dealer"`
+	Manufacturer     int64   `gorm:"column:manufacturer" json:"manufacturer"`
+	Ctime            int64   `gorm:"column:ctime" json:"ctime"`
+	Mtime            int64   `gorm:"column:mtime" json:"mtime"`
+	Status           int64   `gorm:"column:status" json:"status"`
+	OrgId            int64   `gorm:"column:org_id" json:"org_id"`
+	StockCount       int64   `gorm:"column:stock_count" json:"stock_count" form:"stock_count"`
+	WarehouseInfoId  int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
+	PackingPrice     float64 `gorm:"column:packing_price" json:"packing_price" form:"packing_price"`
+	StorehouseId     int64   `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	IsCheck          int64   `gorm:"column:is_check" json:"is_check" form:"is_check"`
+}
+
+func (WarehousingInfoTwenty) TableName() string {
+	return "xt_warehouse_info"
+}
+
+type VmBaseDrugTwenty struct {
+	ID                               int64             `gorm:"column:id" json:"id" form:"id"`
+	DrugType                         int64             `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
+	DrugName                         string            `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	MaxUnit                          string            `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber                        int64             `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit                          string            `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	Dose                             string            `gorm:"column:dose" json:"dose" form:"dose"`
+	DoseUnit                         string            `gorm:"column:dose_unit" json:"dose_unit" form:"dose_unit"`
+	RetailPrice                      float64           `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MinPrice                         float64           `gorm:"column:min_price" json:"min_price" form:"min_price"`
+	LastPrice                        float64           `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	Manufacturer                     int64             `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Status                           int64             `gorm:"column:status" json:"status" form:"status"`
+	Ctime                            int64             `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                            int64             `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                            int64             `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugFlowWarehouseInfo            []*DrugFlowTwenty `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_flow_info"`
+	DrugActFlowWarehouseInfo         []*DrugFlowTwenty `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_act_flow_info"`
+	DrugWarehouseInfoStart           []*DrugFlowTwenty //期初入库结余
+	DrugWarehouseOutInfoStart        []*DrugFlowTwenty //期初出库结余
+	DrugWarehouseOutInfoEnd          []*DrugFlowTwenty //期末出库结余
+	DrugWarehouseInfoEnd             []*DrugFlowTwenty //期末入库结余
+	DrugWarehouseInfoStartEnd        []*DrugFlowTwenty //期中增加
+	DrugWarehouseOutInfoStartEnd     []*DrugFlowTwenty //  期中减少
+	WareStartStockInventoryProfit    []*DrugFlowTwenty //期初盘盈
+	WareStartStockInventoryLosses    []*DrugFlowTwenty //期初盘亏
+	WareEndStockInventoryProfit      []*DrugFlowTwenty //期末盘盈
+	WareEndStockInventoryLosses      []*DrugFlowTwenty //期末盘亏
+	WareStartEndStockInventoryProfit []*DrugFlowTwenty //期间盘盈
+	WareStartEndStockInventoryLosses []*DrugFlowTwenty //期间盘亏
+	WareStartStockCancelInfo         []*DrugFlowTwenty //期初结余退库
+	WareEndStockCancelInfo           []*DrugFlowTwenty //期末结余退库
+	WareStartEndStockCancelInfo      []*DrugFlowTwenty //期中减少退库
+
+	DrugStatFlow DrugFlowTwenty
+	DrugEndFlow  DrugFlowTwenty
+}
+
+func (VmBaseDrugTwenty) TableName() string {
+	return "xt_base_drug"
+}
+
+type DrugFlowTwenty struct {
+	ID                     int64                  `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId          int64                  `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	DrugId                 int64                  `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Count                  int64                  `gorm:"column:count" json:"count" form:"count"`
+	UserOrgId              int64                  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId              int64                  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	SystemTime             int64                  `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	ConsumableType         int64                  `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	Manufacturer           int64                  `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Status                 int64                  `gorm:"column:status" json:"status" form:"status"`
+	Ctime                  int64                  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                  int64                  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Price                  float64                `gorm:"column:price" json:"price" form:"price"`
+	WarehousingDetailId    int64                  `gorm:"column:warehousing_detail_id" json:"warehousing_detail_id" form:"warehousing_detail_id"`
+	WarehouseOutDetailId   int64                  `gorm:"column:warehouse_out_detail_id" json:"warehouse_out_detail_id" form:"warehouse_out_detail_id"`
+	CancelOutDetailId      int64                  `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
+	MaxUnit                string                 `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit                string                 `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	StorehouseId           int64                  `gorm:"column:storehouse_id" json:"storehouse_id" form:"storehouse_id"`
+	DrugWarehouseInfoOne   DrugWarehouseInfo      `gorm:"ForeignKey:ID;AssociationForeignKey:WarehousingDetailId"json:"xt_drug_warehouse_info" `
+	IsRead                 int64                  `gorm:"column:is_read" json:"is_read" form:"is_read"`
+	IsCheck                int64                  `gorm:"column:is_check" json:"is_check" form:"is_check"`
+	OverCount              int64                  `gorm:"column:over_count" json:"over_count" form:"over_count"`
+	XtDrugWarehouseOutInfo XtDrugWarehouseOutInfo `gorm:"ForeignKey:ID;AssociationForeignKey:WarehouseOutDetailId"json:"xt_drug_warehouse_out_info" `
+}
+
+func (DrugFlowTwenty) TableName() string {
+	return "xt_drug_flow"
+}

models/patient_models.go

 	IdCardNo           string `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
 	UserSysBeforeCount int64  `gorm:"column:user_sys_before_count" json:"user_sys_before_count" form:"user_sys_before_count"`
 	TrobleShoot        int64  `gorm:"column:troble_shoot" json:"troble_shoot" form:"troble_shoot"`
+	SchRemark          string `gorm:"column:sch_remark" json:"sch_remark" form:"sch_remark"`
 }
 
 func (MSchedualPatientList) TableName() string {
 	// PrescriptionId int64  `gorm:"column:prescription_id" json:"prescription_id"`
 	Stage int64 `gorm:"column:stage" json:"stage"`
 	// Remark         string `gorm:"column:remark" json:"remark"`
-	BedID         int64                 `gorm:"column:bed_id" json:"bed_id"`
-	StartNurse    int64                 `gorm:"column:start_nurse" json:"start_nurse"`
-	Status        int64                 `gorm:"column:status" json:"status"`
-	DeviceNumber  *MDeviceNumberForList `gorm:"ForeignKey:BedID" json:"device_number"`
-	Creator       int64                 `gorm:"column:creator" json:"creator"`
-	WashpipeNurse int64                 `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
+	BedID              int64                 `gorm:"column:bed_id" json:"bed_id"`
+	StartNurse         int64                 `gorm:"column:start_nurse" json:"start_nurse"`
+	Status             int64                 `gorm:"column:status" json:"status"`
+	DeviceNumber       *MDeviceNumberForList `gorm:"ForeignKey:BedID" json:"device_number"`
+	Creator            int64                 `gorm:"column:creator" json:"creator"`
+	WashpipeNurse      int64                 `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
+	NucleinDate        int64                 `gorm:"column:nuclein_date" json:"nuclein_date" form:"nuclein_date"`
+	EndTime            int64                 `gorm:"column:end_time" json:"end_time" form:"end_time"`
+	DialysisIrrigation string                `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialysisDialyszers string                `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
 }
 
 func (MDialysisOrderForList) TableName() string {
 	return "xt_dialysis_order"
 }
 
+type MDialysisOrderForListSix struct {
+	ID                 int64  `gorm:"column:id" json:"id"`
+	DialysisDate       int64  `gorm:"column:dialysis_date" json:"dialysis_date"`
+	UserOrgId          int64  `gorm:"column:user_org_id" json:"user_org_id"`
+	PatientId          int64  `gorm:"column:patient_id" json:"patient_id"`
+	Stage              int64  `gorm:"column:stage" json:"stage"`
+	BedID              int64  `gorm:"column:bed_id" json:"bed_id"`
+	StartNurse         int64  `gorm:"column:start_nurse" json:"start_nurse"`
+	Status             int64  `gorm:"column:status" json:"status"`
+	Creator            int64  `gorm:"column:creator" json:"creator"`
+	WashpipeNurse      int64  `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
+	NucleinDate        int64  `gorm:"column:nuclein_date" json:"nuclein_date" form:"nuclein_date"`
+	EndTime            int64  `gorm:"column:end_time" json:"end_time" form:"end_time"`
+	DialysisIrrigation string `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialysisDialyszers string `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+}
+
+func (MDialysisOrderForListSix) TableName() string {
+	return "xt_dialysis_order"
+}
+
 type VMTreatmentSummaryForList struct {
 	ID              int64  `gorm:"column:id" json:"id"`
 	UserOrgId       int64  `gorm:"column:user_org_id" json:"user_org_id"`
 	DryWeight                float64 `gorm:"-"`
 	ZbPatientId              string  `gorm:"column:zb_patient_id" json:"zb_patient_id" form:"zb_patient_id"`
 	TreatmentPlan            string  `gorm:"column:treatment_plan" json:"treatment_plan" form:"treatment_plan"`
+	Doctor                   int64   `gorm:"column:doctor" json:"doctor" form:"doctor"`
 }
 
 func (Patients) TableName() string {
 	Epo                        string        `gorm:"column:epo" json:"epo" form:"epo"`
 	EpoCount                   float64       `gorm:"column:epo_count" json:"epo_count" form:"epo_count"`
 	MaxUltrafiltrationRate     float64       `gorm:"column:max_ultrafiltration_rate" json:"max_ultrafiltration_rate" form:"max_ultrafiltration_rate"`
+	AdminUserId                int64         `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	IsWater                    int64         `gorm:"column:is_water" json:"is_water" form:"is_water"`
+	DrhyWater                  string        `gorm:"column:drhy_water" json:"drhy_water" form:"drhy_water"`
+	DryWaterHour               string        `gorm:"column:dry_water_hour" json:"dry_water_hour" form:"dry_water_hour"`
+	WaterMachine               string        `gorm:"column:water_machine" json:"water_machine" form:"water_machine"`
 }
 
 func (DialysisPrescription) TableName() string {
 	DeathTime                    int64   `gorm:"column:death_time" json:"death_time" form:"death_time"`
 	TrobleShoot                  int64   `gorm:"column:troble_shoot" json:"troble_shoot" form:"troble_shoot"`
 	TreatmentPlan                string  `gorm:"column:treatment_plan" json:"treatment_plan" form:"treatment_plan"`
+	Doctor                       int64   `gorm:"column:doctor" json:"doctor" form:"doctor"`
 }
 
 func (XtPatientsNew) TableName() string {

models/schedule_models.go

 }
 
 type VmBloodSchedule struct {
-	ID               int64                      `gorm:"column:id" json:"id" form:"id"`
-	UserOrgId        int64                      `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	PartitionId      int64                      `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
-	BedId            int64                      `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
-	PatientId        int64                      `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
-	ScheduleDate     int64                      `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
-	ScheduleType     int64                      `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
-	ScheduleWeek     int64                      `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
-	ModeId           int64                      `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
-	Status           int64                      `gorm:"column:status" json:"status" form:"status"`
-	CreatedTime      int64                      `gorm:"column:created_time" json:"created_time" form:"created_time"`
-	UpdatedTime      int64                      `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
-	IsExport         int64                      `gorm:"column:is_export" json:"is_export" form:"is_export"`
-	DeviceNumber     *NewMDeviceNumberVM        `gorm:"ForeignKey:BedId" json:"device_number"`
-	SchedualPatient  *NewMSchedualPatientVMList `gorm:"ForeignKey:PatientId" json:"patient"`
-	DialysisSolution DialysisSolution           `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"dialysis_solution"`
+	ID                         int64                      `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                  int64                      `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId                int64                      `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId                      int64                      `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId                  int64                      `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate               int64                      `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType               int64                      `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek               int64                      `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId                     int64                      `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Status                     int64                      `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime                int64                      `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime                int64                      `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	IsExport                   int64                      `gorm:"column:is_export" json:"is_export" form:"is_export"`
+	DeviceNumber               *NewMDeviceNumberVM        `gorm:"ForeignKey:BedId" json:"device_number"`
+	SchedualPatient            *NewMSchedualPatientVMList `gorm:"ForeignKey:PatientId" json:"patient"`
+	DialysisSolution           DialysisSolution           `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"dialysis_solution"`
+	DialysisPrescription       DialysisPrescription       `gorm:"ForeignKey:PatientId,RecordDate;AssociationForeignKey:PatientId,ScheduleDate" json:"dialysis_prescription"`
+	XtAssessmentBeforeDislysis XtAssessmentBeforeDislysis `gorm:"ForeignKey:PatientId,AssessmentDate;AssociationForeignKey:PatientId,ScheduleDate" json:"assessment_befor_dislysis"`
+	XtDoctorAdvice             XtDoctorAdvice             `gorm:"ForeignKey:PatientId,AdviceDate;AssociationForeignKey:PatientId,ScheduleDate" json:"xt_doctor_advice"`
+	HisDoctorAdvice            HisDoctorAdvice            `gorm:"ForeignKey:PatientId,AdviceDate;AssociationForeignKey:PatientId,ScheduleDate" json:"his_doctor_advice"`
+	ReceiveTreatmentAsses      ReceiveTreatmentAsses      `gorm:"ForeignKey:PatientId,RecordDate;AssociationForeignKey:PatientId,ScheduleDate" json:"xt_receive_treatment_asses"`
+	XtAssessmentAfterDislysis  XtAssessmentAfterDislysis  `gorm:"ForeignKey:PatientId,AssessmentDate;AssociationForeignKey:PatientId,ScheduleDate" json:"xt_assesment_after_dislysis"`
+	LastAfterWeight            AssessmentAfterDislysis    `gorm:"ForeignKey:PatientID;AssociationForeignKey:PatientID" json:"lastafterweight"`
 }
 
 func (VmBloodSchedule) TableName() string {
 	IdCardNo           string `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
 	UserSysBeforeCount int64  `gorm:"column:user_sys_before_count" json:"user_sys_before_count" form:"user_sys_before_count"`
 	TrobleShoot        int64  `gorm:"column:troble_shoot" json:"troble_shoot" form:"troble_shoot"`
+	Status             int64  `gorm:"column:status" json:"status" form:"status"`
 }
 
 func (NewMSchedualPatientVMList) TableName() string {
 	return "xt_patients"
 }
+
+type VmBloodScheduleTwo struct {
+	ID                         int64                      `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                  int64                      `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId                int64                      `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId                      int64                      `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId                  int64                      `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate               int64                      `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType               int64                      `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek               int64                      `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId                     int64                      `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Status                     int64                      `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime                int64                      `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime                int64                      `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	IsExport                   int64                      `gorm:"column:is_export" json:"is_export" form:"is_export"`
+	DeviceNumber               *NewMDeviceNumberVM        `gorm:"ForeignKey:BedId" json:"device_number"`
+	SchedualPatient            *NewMSchedualPatientVMList `gorm:"ForeignKey:PatientId" json:"patient"`
+	HisPrescriptionTemplateSix HisPrescriptionTemplateSix `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"his_prescription_template"`
+}
+
+func (VmBloodScheduleTwo) TableName() string {
+	return "xt_schedule"
+}
+
+type HisPrescriptionTemplateSix struct {
+	ID                             int64                             `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                      int64                             `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PatientId                      int64                             `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	Type                           int64                             `gorm:"column:type" json:"type" form:"type"`
+	Status                         int64                             `gorm:"column:status" json:"status" form:"status"`
+	Ctime                          int64                             `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                          int64                             `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Name                           string                            `gorm:"column:name" json:"name" form:"name"`
+	Mode                           int64                             `gorm:"column:mode" json:"mode" form:"mode"`
+	HisPrescriptionInfoTemplateSix []*HisPrescriptionInfoTemplateSix `gorm:"ForeignKey:PTemplateId;AssociationForeignKey:ID" json:"his_prescription_info"`
+}
+
+func (HisPrescriptionTemplateSix) TableName() string {
+	return "his_prescription_template"
+}
+
+type HisPrescriptionInfoTemplateSix struct {
+	ID                                  int64                                  `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                           int64                                  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	RecordDate                          int64                                  `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	PatientId                           int64                                  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	Status                              int64                                  `gorm:"column:status" json:"status" form:"status"`
+	Ctime                               int64                                  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                               int64                                  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Type                                int64                                  `gorm:"column:type" json:"type" form:"type"`
+	Creator                             int64                                  `gorm:"column:creator" json:"creator" form:"creator"`
+	Modifier                            int64                                  `gorm:"column:modifier" json:"modifier" form:"modifier"`
+	PType                               int64                                  `gorm:"column:p_type" json:"p_type" form:"p_type"`
+	PTemplateId                         int64                                  `gorm:"column:p_template_id" json:"p_template_id" form:"p_template_id"`
+	HisPrescriptionProjectTemplateSeven []*HisPrescriptionProjectTemplateSeven `gorm:"ForeignKey:PrescriptionId;AssociationForeignKey:ID" json:"project"`
+	MedType                             string                                 `gorm:"column:med_type" json:"med_type" form:"med_type"`
+}
+
+func (HisPrescriptionInfoTemplateSix) TableName() string {
+	return "his_prescription_info_template"
+}
+
+type HisPrescriptionProjectTemplateSeven struct {
+	ID                 int64         `gorm:"column:id" json:"id" form:"id"`
+	ProjectId          int64         `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	Price              float64       `gorm:"column:price" json:"price" form:"price"`
+	UserOrgId          int64         `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	Status             int64         `gorm:"column:status" json:"status" form:"status"`
+	Ctime              int64         `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime              int64         `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	PatientId          int64         `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	HisPatientId       int64         `gorm:"column:his_patient_id" json:"his_patient_id" form:"his_patient_id"`
+	RecordDate         int64         `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	Count              string        `gorm:"column:count" json:"count" form:"count"`
+	FeedetlSn          string        `gorm:"column:feedetl_sn" json:"feedetl_sn" form:"feedetl_sn"`
+	MedListCodg        string        `gorm:"column:med_list_codg" json:"med_list_codg" form:"med_list_codg"`
+	SingleDose         string        `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	DeliveryWay        string        `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency string        `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	Day                string        `gorm:"column:day" json:"day" form:"day"`
+	Remark             string        `gorm:"column:remark" json:"remark" form:"remark"`
+	Unit               string        `gorm:"column:unit" json:"unit" form:"unit"`
+	Type               int64         `gorm:"column:type" json:"type" form:"type"`
+	PrescriptionId     int64         `gorm:"column:prescription_id" json:"prescription_id" form:"prescription_id"`
+	GoodInfo           GoodInfoNight `gorm:"ForeignKey:ID;AssociationForeignKey:ProjectId" json:"good_info"`
+	FrequencyType      int64         `gorm:"column:frequency_type" json:"frequency_type" form:"frequency_type"`
+	DayCount           int64         `gorm:"column:day_count" json:"day_count" form:"day_count"`
+	WeekDay            string        `gorm:"column:week_day" json:"week_day" form:"week_day"`
+}
+
+func (HisPrescriptionProjectTemplateSeven) TableName() string {
+	return "his_prescription_project_template"
+}
+
+type GoodInfoNight struct {
+	ID                int64  `gorm:"column:id" json:"id" form:"id"`
+	GoodName          string `gorm:"column:good_name" json:"good_name" form:"good_name"`
+	SpecificationName string `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	GoodTypeId        int64  `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
+}
+
+func (GoodInfoNight) TableName() string {
+	return "xt_good_information"
+}

service/device_service.go

 	return devicenumber, err
 }
 
+func GetAllBedNumberTen(orgId int64, zone_id int64) (devicenumber []*models.ScheduleDeviceNumber, err error) {
+
+	err = XTReadDB().Where("org_id = ? and status = 1 and zone_id = ?", orgId, zone_id).Find(&devicenumber).Error
+	return devicenumber, err
+}
+
 func GetAllBedNumberSeven(orgId int64) (devicenumber []*models.SgjDeviceNumber, err error) {
 
 	err = XTReadDB().Where("org_id = ? and status= 1", orgId).Preload("Zone", "status = 1").Find(&devicenumber).Error
 	return devicenumber, err
 }
+
+func ChangeScheduleById(id int64, mode_id int64) error {
+
+	err := XTWriteDB().Model(&models.XtSchedule{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"mode_id": mode_id}).Error
+	fmt.Println("err233322323232232323", err)
+	return err
+}
+
+func ChangeDialysisSolution(patient_id int64, schedule_date int64, org_id int64, mode_id int64) error {
+
+	err := XTWriteDB().Model(&models.DialysisPrescription{}).Where("patient_id = ? and record_date =? and user_org_id = ? and status = 1", patient_id, schedule_date, org_id).Update(map[string]interface{}{"mode_id": mode_id}).Error
+	return err
+
+}
+
+func GetScheduleByClassType(schedule_type int64, schedule_date int64, bed_id int64, user_org_id int64) (models.XtSchedule, error) {
+	schedule := models.XtSchedule{}
+	err := XTReadDB().Where("schedule_type = ? and schedule_date = ? and bed_id = ? and user_org_id = ? and status = 1", schedule_type, schedule_date, bed_id, user_org_id).Find(&schedule).Error
+	return schedule, err
+}
+
+func GetPartionId(bed_id int64, org_id int64) (models.XtDeviceNumber, error) {
+
+	number := models.XtDeviceNumber{}
+	err = XTReadDB().Where("id = ? and status = 1 and org_id = ?", bed_id, org_id).Find(&number).Error
+	return number, err
+}
+
+func UpdateScheduleById(id int64, schedule models.Schedule) error {
+
+	err := XTWriteDB().Model(&models.Schedule{}).Where("id = ? and status =1", id).Update(map[string]interface{}{"patient_id": schedule.PatientId, "mode_id": schedule.ModeId}).Error
+	return err
+}

service/dialysis_service.go

 	return nil
 }
 
-func ModifyDialysisRecord(id int64, finishNurse int64, end_time int64, admin_user_id int64, puncture_point_haematoma int64, internal_fistula string, catheter string, cruor string) error {
-	err := writeDb.Model(&models.DialysisOrder{}).Where("id = ? AND status = 1 ", id).Updates(map[string]interface{}{"updated_time": time.Now().Unix(), "stage": 2, "finish_nurse": finishNurse, "end_time": end_time, "finish_creator": admin_user_id, "finish_modifier": admin_user_id, "puncture_point_haematoma": puncture_point_haematoma, "blood_access_internal_fistula": internal_fistula, "catheter": catheter, "cruor": cruor}).Error
+func ModifyDialysisRecord(id int64, finishNurse int64, end_time int64, admin_user_id int64, puncture_point_haematoma int64, internal_fistula string, catheter string, cruor string, mission string) error {
+	err := writeDb.Model(&models.DialysisOrder{}).Where("id = ? AND status = 1 ", id).Updates(map[string]interface{}{"updated_time": time.Now().Unix(), "stage": 2, "finish_nurse": finishNurse, "end_time": end_time, "finish_creator": admin_user_id, "finish_modifier": admin_user_id, "puncture_point_haematoma": puncture_point_haematoma, "blood_access_internal_fistula": internal_fistula, "catheter": catheter, "cruor": cruor, "mission": mission}).Error
 	return err
 
 }
 	db := readDb.Table("xt_dialysis_order as o").Where("o.status = 1")
 	table := readDb.Table("xt_device_number as n")
 	fmt.Print("table", table)
-	err := db.Select("o.id,o.dialysis_date,o.user_org_id,o.patient_id,o.prescription_id,o.stage,remark,o.bed_id,o.start_nurse,o.finish_nurse,o.status,o.created_time,o.updated_time,o.start_time,o.end_time,o.puncture_nurse,o.creator,o.modifier,o.finish_creator,o.finish_modifier,o.schedual_type,n.number,r.user_name").Joins("left join xt_device_number as n on n.id = o.bed_id").Joins("left join sgj_users.sgj_user_admin_role  as r on r.admin_user_id = o.start_nurse").Where("o.user_org_id = ? and o.patient_id = ? and o.dialysis_date =?", orgid, patientid, dialysisDate).Scan(&orders).Error
+	err := db.Select("o.id,o.dialysis_date,o.user_org_id,o.patient_id,o.prescription_id,o.stage,remark,o.bed_id,o.start_nurse,o.finish_nurse,o.status,o.created_time,o.updated_time,o.start_time,o.end_time,o.puncture_nurse,o.creator,o.modifier,o.finish_creator,o.finish_modifier,o.schedual_type,o.quality_nurse_id,n.number,r.user_name").Joins("left join xt_device_number as n on n.id = o.bed_id").Joins("left join sgj_users.sgj_user_admin_role  as r on r.admin_user_id = o.start_nurse").Where("o.user_org_id = ? and o.patient_id = ? and o.dialysis_date =?", orgid, patientid, dialysisDate).Scan(&orders).Error
 	return orders, err
 }
 func FindPunctureNurse(adminid int64, appid int64, orgid int64) (models.App_Roles, error) {
 	return role, err
 }
 
+func FindeQualityNurse(adminid int64, appid int64, orgid int64) (models.App_Roles, error) {
+	role := models.App_Roles{}
+	db := UserReadDB().Table("sgj_user_admin_role as r").Where("r.status = 1")
+	err := db.Select("r.id,r.admin_user_id,r.org_id,r.role_id,r.user_name,r.avatar,r.user_type,r.user_title,r.intro,r.status,r.ctime,e.url").Joins("left join sgj_user_admin_electronic_signature as e on e.creator = r.admin_user_id").Where("r.admin_user_id = ? and r.app_id = ? and r.org_id = ?", adminid, appid, orgid).Find(&role).Error
+	return role, err
+}
+
 func FindDialysisWay(orgid int64, patientid int64, recorddate int64) (models.DialysisPrescription, error) {
 	prescription := models.DialysisPrescription{}
 	err := readDb.Where("user_org_id = ? and patient_id = ? and record_date = ? and status =1", orgid, patientid, recorddate).Find(&prescription).Error
 }
 
 func FindAllHisProjectById(orgID int64, patient_id int64, record_time int64) (advice []*models.HisPrescriptionProject, err error) {
-	err = readDb.Model(&models.HisPrescriptionProject{}).Preload("HisProject", "status = 1").Preload("GoodInfo", "status = 1").Where("user_org_id=? and status=1 and patient_id = ? AND record_date = ?", orgID, patient_id, record_time).Find(&advice).Error
+	err = readDb.Model(&models.HisPrescriptionProject{}).Preload("HisProject", "status = 1 and user_org_id = ?", orgID).Preload("GoodInfo", "status = 1 and org_id = ?", orgID).Where("user_org_id=? and status=1 and patient_id = ? AND record_date = ?", orgID, patient_id, record_time).Find(&advice).Error
 	return
 }
 
 	err := XTReadDB().Where("patient_id=? and dialysis_date = ? and user_org_id = ? and status = 1", patient_id, dialysis_date, orgid).Find(&order).Error
 	return order, err
 }
+
+func GetScheduleByPatient(patient_id int64, schedule_date int64, orgid int64) (models.XtScheduleSix, error) {
+
+	schedule := models.XtScheduleSix{}
+	err := XTReadDB().Where("patient_id = ? and schedule_date = ? and user_org_id = ? and status = 1", patient_id, schedule_date, orgid).Find(&schedule).Error
+	return schedule, err
+}
+
+func GetSchedulePrintList(page int64, limit int64, schedulType int64, partitionType int64, keywords string, schedule_date int64, orgID int64) (list []*models.DialysisScheduleSix, total int64, err error) {
+
+	db := XTReadDB().Table("xt_schedule as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_patients as p").Where("p.status = 1")
+	fmt.Println("table", table)
+	if schedulType > 0 {
+		db = db.Where("x.schedule_type = ?", schedulType)
+	}
+	if partitionType > 0 {
+		db = db.Where("x.partition_id = ?", partitionType)
+	}
+	if orgID > 0 {
+		db = db.Where("x.user_org_id = ?", orgID)
+	}
+	if schedule_date > 0 {
+		db = db.Where("x.schedule_date = ?", schedule_date)
+	}
+	db = db.Joins("left join xt_patients as p on p.id = x.patient_id")
+	likeKey := "%" + keywords + "%"
+	if len(keywords) > 0 {
+		db = db.Where("p.name like ?", likeKey)
+	}
+	err = db.Count(&total).Select("x.user_org_id,x.partition_id,x.bed_id,x.patient_id,x.schedule_date,x.schedule_type,x.schedule_week,x.mode_id,x.status,p.name").Offset(limit * (page - 1)).Limit(limit).Order("x.schedule_date desc").Find(&list).Error
+
+	return list, total, err
+}
+
+func GetSchedulePrintListOne(page int64, limit int64, schedulType int64, partitionType int64, keywords string, schedule_date int64, orgID int64) (list []*models.DialysisScheduleSeven, err error) {
+
+	db := XTReadDB().Model(&list).Where("status = 1")
+	if orgID > 0 {
+		db = db.Where("user_org_id = ?", orgID)
+	}
+	if schedulType > 0 {
+		db = db.Where("schedule_type = ?", schedulType)
+	}
+	if partitionType > 0 {
+		db = db.Where("partition_id = ?", partitionType)
+	}
+	err = db.Group("schedule_type,partition_id").Find(&list).Error
+	return list, err
+}
+
+func GetDialysisRecordOrder(org_id int64, patient_id int64, dialysis_date int64) (models.MDialysisOrderForListSix, error) {
+
+	order := models.MDialysisOrderForListSix{}
+	err := XTReadDB().Where("user_org_id = ? and patient_id = ? and dialysis_date = ? and status =1 ", org_id, patient_id, dialysis_date).Find(&order).Error
+	return order, err
+}

service/dialysis_solution_service.go

 
 import (
 	"XT_New/models"
+	"fmt"
+	"github.com/jinzhu/gorm"
 )
 
 func GetPatientSolutionGroupList(patient_id int64, orgid int64) (solution []*models.DialysisSolution, err error) {
 
 func GetPatientDialysisSolutionGroupList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64) (schedule []*models.VmBloodSchedule, total int64, err error) {
 
-	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("xt_schedule.status = 1")
 	offset := (page - 1) * limit
 	if scheduleDate > 0 {
-		db = db.Where("schedule_date = ?", scheduleDate)
+		db = db.Where("xt_schedule.schedule_date = ?", scheduleDate)
 	}
 	if schedule_type > 0 {
-		db = db.Where("schedule_type = ?", schedule_type)
+		db = db.Where("xt_schedule.schedule_type = ?", schedule_type)
 	}
 	if partition_id > 0 {
-		db = db.Where("partition_id = ?", partition_id)
+		db = db.Where("xt_schedule.partition_id = ?", partition_id)
 	}
 	if orgID > 0 {
-		db = db.Where("user_org_id  = ?", orgID)
+		db = db.Where("xt_schedule.user_org_id  = ?", orgID)
 	}
 
 	if len(keywords) > 0 {
 		keywords = "%" + keywords + "%"
-		db = db.Joins("JOIN xt_patients AS patient ON patient.id=xt_schedule.patient_id AND patient.status = 1 AND patient.user_org_id = ? AND patient.name Like ?", orgID, keywords)
-		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+		db = db.Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
 			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
 			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
-			Preload("DialysisSolution", "status = 1 AND user_org_id = ? and solution_status = 1", orgID).Find(&schedule).Error
+			Preload("DialysisSolution", "status = 1 AND user_org_id = ? and solution_status = 1", orgID)
+		db = db.Joins("JOIN xt_patients AS patient ON patient.id=xt_schedule.patient_id AND patient.status = 1 AND patient.user_org_id = ? AND patient.name Like ?", orgID, keywords)
+		err = db.Count(&total).Offset(offset).Limit(limit).Find(&schedule).Error
 	} else {
 		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
 			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
 	return schedule, total, err
 }
 
-func GetDialysisAdviceTemplateList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64) (schedule []*models.VmBloodSchedule, total int64, err error) {
-	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+func GetDialysisAdviceTemplateList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64, idArray []string) (schedule []*models.VmBloodSchedule, total int64, err error) {
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("xt_schedule.status = 1")
 	offset := (page - 1) * limit
 	if scheduleDate > 0 {
-		db = db.Where("schedule_date = ?", scheduleDate)
+		db = db.Where("xt_schedule.schedule_date = ?", scheduleDate)
 	}
 	if schedule_type > 0 {
-		db = db.Where("schedule_type = ?", schedule_type)
+		db = db.Where("xt_schedule.schedule_type = ?", schedule_type)
 	}
 	if partition_id > 0 {
-		db = db.Where("partition_id = ?", partition_id)
+		db = db.Where("xt_schedule.partition_id = ?", partition_id)
 	}
 	if orgID > 0 {
-		db = db.Where("user_org_id  = ?", orgID)
+		db = db.Where("xt_schedule.user_org_id  = ?", orgID)
+	}
+	fmt.Println("idArray23233223323232233232", len(idArray))
+	if len(idArray) > 1 {
+		db = db.Where("xt_schedule.id in(?)", idArray)
 	}
 
 	if len(keywords) > 0 {
 	err := XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&setting).Error
 	return setting, err
 }
+
+func GetDialysisParameterList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64) (schedule []*models.VmBloodSchedule, total int64, err error) {
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("xt_schedule.status = 1")
+	offset := (page - 1) * limit
+	if scheduleDate > 0 {
+		db = db.Where("xt_schedule.schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("xt_schedule.schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("xt_schedule.partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("xt_schedule.user_org_id  = ?", orgID)
+	}
+
+	if len(keywords) > 0 {
+		keywords = "%" + keywords + "%"
+		db = db.Joins("JOIN xt_patients AS patient ON patient.id=xt_schedule.patient_id AND patient.status = 1 AND patient.user_org_id = ? AND patient.name Like ?", orgID, keywords)
+		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DialysisSolution", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DialysisPrescription", "status = 1 AND user_org_id = ? and record_date = ?", orgID, scheduleDate).
+			Preload("XtAssessmentBeforeDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
+			Preload("ReceiveTreatmentAsses", "status = 1 AND user_org_id = ? and record_date = ?", orgID, scheduleDate).
+			Preload("XtAssessmentAfterDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
+			Preload("LastAfterWeight", func(db *gorm.DB) *gorm.DB {
+				return db.Where("user_org_id = ? and status = 1 and assessment_date < ?", orgID, scheduleDate)
+			}).
+			Preload("XtDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ? and advice_type = 1", orgID, scheduleDate).
+			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).Find(&schedule).Error
+	} else {
+		err = db.Count(&total).Offset(offset).Limit(limit).Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DialysisSolution", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DialysisPrescription", "status = 1 AND user_org_id = ? and record_date = ?", orgID, scheduleDate).
+			Preload("XtAssessmentBeforeDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
+			Preload("ReceiveTreatmentAsses", "status = 1 AND user_org_id = ? and record_date = ?", orgID, scheduleDate).
+			Preload("XtAssessmentAfterDislysis", "status = 1 AND user_org_id = ? and assessment_date = ?", orgID, scheduleDate).
+			Preload("XtDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ? and advice_type = 1", orgID, scheduleDate).
+			Preload("LastAfterWeight", func(db *gorm.DB) *gorm.DB {
+				return db.Where("user_org_id = ? and status = 1 and assessment_date < ?", orgID, scheduleDate)
+			}).Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).Find(&schedule).Error
+	}
+
+	return schedule, total, err
+}
+
+func GetDialysisGoodTotalCount(orgID int64, schedule_type int64, partition_id int64, scheduleDate int64) (schedule []*models.VmBloodSchedule, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+
+	if scheduleDate > 0 {
+		db = db.Where("schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("user_org_id  = ?", orgID)
+	}
+	err = db.Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+		Preload("DialysisPrescription", "status = 1 AND user_org_id = ? and record_date = ?", orgID, scheduleDate).
+		Preload("DialysisSolution", "status = 1 AND user_org_id = ? AND solution_status = 1", orgID).
+		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).Find(&schedule).Error
+
+	return schedule, err
+
+}
+
+func GetDialysisAdviceSchedulist(orgID int64, schedule_type int64, partition_id int64, scheduleDate int64) (schedule []*models.VmBloodSchedule, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+
+	if scheduleDate > 0 {
+		db = db.Where("schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("user_org_id  = ?", orgID)
+	}
+	err = db.Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+		Preload("XtDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ?", orgID, scheduleDate).
+		Preload("HisDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ?", orgID, scheduleDate).
+		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).Find(&schedule).Error
+
+	return schedule, err
+
+}
+
+func GetAllDrugMap(org_id int64) (list []*BaseDrugLib, err error) {
+
+	err = readDb.Model(&BaseDrugLib{}).Where("org_id = ?  AND status = 1", org_id).Find(&list).Error
+	return list, err
+}
+
+func GetDialysisParameterGoodList(orgID int64, schedule_type int64, partition_id int64, scheduleDate int64) (schedule []*models.VmBloodSchedule, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodSchedule{}).Where("status = 1")
+
+	if scheduleDate > 0 {
+		db = db.Where("schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("user_org_id  = ?", orgID)
+	}
+	err = db.Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+		Preload("DialysisPrescription", "status = 1 and user_org_id = ?", orgID).
+		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+		Preload("XtDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ?", orgID, scheduleDate).
+		Preload("HisDoctorAdvice", "status = 1 AND user_org_id = ? and advice_date = ?", orgID, scheduleDate).
+		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).Find(&schedule).Error
+
+	return schedule, err
+}
+
+func SaveHisDialysis(orgid int64, ids []string) error {
+
+	goodsType := models.BloodGoodsType{}
+	err := XTWriteDB().Model(&goodsType).Where("org_id = ? and status = 1 and id in(?)", orgid, ids).Update(map[string]interface{}{"is_open": 1}).Error
+
+	err = XTWriteDB().Model(&goodsType).Where("org_id = ? and status = 1 and id not in(?)", orgid, ids).Update(map[string]interface{}{"is_open": 0}).Error
+	return err
+}
+
+func GetHisPatientDialysisSolutionGroupList(keywords string, limit int64, page int64, partition_id int64, schedule_type int64, scheduleDate int64, orgID int64) (schedule []*models.VmBloodScheduleTwo, total int64, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodScheduleTwo{}).Where("xt_schedule.status = 1")
+	offset := (page - 1) * limit
+	if scheduleDate > 0 {
+		db = db.Where("xt_schedule.schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("xt_schedule.schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("xt_schedule.partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("xt_schedule.user_org_id  = ?", orgID)
+	}
+
+	if len(keywords) > 0 {
+		keywords = "%" + keywords + "%"
+		db = db.Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
+			Preload("HisPrescriptionTemplateSix", func(db *gorm.DB) *gorm.DB {
+				return db.Where("user_org_id = ? and status = 1", orgID).Preload("HisPrescriptionInfoTemplateSix", func(db *gorm.DB) *gorm.DB {
+					return db.Where("user_org_id = ? and status = 1 and type = 2", orgID).Preload("HisPrescriptionProjectTemplateSeven", func(db *gorm.DB) *gorm.DB {
+						return db.Where("user_org_id = ? and status = 1 and type = 3", orgID).Preload("GoodInfo", "org_id =? and status = 1", orgID)
+					})
+				})
+			})
+		db = db.Joins("JOIN xt_patients AS patient ON patient.id=xt_schedule.patient_id AND patient.status = 1 AND patient.user_org_id = ? AND patient.name Like ?", orgID, keywords)
+		err = db.Count(&total).Offset(offset).Limit(limit).Find(&schedule).Error
+	} else {
+		err = db.Count(&total).Offset(offset).Limit(limit).
+			Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+			Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+			Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
+			Preload("HisPrescriptionTemplateSix", func(db *gorm.DB) *gorm.DB {
+				return db.Where("user_org_id = ? and status = 1", orgID).Preload("HisPrescriptionInfoTemplateSix", func(db *gorm.DB) *gorm.DB {
+					return db.Where("user_org_id = ? and status = 1 and type = 2", orgID).Preload("HisPrescriptionProjectTemplateSeven", func(db *gorm.DB) *gorm.DB {
+						return db.Where("user_org_id = ? and status = 1 and type = 3", orgID).Preload("GoodInfo", "org_id =? and status = 1", orgID)
+					})
+				})
+			}).Find(&schedule).Error
+	}
+
+	return schedule, total, err
+}
+
+func GetHisDialysisGoodCount(orgID int64, schedule_type int64, partition_id int64, scheduleDate int64) (schedule []*models.VmBloodScheduleTwo, err error) {
+
+	db := XTReadDB().Model(&models.VmBloodScheduleTwo{}).Where("xt_schedule.status = 1")
+	if scheduleDate > 0 {
+		db = db.Where("xt_schedule.schedule_date = ?", scheduleDate)
+	}
+	if schedule_type > 0 {
+		db = db.Where("xt_schedule.schedule_type = ?", schedule_type)
+	}
+	if partition_id > 0 {
+		db = db.Where("xt_schedule.partition_id = ?", partition_id)
+	}
+	if orgID > 0 {
+		db = db.Where("xt_schedule.user_org_id  = ?", orgID)
+	}
+
+	err = db.
+		Preload("SchedualPatient", "status = 1 AND user_org_id = ?", orgID).
+		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
+		Preload("DeviceNumber.Zone", "status = 1 AND org_id = ?", orgID).
+		Preload("HisPrescriptionTemplateSix", func(db *gorm.DB) *gorm.DB {
+			return db.Where("user_org_id = ? and status = 1", orgID).Preload("HisPrescriptionInfoTemplateSix", func(db *gorm.DB) *gorm.DB {
+				return db.Where("user_org_id = ? and status = 1 and type = 2", orgID).Preload("HisPrescriptionProjectTemplateSeven", func(db *gorm.DB) *gorm.DB {
+					return db.Where("user_org_id = ? and status = 1 and type = 3", orgID).Preload("GoodInfo", "org_id =? and status = 1", orgID)
+				})
+			})
+		}).Find(&schedule).Error
+
+	return schedule, err
+}

service/gobal_config_service.go

 	dbTwo := XTReadDB().Table("xt_drug_warehouse_out as t").Where("t.status = 1")
 	fmt.Print(dbOne, dbTwo)
 	if startime > 0 {
-		db = db.Where("x.ctime >=?", startime)
+		db = db.Where("x.sys_record_time >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("x.ctime <=?", endtime)
+		db = db.Where("x.sys_record_time <=?", endtime)
 	}
 
 	if orgid > 0 {
 	err = XTReadDB().Where("warehouse_out_id = ? and drug_id = ? and user_org_id = ? and status = 1", ware_out_id, drug_id, orgid).Find(&flow).Error
 	return flow, err
 }
+
+func GetDrugWarehouseOutInfoFlow(drug_id int64, start_time int64, end_time int64, user_org_id int64) (info []*models.XtDrugWarehouseOutInfo, err error) {
+
+	db := XTReadDB().Model(&info).Where("status = 1")
+	if start_time > 0 {
+		db = db.Where("sys_record_time >=?", start_time)
+	}
+	if end_time > 0 {
+		db = db.Where("sys_record_time <=?", end_time)
+	}
+	if user_org_id > 0 {
+		db = db.Where("user_org_id = ?", user_org_id)
+	}
+	err = db.Find(&info).Error
+	return info, err
+}

service/his_project_service.go

 
 func GetHisProject(orgid int64) (project []*models.XtHisProject, err error) {
 
-	err = XTReadDB().Model(&project).Where("user_org_id = ? and status =1", orgid).Find(&project).Error
+	err = XTReadDB().Model(&project).Where("user_org_id = ? and status =1 and medical_status!=1", orgid).Find(&project).Error
 	return project, err
 }
 

service/his_service.go

 	err = readDb.Model(&models.HisOrder{}).Where("id = ?", order_id).First(&order).Error
 	return
 }
+
+func GetHisPrescriptonProjectById(id int64) (models.HisPrescriptionProject, error) {
+
+	project := models.HisPrescriptionProject{}
+
+	err := XTReadDB().Where("id = ? and status = 1", id).Find(&project).Error
+	return project, err
+}

service/manage_center_service.go

 
 import (
 	"XT_New/models"
-	"fmt"
 	"github.com/jinzhu/gorm"
 	"strconv"
 	"strings"
 
 			if (over_count + out_count) <= sum_count {
 				if its.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
-					fmt.Println("进来1", its.Count)
+
 					//退库
 					warehouseInfo := models.DrugWarehouseInfo{
 						StockMinNumber: its.Count,
 
 				}
 				if its.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
-					fmt.Println("进来2", its.Count)
+
 					warehouseInfo := models.DrugWarehouseInfo{
 						StockMaxNumber: its.Count,
 					}
 				}
 
 				if its.CountUnit == drug.MaxUnit && drug.MaxUnit == drug.MinUnit {
-					fmt.Println("进来3", its.Count)
+
 					warehouseInfo := models.DrugWarehouseInfo{
 						StockMaxNumber: its.Count,
 					}
 				IsCheck:          1,
 			}
 
+			//查询剩余库存
+			stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
+			var sum_count int64
+			for _, its := range stockInfo {
+				if its.MaxUnit == drug.MaxUnit {
+					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
+				}
+				sum_count += its.StockMaxNumber + its.StockMinNumber
+			}
 			flow := models.DrugFlow{
 				WarehousingId:           info.WarehouseInfoId,
 				DrugId:                  info.DrugId,
 				MinUnit:                 "",
 				AdviceId:                info.AdviceId,
 				StorehouseId:            storeHouseConfig.DrugStorehouseOut,
+				OverCount:               sum_count,
 			}
 			CreatedCancelStock(cancelStockInfo)
 			CreateDrugFlowOne(flow)
 				StorehouseId:     houseConfig.DrugStorehouseOut,
 				IsCheck:          1,
 			}
+			//查询剩余库存
+			stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
+			var sum_count int64
+			for _, its := range stockInfo {
+				if its.MaxUnit == drug.MaxUnit {
+					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
+				}
+				sum_count += its.StockMaxNumber + its.StockMinNumber
+			}
 
 			flow := models.DrugFlow{
 				WarehousingId:           info.WarehouseInfoId,
 				MinUnit:                 "",
 				AdviceId:                info.AdviceId,
 				StorehouseId:            houseConfig.DrugStorehouseOut,
+				OverCount:               sum_count,
 			}
 			CreatedCancelStock(cancelStockInfo)
 			CreateDrugFlowOne(flow)
 				StorehouseId:     houseConfig.DrugStorehouseOut,
 				IsCheck:          1,
 			}
+			//查询剩余库存
+			stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, advice.UserOrgId, advice.DrugId)
+			var sum_count int64
+			for _, its := range stockInfo {
+				if its.MaxUnit == drug.MaxUnit {
+					its.StockMaxNumber = its.StockMaxNumber * drug.MinNumber
+				}
+				sum_count += its.StockMaxNumber + its.StockMinNumber
+			}
 
 			flow := models.DrugFlow{
 				WarehousingId:           info.WarehouseInfoId,
 				MinUnit:                 "",
 				AdviceId:                info.AdviceId,
 				StorehouseId:            houseConfig.DrugStorehouseOut,
+				OverCount:               sum_count,
 			}
 			CreatedCancelStock(cancelStockInfo)
 			CreateDrugFlowOne(flow)
 		medical, _ := GetBaseDrugMedical(advice.DrugId)
 		var sum_count_one int64
 		for _, its := range stockInfo {
-			sum_count_one += its.StockMaxNumber*medical.MinNumber + its.StockMinNumber
+			if its.MaxUnit == medical.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * medical.MinNumber
+			}
+			sum_count_one += its.StockMaxNumber + its.StockMinNumber
 		}
 		UpdateBaseDrugSumTwo(advice.DrugId, sum_count_one, advice.UserOrgId)
 

service/mobile_dialysis_service.go

 	IdCardNo           string `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
 	UserSysBeforeCount int64  `gorm:"column:user_sys_before_count" json:"user_sys_before_count" form:"user_sys_before_count"`
 	TrobleShoot        int64  `gorm:"column:troble_shoot" json:"troble_shoot" form:"troble_shoot"`
+	SchRemark          string `gorm:"column:sch_remark" json:"sch_remark" form:"sch_remark"`
 }
 
 func (MSchedualPatientVMList) TableName() string {
 	// PrescriptionId int64  `gorm:"column:prescription_id" json:"prescription_id"`
 	Stage int64 `gorm:"column:stage" json:"stage"`
 	// Remark         string `gorm:"column:remark" json:"remark"`
-	BedID         int64            `gorm:"column:bed_id" json:"bed_id"`
-	StartNurse    int64            `gorm:"column:start_nurse" json:"start_nurse"`
-	Status        int64            `gorm:"column:status" json:"status"`
-	DeviceNumber  *MDeviceNumberVM `gorm:"ForeignKey:BedID" json:"device_number"`
-	Creator       int64            `gorm:"column:creator" json:"creator"`
-	WashpipeNurse int64            `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
+	BedID              int64            `gorm:"column:bed_id" json:"bed_id"`
+	StartNurse         int64            `gorm:"column:start_nurse" json:"start_nurse"`
+	Status             int64            `gorm:"column:status" json:"status"`
+	DeviceNumber       *MDeviceNumberVM `gorm:"ForeignKey:BedID" json:"device_number"`
+	Creator            int64            `gorm:"column:creator" json:"creator"`
+	WashpipeNurse      int64            `gorm:"column:washpipe_nurse" json:"washpipe_nurse" form:"washpipe_nurse"`
+	NucleinDate        int64            `gorm:"column:nuclein_date" json:"nuclein_date" form:"nuclein_date"`
+	DialysisIrrigation string           `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialysisDialyszers string           `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
 }
 
 func (MDialysisOrderVMList) TableName() string {
 func ModifyStartDialysisOrder(order *models.DialysisOrder) error {
 	tx := writeDb.Begin()
 	updateTime := time.Now().Unix()
-	err := tx.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND id = ? AND status = 1 ", order.UserOrgId, order.ID).Updates(map[string]interface{}{"start_nurse": order.StartNurse, "updated_time": updateTime, "bed_id": order.BedID, "puncture_nurse": order.PunctureNurse, "start_time": order.StartTime, "modifier": order.Modifier, "schedual_type": order.SchedualType, "washpipe_nurse": order.WashpipeNurse, "change_nurse": order.ChangeNurse, "difficult_puncture_nurse": order.DifficultPunctureNurse, "new_fistula_nurse": order.NewFistulaNurse}).Error
+	err := tx.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND id = ? AND status = 1 ", order.UserOrgId, order.ID).Updates(map[string]interface{}{"start_nurse": order.StartNurse, "updated_time": updateTime, "bed_id": order.BedID, "puncture_nurse": order.PunctureNurse, "start_time": order.StartTime, "modifier": order.Modifier, "schedual_type": order.SchedualType, "washpipe_nurse": order.WashpipeNurse, "change_nurse": order.ChangeNurse, "difficult_puncture_nurse": order.DifficultPunctureNurse, "new_fistula_nurse": order.NewFistulaNurse, "quality_nurse_id": order.QualityNurseId, "puncture_needle": order.PunctureNeedle, "puncture_way": order.PunctureWay, "dialysis_dialyszers": order.DialysisDialyszers, "dialysis_irrigation": order.DialysisIrrigation, "blood_access_id": order.BloodAccessId, "nuclein_date": order.NucleinDate}).Error
 	if err != nil {
 		tx.Rollback()
 		return err
 func ModifyFinishDialysisOrder(order *models.DialysisOrder) error {
 	tx := writeDb.Begin()
 	updateTime := time.Now().Unix()
-	err := tx.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND id = ? AND status = 1 ", order.UserOrgId, order.ID).Updates(map[string]interface{}{"finish_nurse": order.FinishNurse, "updated_time": updateTime, "end_time": order.EndTime, "finish_modifier": order.FinishModifier, "puncture_point_haematoma": order.PuncturePointHaematoma, "blood_access_internal_fistula": order.BloodAccessInternalFistula, "catheter": order.Catheter, "cruor": order.Cruor}).Error
+	err := tx.Model(&models.DialysisOrder{}).Where("user_org_id = ? AND id = ? AND status = 1 ", order.UserOrgId, order.ID).Updates(map[string]interface{}{"finish_nurse": order.FinishNurse, "updated_time": updateTime, "end_time": order.EndTime, "finish_modifier": order.FinishModifier, "puncture_point_haematoma": order.PuncturePointHaematoma, "blood_access_internal_fistula": order.BloodAccessInternalFistula, "catheter": order.Catheter, "cruor": order.Cruor, "mission": order.Mission}).Error
 	if err != nil {
 		tx.Rollback()
 		return err
 	err = readDb.Where("org_id = ? and patient_id = ? and sys_record_time = ? and status = 1", orgId, patient_id, sys_record_time).Find(&outifno).Error
 	return outifno, err
 }
+
+func GetLastDilysisOrder(orgid int64, patient_id int64, dialysis_date int64) (models.DialysisOrder, error) {
+
+	order := models.DialysisOrder{}
+
+	err = XTReadDB().Where("user_org_id = ? and patient_id = ? and dialysis_date < ? and status= 1", orgid, patient_id, dialysis_date).Last(&order).Error
+
+	return order, err
+}

service/new_stock_service.go

 	offset := (page - 1) * limit
 	likeKey := "%" + keyword + "%"
 
-	db := XTReadDB().Table("xt_good_information as x").Where("x.status = 1 and x.total_count > 0 and x.org_id =?", orgId)
+	db := XTReadDB().Table("xt_good_information as x").Where("x.status = 1  and x.org_id =?", orgId)
 
 	if good_type == 2 {
 		db = db.Where(" x.total_count<=x.stock_warn_count")
 	return &drugStockCount, nil
 }
 
+func GetDrugStockCountSix(storehouse_id int64, drug_id int64, org_id int64) (models.XtDrugStockCount, error) {
+
+	drugStockCount := models.XtDrugStockCount{}
+	err = XTReadDB().Where("storehouse_id = ? and drug_id = ? and user_org_id  = ? and status = 1", storehouse_id, drug_id, org_id).Find(&drugStockCount).Error
+	return drugStockCount, err
+}
+
 func CreateDrugStockSum(drug models.XtDrugStockCount) error {
 
 	ut := XTWriteDB().Begin()
 	db.Commit()
 	return err
 }
+
+func GetAutoGoodLastCount(goodid int64, count int64, record_time int64, patient_id int64) (models.AutomaticReduceDetail, error) {
+
+	detail := models.AutomaticReduceDetail{}
+	err := XTReadDB().Where("good_id = ? and count = ? and record_time = ? and patient_id = ?", goodid, count, record_time, patient_id).Last(&detail).Error
+	return detail, err
+}
+
+func UpdateLastAutoCount(id int64, count int64) error {
+
+	detail := models.AutomaticReduceDetail{}
+	err := XTWriteDB().Model(&detail).Where("id = ?", id).Update(map[string]interface{}{"count": count, "status": 1}).Error
+	return err
+}

service/new_warehouse_service.go

 //耗材出库
 func ConsumablesGoodDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) {
 
-	fmt.Println("出库数量2333333333333333333333333333333333hhha", goods.Count)
 	//开事务
 	var deliver_number int64 = 0
 	var stock_number int64 = 0
 		if errThree != nil {
 			return errThree
 		}
+		//更新his_prescripton_project出库状态值
+		UpdateHisPrescriptionProjectStatus(goods.GoodId, record_time, orgID, patient_id)
 
 		//查询剩余库存
 		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
 			StorehouseId:            goods.StorehouseId,
 			IsCheck:                 1,
 			OverCount:               sum_count,
+			RegisterNumber:          warehouse.RegisterNumber,
 		}
 		warehouseOutInfo.Count = count
-
+		if orgID == 9671 || orgID == 10265 {
+			goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+			warehouseOutInfo.Price = goodsInfo.PackingPrice
+		}
 		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
+		//fmt.Println("errcodes2333232233232wode3223", errcodes, goods.ProjectId)
 		if errcodes == gorm.ErrRecordNotFound {
 			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
 			if errOne != nil {
 		} else if errcodes == nil {
 
 			outInfoOne, _ := GetWarehouseOutInfoIsExistTwo(goods.GoodId, patient_id, record_time, goods.ProjectId)
-			fmt.Println("goods.cout23323233223232323w", count)
-			fmt.Println("outInfoOnewowowwowowowowowo", outInfoOne.Count)
+			//fmt.Println("goods.cout23323233223232323w", count)
+			//fmt.Println("outInfoOnewowowwowowowowowo", outInfoOne.Count)
 			if count != outInfoOne.Count {
 				UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
 			}
 		for _, item := range flowGoodTwo {
 			out_count_one += item.Count
 		}
-		fmt.Println("deliver_number", deliver_number)
-		fmt.Println("out_count", out_count)
-		fmt.Println("count", count)
-		fmt.Println("cancel_out_count2333233", out_count_one)
+		//fmt.Println("deliver_number", deliver_number)
+		//fmt.Println("out_count", out_count)
+		//fmt.Println("count", count)
+		//fmt.Println("cancel_out_count2333233", out_count_one)
 		//如果本次出库数据大于历史出库数据 新增1条流水
 		if count > (out_count - out_count_one) {
+
 			flow := models.VmStockFlow{
 				WarehouseOutId:          warehouseOut.ID,
 				WarehousingId:           warehouse.ID,
 				StorehouseId:            goods.StorehouseId,
 				OverCount:               sum_count,
 				BuyPrice:                warehouse.Price,
+				RegisterNumber:          warehouse.RegisterNumber,
+			}
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				flow.Price = goodsInfo.PackingPrice
+				flow.BuyPrice = goodsInfo.BuyPrice
 			}
 			errThre := CreateStockFlowOne(flow)
 			if errThre != nil {
 				StorehouseId:    goods.StorehouseId,
 				IsCheck:         1,
 			}
-
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				cancelStockInfo.Price = goodsInfo.PackingPrice
+			}
 			CreateCancelStockInfoOne(&cancelStockInfo)
 
 			cancelInfo, _ := GetLastCancelStockInfoByGoodId(goods.GoodId)
 				PatientId:               patient_id,
 				SystemTime:              record_time,
 				ConsumableType:          7,
-				IsSys:                   0,
+				IsSys:                   1,
 				WarehousingOrder:        "",
-				WarehouseOutId:          0,
-				WarehouseOutOrderNumber: "",
+				WarehouseOutId:          lastOut.WarehouseOutId,
+				WarehouseOutOrderNumber: lastOut.WarehouseOutOrderNumber,
 				IsEdit:                  0,
 				CancelStockId:           cancel.ID,
 				CancelOrderNumber:       cancel.OrderNumber,
 				StorehouseId:            goods.StorehouseId,
 				BuyPrice:                warehouse.Price,
 				ProjectId:               goods.ProjectId,
+				OverCount:               sum_count,
+				RegisterNumber:          warehouse.RegisterNumber,
+			}
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				flow.Price = goodsInfo.PackingPrice
+				flow.BuyPrice = goodsInfo.BuyPrice
 			}
 			CreateStockFlowOne(flow)
 		}
 			StorehouseId:            goods.StorehouseId,
 			IsCheck:                 1,
 			OverCount:               sum_count,
+			RegisterNumber:          warehouse.RegisterNumber,
 		}
 		warehouseOutInfo.Count = stock_number
-
-		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, goods.PatientId, record_time, goods.ProjectId)
-
+		if orgID == 9671 || orgID == 10265 {
+			goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+			warehouseOutInfo.Price = goodsInfo.PackingPrice
+		}
+		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
+		//fmt.Println("errcodes23332322332323223", errcodes, goods.ProjectId)
 		if errcodes == gorm.ErrRecordNotFound {
 			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
 			if errOne != nil {
 				StorehouseId:            goods.StorehouseId,
 				OverCount:               sum_count,
 				BuyPrice:                warehouse.Price,
+				RegisterNumber:          warehouse.RegisterNumber,
+			}
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				flow.Price = goodsInfo.PackingPrice
+				flow.BuyPrice = goodsInfo.BuyPrice
 			}
 			errThre := CreateStockFlowOne(flow)
 			if errThre != nil {
 				StorehouseId:    goods.StorehouseId,
 				IsCheck:         1,
 			}
-
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				cancelStockInfo.Price = goodsInfo.PackingPrice
+			}
 			CreateCancelStockInfoOne(&cancelStockInfo)
 
 			cancelInfo, _ := GetLastCancelStockInfoByGoodId(goods.GoodId)
 				PatientId:               patient_id,
 				SystemTime:              record_time,
 				ConsumableType:          7,
-				IsSys:                   0,
+				IsSys:                   1,
 				WarehousingOrder:        "",
-				WarehouseOutId:          0,
-				WarehouseOutOrderNumber: "",
+				WarehouseOutId:          lastOut.WarehouseOutId,
+				WarehouseOutOrderNumber: lastOut.WarehouseOutOrderNumber,
 				IsEdit:                  0,
 				CancelStockId:           cancel.ID,
 				CancelOrderNumber:       cancel.OrderNumber,
 				StorehouseId:            goods.StorehouseId,
 				BuyPrice:                warehouse.Price,
 				ProjectId:               goods.ProjectId,
+				OverCount:               sum_count,
+				RegisterNumber:          warehouse.RegisterNumber,
+			}
+			if orgID == 9671 || orgID == 10265 {
+				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
+				flow.Price = goodsInfo.PackingPrice
+				flow.BuyPrice = goodsInfo.BuyPrice
 			}
 			CreateStockFlowOne(flow)
 		}
 		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drup.MinNumber + its.StockMinNumber
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
 
 		warehouseOutInfo := &models.DrugWarehouseOutInfo{
 				PatientId:               advice.PatientId,
 				SystemTime:              advice.AdviceDate,
 				ConsumableType:          7,
-				IsSys:                   0,
+				IsSys:                   1,
 				WarehousingOrder:        "",
 				WarehouseOutId:          0,
 				WarehouseOutOrderNumber: "",
 		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drup.MinNumber + its.StockMinNumber
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
 
 		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
 				PatientId:               advice.PatientId,
 				SystemTime:              advice.AdviceDate,
 				ConsumableType:          7,
-				IsSys:                   0,
+				IsSys:                   1,
 				WarehousingOrder:        "",
 				WarehouseOutId:          0,
 				WarehouseOutOrderNumber: "",
 		return err
 	}
 	// 将该批次的剩余库存数量转换为拆零数量
-	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
+	// 将该批次的剩余库存数量转换为拆零数量
+	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
+		fmt.Println("进来1")
+		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
+		fmt.Println("剩余库存1", stock_number)
+	}
+	if warehouse.MaxUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
+		fmt.Println("进来2")
+		stock_number = warehouse.StockMaxNumber + warehouse.StockMinNumber
+		fmt.Println("剩余库存2", stock_number)
+	}
+	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit == drup.MinUnit {
+		fmt.Println("进来3")
+		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
+		fmt.Println("剩余库存3", stock_number)
+	}
+	fmt.Println("剩余库存23333333333333333333333333333wo", stock_number)
+	fmt.Println("出库数量2333333333333333333333333333333333333wo", deliver_number)
 
 	// 当库存数量大于或等于出库数量的话，则正常出库该批次
 	if stock_number >= deliver_number {
 			}
 		}
 
-		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		if drup.MinUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
+		}
+		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
+		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
 
 		if warehouse.StockMaxNumber < 0 {
 			warehouse.StockMaxNumber = 0
 
 		warehouse.Mtime = time.Now().Unix()
 
+		fmt.Println("minnU目标而332322323323233223323223我", minNumber)
+		fmt.Println("max_number232232332232322wo", maxNumber)
+		fmt.Println(" warehouse.StockMinNumber", warehouse.StockMinNumber)
 		if warehouse.StockMinNumber < minNumber {
 
 			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
 			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
 		} else {
 			if minNumber > 0 {
-				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
+				if (warehouse.StockMinNumber - minNumber) >= 0 {
+					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
+				}
+
 			}
 
 			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
 				if warehouse.StockMinNumber > 0 {
-					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+					if warehouse.StockMinNumber-deliver_number >= 0 {
+						warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+					}
+
 				}
 
 			}
 		}
 
 		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
-			if (warehouse.StockMinNumber - deliver_number) > 0 {
+			if (warehouse.StockMinNumber - deliver_number) >= 0 {
 				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
 			}
 
 		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drup.MinNumber + its.StockMinNumber
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
 
 		warehouseOutInfo := &models.DrugWarehouseOutInfo{
 				AdviceId:                advice.ID,
 				StorehouseId:            storeConfig.DrugStorehouseOut,
 				LastPrice:               warehouse.Price,
+				OverCount:               sum_count,
 			}
 			CreateDrugFlowOne(flow)
 			AddCancelSumCountOne(storeConfig.DrugStorehouseOut, advice.DrugId, advice.UserOrgId, flow.Count)
 		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
 		var sum_count int64
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drup.MinNumber + its.StockMinNumber
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
 
 		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
 				AdviceId:                advice.ID,
 				StorehouseId:            storeConfig.DrugStorehouseOut,
 				LastPrice:               warehouse.Price,
+				OverCount:               sum_count,
 			}
 			CreateDrugFlowOne(flow)
 
 
 func UpdateSingleDrugWarehouseOutInfoSix(patient_id int64, advice_date int64, orgid int64, info *models.DrugWarehouseOutInfo, advice_id int64) error {
 
-	err := XTWriteDB().Model(&models.XtDrugWarehouseOutInfo{}).Where("patient_id = ? and advice_date = ? and org_id = ? and advice_id = ?", patient_id, advice_date, orgid, advice_id).Update(map[string]interface{}{"count": info.Count, "price": info.Price, "total_price": info.TotalPrice, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "remark": info.Remark, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "retail_price": info.RetailPrice, "number": info.Number, "batch_number": info.BatchNumber, "count_unit": info.CountUnit, "warehouse_info_id": info.WarehouseInfoId, "storehouse_id": info.StorehouseId}).Error
+	err := XTWriteDB().Model(&models.XtDrugWarehouseOutInfo{}).Where("patient_id = ? and sys_record_time = ? and org_id = ? and advice_id = ?", patient_id, advice_date, orgid, advice_id).Update(map[string]interface{}{"count": info.Count, "price": info.Price, "total_price": info.TotalPrice, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "remark": info.Remark, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "retail_price": info.RetailPrice, "number": info.Number, "batch_number": info.BatchNumber, "count_unit": info.CountUnit, "warehouse_info_id": info.WarehouseInfoId, "storehouse_id": info.StorehouseId}).Error
 	return err
 }
 
 	err := XTWriteDB().Model(&models.DrugWarehouseOutInfo{}).Where("patient_id = ? and sys_record_time = ? and org_id = ? and status = 1", patient_id, advice_date, orgid).Update(map[string]interface{}{"count": info.Count, "count_unit": info.CountUnit}).Error
 	return err
 }
+
+func FindeGoodInfo(orgid int64, id int64) (models.GoodInformation, error) {
+
+	information := models.GoodInformation{}
+	err := XTReadDB().Where("org_id = ? and id = ? and status = 1", orgid, id).Find(&information).Error
+	return information, err
+}
+
+func UpdateHisPrescriptionProjectStatus(project_id int64, record_time int64, user_org_id int64, patient_id int64) (models.HisPrescriptionProject, error) {
+
+	project := models.HisPrescriptionProject{}
+	err := XTWriteDB().Model(&project).Where("project_id  = ? and record_date = ? and user_org_id = ? and patient_id = ? and status = 1", project_id, record_time, user_org_id, patient_id).Update(map[string]interface{}{"is_out": 1}).Error
+	return project, err
+}

service/patient_schedule_template_service.go

 	addTemplateItems []*models.PatientScheduleTemplateItem,
 	delTemplateItems []*models.PatientScheduleTemplateItem,
 	changeTemplateItems []*models.PatientScheduleTemplateItem,
-) error {
+	shouldUpdateNextWeekSchedules bool,
+	shouldUpdateNextSecondWeekSchedules bool) error {
 
 	now := time.Now()
 	tx := writeDb.Begin()
 	//	}
 	//}
 
+	if orgID != 9671 && orgID != 10340 {
+		if shouldUpdateNextWeekSchedules {
+			nextWeek := now.AddDate(0, 0, 7)
+			if updateErr := _updateWeekSchedules(tx, orgID, nextWeek, addTemplateItems, delTemplateItems, changeTemplateItems, devicesMap); updateErr != nil {
+				tx.Rollback()
+				return updateErr
+			}
+		}
+		if shouldUpdateNextSecondWeekSchedules {
+			nextWeek := now.AddDate(0, 0, 14)
+			if updateErr := _updateWeekSchedules(tx, orgID, nextWeek, addTemplateItems, delTemplateItems, changeTemplateItems, devicesMap); updateErr != nil {
+				tx.Rollback()
+				return updateErr
+			}
+		}
+	}
+
 	tx.Commit()
 	return nil
 }

service/patient_service.go

 	return
 }
 
+func GetAllPatientListTwenty(orgID int64) (patients []*models.Patients, total int64, err error) {
+
+	db := readDb.Table("xt_patients as p").Where("p.user_org_id=? and p.status=1 and p.lapseto = 1", orgID)
+
+	err = db.Select(" p.id, p.user_org_id, p.user_id, p.patient_type, p.dialysis_no, p.admission_number, p.source, p.lapseto, p.partition_id, p.bed_id, p.name, p.alias, p.gender, p.marital_status, p.id_card_no, p.birthday, p.reimbursement_way_id, p.health_care_type, p.health_care_no, p.health_care_due_date, p.height, p.blood_type, p.rh, p.health_care_due_alert_date, p.education_level, p.profession, p.phone, p.home_telephone, p.relative_phone, p.relative_relations, p.home_address, p.work_unit, p.unit_address, p.children, p.receiving_date, p.is_hospital_first_dialysis, p.first_dialysis_date, p.first_dialysis_hospital, p.induction_period, p.initial_dialysis, p.total_dialysis, p.attending_doctor_id, p.head_nurse_id, p.evaluate, p.diagnose, p.remark, p.registrars_id, p.registrars, p.qr_code, p.binding_state, p.status, p.created_time, p.updated_time").Count(&total).Find(&patients).Error
+	return
+}
+
 func GetAllPatientListSix(orgID int64) (patients []*models.MSchedualPatientList, err error) {
 
 	err = XTReadDB().Model(&patients).Where("user_org_id = ? and status = 1", orgID).Find(&patients).Error
 	defer redis.Close()
 	key := strconv.FormatInt(orgID, 10) + ":" + strconv.FormatInt(scheduleDate, 10) + ":dialysis_orders_list_all"
 	dialysis_orders_list_all, _ := redis.Get(key).Result()
-
+	redis.Set(dialysis_orders_list_all, "", time.Second)
 	if len(dialysis_orders_list_all) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		err = readDb.Model(&models.MDialysisOrderForList{}).Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).Where("status = 1 AND user_org_id = ? AND dialysis_date = ?", orgID, scheduleDate).Find(&dialysisOrders).Error
 
 		return
 	}
 	// 删除排班和排班模板信息
-	if lapseto.LapsetoType == 2 {
+	if lapseto.LapsetoType == 2 || lapseto.LapsetoType == 3 {
 		now := time.Now()
 		deleteScheduleErr := utx.Model(&models.PatientSchedule{}).Where("patient_id = ? AND schedule_date >= ? AND status = 1", patient.ID, lapseto.LapsetoTime).Updates(map[string]interface{}{
 			"status":       0,
 func UpdatepatientTwo(patientsNew *models.XtPatientsNew, id int64) error {
 
 	err := XTWriteDB().Model(&patientsNew).Where("blood_id = ?", id).Update(map[string]interface{}{"user_org_id": patientsNew.UserOrgId, "user_id": patientsNew.UserId, "avatar": patientsNew.Avatar, "patient_type": patientsNew.Avatar, "dialysis_no": patientsNew.DialysisNo, "admission_number": patientsNew.AdmissionNumber, "source": patientsNew.Source, "lapseto": patientsNew.Lapseto, "partition_id": patientsNew.PartitionId, "bed_id": patientsNew.BedId, "name": patientsNew.Name, "alias": patientsNew.Alias, "gender": patientsNew.Gender, "marital_status": patientsNew.MaritalStatus, "id_card_no": patientsNew.IdCardNo, "birthday": patientsNew.Birthday, "reimbursement_way_id": patientsNew.ReimbursementWayId, "health_care_type": patientsNew.HealthCareType, "health_care_no": patientsNew.HealthCareType, "health_care_due_date": patientsNew.HealthCareType, "height": patientsNew.Height, "blood_type": patientsNew.BloodType, "rh": patientsNew.Rh, "health_care_due_alert_date": patientsNew.HealthCareDueAlertDate, "education_level": patientsNew.EducationLevel, "profession": patientsNew.Profession, "phone": patientsNew.Phone, "home_telephone": patientsNew.HomeTelephone, "relative_phone": patientsNew.RelativePhone, "relative_relations": patientsNew.RelativeRelations, "home_address": patientsNew.HomeAddress, "work_unit": patientsNew.WorkUnit, "unit_address": patientsNew.UnitAddress, "children": patientsNew.Children, "receiving_date": patientsNew.ReceivingDate, "is_hospital_first_dialysis": patientsNew.IsHospitalFirstDialysis, "first_dialysis_date": patientsNew.FirstDialysisDate, "first_dialysis_hospital": patientsNew.FirstDialysisHospital, "predialysis_condition": patientsNew.PredialysisCondition, "pre_hospital_dialysis_frequency": patientsNew.PreHospitalDialysisFrequency, "pre_hospital_dialysis_times": patientsNew.PreHospitalDialysisFrequency, "hospital_first_dialysis_date": patientsNew.HospitalFirstDialysisDate, "induction_period": patientsNew.InductionPeriod, "initial_dialysis": patientsNew.InitialDialysis, "total_dialysis": patientsNew.TotalDialysis, "attending_doctor_id": patientsNew.AttendingDoctorId, "head_nurse_id": patientsNew.HeadNurseId, "evaluate": patientsNew.Evaluate, "diagnose": patientsNew.Diagnose, "remark": patientsNew.Remark, "registrars_id": patientsNew.RegistrarsId, "registrars": patientsNew.Registrars, "qr_code": patientsNew.QrCode, "binding_state": patientsNew.BindingState, "patient_complains": patientsNew.PatientComplains, "present_history": patientsNew.PresentHistory, "past_history": patientsNew.PastHistory, "temperature": patientsNew.Temperature,
-		"pulse": patientsNew.Pulse, "respiratory": patientsNew.Respiratory, "sbp": patientsNew.Sbp, "dbp": patientsNew.Dbp, "nation": patientsNew.Nation, "native_place": patientsNew.NativePlace, "age": patientsNew.Age, "infectious_next_record_time": patientsNew.InfectiousNextRecordTime, "is_infectious": patientsNew.IsInfectious, "remind_cycle": patientsNew.RemindCycle, "response_result": patientsNew.ResponseResult, "is_open_remind": patientsNew.IsOpenRemind, "first_treatment_date": patientsNew.FirstTreatmentDate, "dialysis_age": patientsNew.DialysisAge, "expense_kind": patientsNew.ExpenseKind, "tell_phone": patientsNew.ExpenseKind, "contact_name": patientsNew.ContactName, "blood_patients": patientsNew.BloodPatients, "slow_patients": patientsNew.SlowPatients, "member_patients": patientsNew.MemberPatients, "ecommer_patients": patientsNew.EcommerPatients, "troble_shoot": patientsNew.TrobleShoot}).Error
+		"pulse": patientsNew.Pulse, "respiratory": patientsNew.Respiratory, "sbp": patientsNew.Sbp, "dbp": patientsNew.Dbp, "nation": patientsNew.Nation, "native_place": patientsNew.NativePlace, "age": patientsNew.Age, "infectious_next_record_time": patientsNew.InfectiousNextRecordTime, "is_infectious": patientsNew.IsInfectious, "remind_cycle": patientsNew.RemindCycle, "response_result": patientsNew.ResponseResult, "is_open_remind": patientsNew.IsOpenRemind, "first_treatment_date": patientsNew.FirstTreatmentDate, "dialysis_age": patientsNew.DialysisAge, "expense_kind": patientsNew.ExpenseKind, "tell_phone": patientsNew.ExpenseKind, "contact_name": patientsNew.ContactName, "blood_patients": patientsNew.BloodPatients, "slow_patients": patientsNew.SlowPatients, "member_patients": patientsNew.MemberPatients, "ecommer_patients": patientsNew.EcommerPatients, "troble_shoot": patientsNew.TrobleShoot, "sch_remark": patientsNew.SchRemark}).Error
 	return err
 }
 

service/patientmanage_service.go

 
 func UpdatedPatient(patients models.Patients, id int64) error {
 
-	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "admission_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "out_reason": patients.OutReason, "death_time": patients.DeathTime, "relative_phone": patients.RelativePhone}).Error
+	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "admission_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "out_reason": patients.OutReason, "death_time": patients.DeathTime, "relative_phone": patients.RelativePhone, "remark": patients.Remark, "sch_remark": patients.SchRemark, "treatment_plan": patients.TreatmentPlan}).Error
 
 	return err
 }
 
 func UpdateXtPatientNew(patients models.XtPatientsNew, id int64) error {
 
-	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "admission_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "out_reason": patients.OutReason, "death_time": patients.DeathTime, "relative_phone": patients.RelativePhone}).Error
+	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "admission_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "out_reason": patients.OutReason, "death_time": patients.DeathTime, "relative_phone": patients.RelativePhone, "remark": patients.Remark, "sch_remark": patients.SchRemark, "treatment_plan": patients.TreatmentPlan}).Error
 
 	return err
 }
 
 func UpdateXtPatientNewOne(patients models.XtPatientsNew, id int64) error {
 
-	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "adminssion_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "member_patienttype": patients.MemberPatienttype, "member_treatement": patients.MemberTreatement}).Error
+	err := XTWriteDB().Model(&patients).Where("id=?", id).Update(map[string]interface{}{"name": patients.Name, "gender": patients.Gender, "birthday": patients.Birthday, "age": patients.Age, "phone": patients.Phone, "lapseto": patients.Lapseto, "adminssion_number": patients.AdmissionNumber, "first_dialysis_date": patients.FirstDialysisDate, "diagnose": patients.Diagnose, "source": patients.Source, "dialysis_no": patients.DialysisNo, "avatar": patients.Avatar, "id_card_no": patients.IdCardNo, "is_infectious": patients.IsInfectious, "member_patienttype": patients.MemberPatienttype, "member_treatement": patients.MemberTreatement, "treatment_plan": patients.TreatmentPlan}).Error
 	return err
 }
 

service/pharmacy_service.go

 			err = fmt.Errorf("!:%v", err)
 			return
 		}
-		drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
+		//drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
 		//查询默认仓库
 		storeHouseConfig, _ := GetAllStoreHouseConfig(orgid)
 		//查询默认仓库剩余多少库存
 		var sum_count int64
 		stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, orgid, v.DrugId)
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drug.MinNumber + its.StockMinNumber
+			baseDrug, _ := GetBaseDrugMedical(its.DrugId)
+			if its.MaxUnit == baseDrug.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
+
 		UpdateBaseDrugSumTwo(v.DrugId, sum_count, orgid)
 	}
 
 			err = fmt.Errorf("!:%v", err)
 			return
 		}
-		drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
+		//drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
 		//查询默认仓库
 		storeHouseConfig, _ := GetAllStoreHouseConfig(orgid)
 		//查询默认仓库剩余多少库存
 		var sum_count int64
 		stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, orgid, v.DrugId)
 		for _, its := range stockInfo {
-			sum_count += its.StockMaxNumber*drug.MinNumber + its.StockMinNumber
+			baseDrug, _ := GetBaseDrugMedical(its.DrugId)
+			if its.MaxUnit == baseDrug.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
 		}
 		UpdateBaseDrugSumTwo(v.DrugId, sum_count, orgid)
 	}
 		err = fmt.Errorf("!:%v", err)
 		return
 	}
-	drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
+	//drug, _ := FindBaseDrugLibRecordSeven(orgid, v.DrugId)
 	//查询默认仓库
 	storeHouseConfig, _ := GetAllStoreHouseConfig(orgid)
 	//查询默认仓库剩余多少库存
 	var sum_count int64
 	stockInfo, _ := GetDrugAllStockInfo(storeHouseConfig.DrugStorehouseOut, orgid, v.DrugId)
 	for _, its := range stockInfo {
-		sum_count += its.StockMaxNumber*drug.MinNumber + its.StockMinNumber
+		baseDrug, _ := GetBaseDrugMedical(its.DrugId)
+		if its.MaxUnit == baseDrug.MaxUnit {
+			its.StockMaxNumber = its.StockMaxNumber * baseDrug.MinNumber
+		}
+		sum_count += its.StockMaxNumber + its.StockMinNumber
 	}
 	UpdateBaseDrugSumTwo(v.DrugId, sum_count, orgid)
 	return

service/print_data_service/schedule_dialysis/print_schedule_dialysis_service.go

 		db = db.Where("x.org_id = ?", orgid)
 	}
 	if startime > 0 {
-		db = db.Where("x.ctime >= ?", startime)
+		db = db.Where("x.sys_record_time >= ?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("x.ctime<=?", endtime)
+		db = db.Where("x.sys_record_time<=?", endtime)
 	}
 	err = db.Select("x.patient_id,x.sys_record_time,x.good_id,sum(x.count) as count,x.ctime,t.good_name,t.specification_name,t.packing_unit,t.retail_price,t.packing_price,t.buy_price").Joins("left join xt_good_information as t on t.id = x.good_id").Group("x.good_id").Scan(&out).Error
 	return out, err

service/schedule_service.go

 	return
 }
 
+func GetPatientWithScheduleAndSolutionTwo(orgID int64, keywords string, weekStart, weekEnd, schedule, contagion int64) (patients []*models.Patients, err error) {
+	db := readDb.Table("xt_patients as p").
+		Preload("DialysisSolutions", "user_org_id=? and initiate_mode=1 and affirm_state=1 and parent_id=0 and status=1", orgID).
+		//Preload("Schedules", "user_org_id=? and schedule_date>=? and schedule_date<= ? and status=1", orgID, weekStart, weekEnd).
+		Where("p.user_org_id=? and p.lapseto=1 and p.status=1", orgID)
+	if len(keywords) > 0 {
+		likeKey := "%" + keywords + "%"
+		db = db.Where("p.name LIKE ?", likeKey)
+	}
+
+	err = db.Find(&patients).Error
+	return
+}
+
 func GetWeekSchedule(orgID int64, start, end int64) (schedules []*models.Schedule, err error) {
 
 	err = readDb.Table("xt_schedule as s").Preload("PatientInfectiousDiseases", "status = 1 ").

service/self_drug_service.go

 	return info, total, err
 }
 
-func GetGoodPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfo, total int64, err error) {
+func GetGoodPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {
 
 	db := XTReadDB().Model(&goodinfo).Where("status = 1 and total_count > 0")
 	offset := (page - 1) * limit
 	return info, total, err
 }
 
-func GetDrugPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrug, total int64, err error) {
+func GetDrugPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrugTwenty, total int64, err error) {
 
 	db := XTReadDB().Model(&druginfo).Where("status = 1")
 	offset := (page - 1) * limit
 		db = db.Preload("DrugWarehouseInfo", "org_id = ? and status = 1 and is_check = 1", orgId)
 	}
 
-	if len(goodIds) > 0 {
-		db = db.Where("id in(?)", goodIds)
-	}
+	//if len(goodIds) > 0 {
+	//	db = db.Where("id in(?)", goodIds)
+	//}
 
 	if len(keyword) > 0 {
 		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
 	return info, err
 }
 
-func GetAddStartFlow(good_id int64, orgid int64, startime int64, endtime int64) (info []*models.VmStockFlow, err error) {
+func GetAddStartFlow(good_id int64, orgid int64, startime int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type =1")
 	if good_id > 0 {
 		db = db.Where("good_id = ?", good_id)
 	return info, err
 }
 
-func GetReduceWarehouseInfoList(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlow, err error) {
+func GetReduceWarehouseInfoList(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3)")
 	if good_id > 0 {
 		db = db.Where("good_id = ?", good_id)
 	return outinfo, err
 }
 
-func GetStartEndCancelFLowInfo(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlow, err error) {
+func GetStartEndCancelFLowInfo(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 7)")
 	if good_id > 0 {
 		db = db.Where("good_id = ?", good_id)
 	return outinfo, err
 }
 
-func FindeStartFlowInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlow, err error) {
+func FindeStartFlowInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
 	if good_id > 0 {
 	return info, err
 }
 
-func FindeStartFlowOutInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlow, err error) {
+func FindeStartFlowOutInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 2 or consumable_type = 3)")
 	if good_id > 0 {
 	return info, err
 }
 
-func FindeStartCancelInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlow, err error) {
+func FindeStartCancelInfo(good_id int64, orgid int64, startime int64) (info []*models.VmStockFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 4 or consumable_type = 7)")
 	if good_id > 0 {
 		db = db.Where("good_id = ?", good_id)
 	return info, err
 }
 
-func FindEndStartFlowInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlow, err error) {
+func FindEndStartFlowInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
 	if good_id > 0 {
 	return info, err
 }
 
-func FindeEndFLowOutInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlow, err error) {
+func FindeEndFLowOutInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 2 or consumable_type = 3)")
 	if good_id > 0 {
 	return info, err
 }
 
-func FindEndCancelInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlow, err error) {
+func FindEndCancelInfo(good_id int64, orgid int64, endtime int64) (info []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and  (consumable_type = 4 or consumable_type = 7)")
 	if good_id > 0 {
 	return info, err
 }
 
-func FindeWarehouseOutInfo(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlow, err error) {
+func FindeWarehouseOutInfo(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 2 or consumable_type = 3)")
 	if good_id > 0 {
 	return outinfo, err
 }
 
-func FindeStartStockInventoryProfit(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlow, err error) {
+func FindeStartStockInventoryProfit(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 10)")
 	if good_id > 0 {
 	return outinfo, err
 }
 
-func FindeEndStokInventoryProfit(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlow, err error) {
+func FindeEndStokInventoryProfit(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 10)")
 	if good_id > 0 {
 	return outinfo, err
 }
 
-func FindeEndStockInventoryLosses(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlow, err error) {
+func FindeEndStockInventoryLosses(good_id int64, orgid int64, startime int64, endtime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 11)")
 	if good_id > 0 {
 		db = db.Where("good_id = ?", good_id)
 	return outinfo, err
 }
 
-func FindStartStockInventoryLosses(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlow, err error) {
+func FindStartStockInventoryLosses(good_id int64, orgid int64, startime int64) (outinfo []*models.VmStockFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&outinfo).Where("status = 1 and (consumable_type = 11)")
 	if good_id > 0 {
 	return outinfo, err
 }
 
-func GetDrugWarehouseInfoStart(drug_id int64, orgid int64, startTime int64) (info []*models.DrugFlow, err error) {
+func GetDrugWarehouseInfoStart(drug_id int64, orgid int64, startTime int64) (info []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and  consumable_type=1 ")
 	if drug_id > 0 {
 	return info, err
 }
 
-func DrugWarehouseInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlow, err error) {
+func DrugWarehouseInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and consumable_type = 1")
 	if drug_id > 0 {
 	return info, err
 }
 
-func DrugWarehouseOutInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlow, err error) {
+func DrugWarehouseOutInfoEnd(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 2 or consumable_type= 3)")
 	if drug_id > 0 {
 	return info, err
 }
 
-func GetEndDrugFlowCancelInfo(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlow, err error) {
+func GetEndDrugFlowCancelInfo(drug_id int64, orgid int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1 and (consumable_type = 4 or consumable_type= 7)")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return info, err
 }
 
-func GetDrugWarehouseStartEnd(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlow, err error) {
+func GetDrugWarehouseStartEnd(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1 and  consumable_type = 1")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return info, err
 }
 
-func FindeDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlow, err error) {
+func FindeDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1  and (consumable_type = 2 or consumable_type= 3)")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return info, err
 }
 
-func FindStartEndDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlow, err error) {
+func FindStartEndDrugWarehouseOutInfo(drug_id int64, orgid int64, startTime int64, endTime int64) (info []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&info).Where("status = 1  and (consumable_type= 7)")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return flow, err
 }
 
-func GetDrugFlowOut(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowOut(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&flow).Where("status = 1  and (consumable_type = 2 or consumable_type= 3)")
 	if drug_id > 0 {
 	return flow, err
 }
 
-func GetStartDrugFlowCancelInfo(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlow, err error) {
+func GetStartDrugFlowCancelInfo(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&flow).Where("status = 1  and (consumable_type = 4 or consumable_type = 7)")
 
 	return flow, err
 }
 
-func GetDrugFlowStartProfit(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowStartProfit(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 10")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return flow, err
 }
 
-func GetDrugFlowStartLosses(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowStartLosses(drug_id int64, user_org_id int64, ctime int64) (flow []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11 ")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return flow, err
 }
 
-func GetDrugFlowEndProfit(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowEndProfit(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
 
 	db := XTReadDB().Model(&flow).Where("status = 1 and consumable_type = 10")
 	if drug_id > 0 {
 	return flow, err
 }
 
-func GetDrugFlowEndLosses(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowEndLosses(drug_id int64, user_org_id int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return flow, err
 }
 
-func GetDrugFlowStartEndProfit(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowStartEndProfit(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 10 ")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	return flow, err
 }
 
-func GetDrugFlowStartEndLosses(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlow, err error) {
+func GetDrugFlowStartEndLosses(drug_id int64, user_org_id int64, startime int64, endtime int64) (flow []*models.DrugFlowTwenty, err error) {
 	db := XTReadDB().Model(&flow).Where("status = 1  and consumable_type = 11 ")
 	if drug_id > 0 {
 		db = db.Where("drug_id = ?", drug_id)
 	err := XTWriteDB().Create(&stockCount).Error
 	return err
 }
+
+func GetGoodNewPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, ids []int64, goodIds []int64) (goodinfo []*models.GoodInfoTwenty, total int64, err error) {
+
+	db := XTReadDB().Model(&goodinfo).Where("status = 1 and total_count > 0")
+	offset := (page - 1) * limit
+	likeKey := "%" + keyword + "%"
+	if good_type > 0 {
+		db = db.Where("good_type_id = ?", good_type)
+	}
+
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+	if len(ids) > 0 {
+		db = db.Where("id in(?)", goodIds)
+	}
+	if len(keyword) > 0 {
+		db = db.Where("good_name like ? or manufacturer in(?)", likeKey, ids)
+	}
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&goodinfo).Error
+
+	return goodinfo, total, err
+}
+
+func GetStartLastFLow(goodid int64, orgid int64, startime int64) (models.VmStockFlowTwenty, error) {
+
+	flwo := models.VmStockFlowTwenty{}
+	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime < ?", goodid, orgid, startime).Last(&flwo).Error
+	return flwo, err
+}
+
+func GetEndLastFlow(goodid int64, orgid int64, endtime int64) (models.VmStockFlowTwenty, error) {
+	flwo := models.VmStockFlowTwenty{}
+	err := XTReadDB().Where("good_id = ? and user_org_id = ? and status = 1 and ctime <= ?", goodid, orgid, endtime).Last(&flwo).Error
+	return flwo, err
+}
+
+func GetDrugNewPurchaseStockQuery(good_type int64, keyword string, page int64, limit int64, orgid int64, startime int64, endtime int64, ids []int64, infos []int64) (druginfo []*models.VmBaseDrugTwenty, total int64, err error) {
+
+	db := XTReadDB().Model(&druginfo).Where("status = 1")
+	offset := (page - 1) * limit
+	likeKey := "%" + keyword + "%"
+	if good_type > 0 {
+		db = db.Where("drug_type = ?", good_type)
+	}
+
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+
+	if len(keyword) > 0 {
+		db = db.Where("drug_name like ? or manufacturer in(?)", likeKey, ids)
+	}
+	if len(infos) > 0 {
+		db = db.Where("id in(?)", infos)
+	}
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&druginfo).Error
+
+	return druginfo, total, err
+}
+
+func GetDrugStartFlow(drug_id int64, user_org_id int64, startime int64) (models.DrugFlowTwenty, error) {
+
+	flow := models.DrugFlowTwenty{}
+	err := XTReadDB().Where("drug_id = ? and user_org_id = ? and ctime<? and status = 1", drug_id, user_org_id, startime).Last(&flow).Error
+	return flow, err
+}
+
+func GetDrugEndFlow(drug_id int64, user_org_id int64, endtime int64) (models.DrugFlowTwenty, error) {
+
+	flow := models.DrugFlowTwenty{}
+	err := XTReadDB().Where("drug_id = ? and user_org_id = ? and ctime<=? and status = 1", drug_id, user_org_id, endtime).Last(&flow).Error
+	return flow, err
+}
+
+func GetAllStockCount(orgid int64) (stock []*models.XtGoodStockCount, err error) {
+
+	err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Find(&stock).Error
+	return stock, err
+}
+func GetLastStockFlow(good_id int64) (models.VmStockFlow, error) {
+
+	flow := models.VmStockFlow{}
+
+	err := XTReadDB().Where("good_id = ? and status =1  and ctime<=1667231999", good_id).Last(&flow).Error
+
+	return flow, err
+}
+
+func ModifyStockFlowById(id int64, over_count int64) error {
+
+	err := XTWriteDB().Model(&models.VmStockFlow{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"over_count": over_count}).Error
+	return err
+}
+
+func GetAllDrugCount(user_org_id int64) (drug []*models.XtDrugStockCount, err error) {
+
+	err = XTReadDB().Where("user_org_id = ? and status = 1", user_org_id).Find(&drug).Error
+	return drug, err
+}
+
+func GetLastDrugFlow(drug_id int64) (models.DrugFlow, error) {
+
+	flow := models.DrugFlow{}
+	err := XTReadDB().Where("drug_id = ? and status =1  and ctime<=1667231999", drug_id).Last(&flow).Error
+
+	return flow, err
+}
+
+func ModifyDrugFlowById(id int64, over_count int64) error {
+
+	err := XTWriteDB().Model(&models.DrugFlow{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"over_count": over_count}).Error
+	return err
+}
+
+func GetDrugInventoryWarehouseInfoList(org_id int64, storehouse_id int64) (info []*models.XtDrugWarehouseInfo, err error) {
+
+	err = XTReadDB().Model(&info).Where("status = 1 and storehouse_id = ? and is_check = 1 and org_id = ?", storehouse_id, org_id).Preload("XtBaseDrug", "status= 1").Find(&info).Error
+	return info, err
+}

service/stock_service.go

 		db = db.Where("x.org_id = ?", orgid)
 	}
 
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,t.social_security_directory_code,x.is_sys,x.sys_record_time,n.number,x.remark,x.license_number,x.storehouse_id,x.admin_user_id,x.buy_price,x.stock_count,x.warehouse_info_id,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit,t.packing_price").Joins("left join xt_warehouse_info as n on n.id=x.warehouse_info_id").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,x.manufacturer,t.social_security_directory_code,x.is_sys,x.sys_record_time,n.number,x.remark,x.license_number,x.storehouse_id,x.admin_user_id,x.buy_price,x.stock_count,x.warehouse_info_id,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit,t.packing_price,x.register_number").Joins("left join xt_warehouse_info as n on n.id=x.warehouse_info_id").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.warehouse_out_id,x.good_id").Order("x.ctime desc").Scan(&out).Error
 
 	return out, err
 }
 
 func GetOrderStockFlow(id []string, orgid int64) (list []*models.VmStockFlow, err error) {
 
-	db := XTReadDB().Model(&list).Where("status = 1 and consumable_type = 7 and patient_id > 0")
+	db := XTReadDB().Model(&list).Where("status = 1 and consumable_type = 7 and patient_id > 0 and count>0")
 	if len(id) > 0 {
 		db = db.Where("warehouse_out_id in (?)", id)
 	}
 	if len(warehouse_out_id) > 0 {
 		db = db.Where("x.warehouse_out_id in(?)", warehouse_out_id)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.max_unit as count_unit,x.price,x.retail_price,x.product_date,x.expire_date,x.warehouse_out_order_number,x.dealer,x.manufacturer,x.is_sys,x.number,x.batch_number,x.patient_id,x.ctime,b.dose,b.dose_unit,b.min_number,b.min_unit,b.max_unit,b.drug_name,b.drug_type,b.min_price").Joins("left join xt_base_drug as b on b.id = x.drug_id").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.drug_id,x.count,x.max_unit as count_unit,x.price,x.retail_price,x.product_date,x.expire_date,x.warehouse_out_order_number,x.dealer,x.manufacturer,x.is_sys,x.number,x.batch_number,x.patient_id,x.ctime,x.consumable_type,b.dose,b.dose_unit,b.min_number,b.min_unit,b.max_unit,b.drug_name,b.drug_type,b.min_price").Joins("left join xt_base_drug as b on b.id = x.drug_id").Scan(&out).Error
 	return out, err
 }
 
+func GetDrugOutListFlow(warehouse_out_id []string, orgid int64) (info []*models.XtDrugWarehouseOutInfo, err error) {
+
+	db := XTReadDB().Model(&info).Where("status = 1")
+	if len(warehouse_out_id) > 0 {
+		db = db.Where("warehouse_out_id in(?)", warehouse_out_id)
+	}
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+	err = db.Find(&info).Error
+	return info, err
+}
+
 func GetDrugWarehouseOut(warehouse_out_id []string) (out []*models.StDrugWarehouseOutInfo, err error) {
 
 	err = XTReadDB().Where("warehouse_out_id in(?)", warehouse_out_id).Find(&out).Error
 		}
 
 	}
-	err = db.Count(&total).Offset(offset).Limit(limit).Order("id desc").Preload("BaseDrugLib", "status = 1").Preload("DrugWarehouseInfo", "status = 1").Find(&drug_flow).Error
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("id desc").Preload("BaseDrugLib", "status = 1").Preload("DrugWarehouseInfo", "status = 1").Preload("XtDrugWarehouseOutInfo", "status = 1").Find(&drug_flow).Error
 	return drug_flow, total, err
 }
 
 
 func ModifyWarehouseOutInfo(id int64, info *models.WarehouseOutInfo) error {
 
-	err := XTWriteDB().Model(&models.WarehouseOutInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"good_id": info.GoodId, "good_type_id": info.GoodTypeId, "count": info.Count, "price": info.Price, "total_price": info.TotalPrice, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "remark": info.Remark, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "number": info.Number, "license_number": info.LicenseNumber, "storehouse_id": info.StorehouseId, "admin_user_id": info.AdminUserId, "buy_price": info.BuyPrice, "stock_count": info.StockCount}).Error
+	err := XTWriteDB().Model(&models.WarehouseOutInfo{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"good_id": info.GoodId, "good_type_id": info.GoodTypeId, "count": info.Count, "price": info.Price, "total_price": info.TotalPrice, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "remark": info.Remark, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "number": info.Number, "license_number": info.LicenseNumber, "storehouse_id": info.StorehouseId, "admin_user_id": info.AdminUserId, "buy_price": info.BuyPrice, "stock_count": info.StockCount, "register_number": info.RegisterNumber}).Error
 	return err
 }
 
 }
 
 func UpdateCheckDrugOut(out models.DrugWarehouseOut, id int64) error {
-
-	err := XTWriteDB().Model(&models.DrugWarehouseOut{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": out.IsCheck}).Error
+	tx := XTWriteDB().Begin()
+	err := tx.Model(&models.DrugWarehouseOut{}).Where("id = ? and status = 1", id).Update(map[string]interface{}{"is_check": out.IsCheck}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
 	err = XTWriteDB().Model(&models.DrugWarehouseOutInfo{}).Where("warehouse_out_id = ? and status = 1", id).Update(map[string]interface{}{"is_check": 1}).Error
+	if err != nil {
+		tx.Rollback()
+		return err
+	}
+	tx.Commit()
 	return err
 }
 
 	tx.Commit()
 	return err
 
-	err = XTWriteDB().Model(&models.GoodInfo{}).Where("id = ? and org_id = ? and status = 1", goodid, orgid).Update(map[string]interface{}{"sum_count": sum_count}).Error
-	return err
 }
 
 func UpdateGoodInfoAddSumCount(goodid int64, sum_count int64, orgid int64, sum_in_count int64) error {
 	return detail, err
 }
 
+func GetGoodDialysisOutInfoSix(orgid int64, patient_id int64, sys_record_time int64, good_id int64) (models.WarehouseOutInfo, error) {
+
+	detail := models.WarehouseOutInfo{}
+	err := XTReadDB().Where("org_id =? and patient_id = ? and sys_record_time = ? and good_id = ? and status= 1", orgid, patient_id, sys_record_time, good_id).Find(&detail).Error
+	return detail, err
+}
+
+func GetGoodSumCount(storehouse_id int64, good_id int64, orgid int64) (models.XtGoodStockCount, error) {
+
+	stock := models.XtGoodStockCount{}
+	err := XTReadDB().Where("storehouse_id = ? and good_id = ? and user_org_id = ? and status = 1", storehouse_id, good_id, orgid).Find(&stock).Error
+	return stock, err
+}
+
+func CreateGoodStockCount(stock models.XtGoodStockCount) error {
+
+	err := XTWriteDB().Create(&stock).Error
+	return err
+}
+
 func AddGoodSumInCount(storehouse_id int64, good_id int64, user_org_id int64, count int64) error {
 
 	ut := XTWriteDB().Begin()
 	return err
 }
 
+func CreateDrugStock(stock models.XtDrugStockCount) error {
+
+	err := XTWriteDB().Create(&stock).Error
+	return err
+}
+
 func UpdateDrugCount(storehouse_id int64, user_org_id int64, drug_id int64, sum_in_count int64, flush_count int64) error {
 
 	ut := XTWriteDB().Begin()
 	ut.Commit()
 	return err
 }
+
+func GetInvetoryWarehouseInfoList(orgid int64, storehouse_id int64) (info []*models.WarehousingInfo, err error) {
+
+	err = XTReadDB().Model(&info).Where("status = 1 and storehouse_id=? and is_check= 1 and org_id = ?", storehouse_id, orgid).Preload("GoodInfo", "status = 1").Find(&info).Error
+	return info, err
+}

service/user_service.go

 	return
 }
 
+func GetAllDoctorAndNurseSix(orgId, appid int64) (doctors []AdminUserList, nurses []AdminUserList, err error) {
+
+	var users []AdminUserList
+	err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("org_id=? and app_id =? and uar.user_type IN (2,3) and ua.status=1", orgId, appid).Select("ua.id, uar.user_name as name, uar.user_type,uar.status").Scan(&users).Error
+	if err != nil {
+		return
+	}
+	if len(users) == 0 {
+		return
+	}
+	for _, item := range users {
+		if item.UserType == 2 {
+			doctors = append(doctors, item)
+		} else {
+			nurses = append(nurses, item)
+		}
+	}
+	return
+}
+
 func GetAllAdminUsers(orgId, appid int64) (list []*AdminUserList, err error) {
 
 	err = readUserDb.Table("sgj_user_admin_role as uar").Joins("JOIN sgj_user_admin as ua ON ua.id = uar.admin_user_id").Where("uar.org_id=? and uar.app_id =? and ua.status=1", orgId, appid).Select("ua.id, uar.user_name as name, uar.user_type,uar.status").Scan(&list).Error

service/warhouse_service.go

 
 	if stock_number >= deliver_number {
 
+		var maxNumber int64 = 0
+		var minNumber int64 = 0
+		//var stock_max_number int64 = 0
+		//stock_max_number = warehouse.StockMaxNumber
+
+		maxNumber = deliver_number / drup.MinNumber
+		minNumber = deliver_number % drup.MinNumber
+
+		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
+			minNumber = maxNumber
+		}
+
+		if drup.MaxUnit != drup.MinUnit {
+			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
+				return errors.New("库存数量不足")
+			}
+		}
+
+		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+
+		if warehouse.StockMaxNumber < 0 {
+			warehouse.StockMaxNumber = 0
+		}
+		if warehouse.StockMinNumber < 0 {
+			warehouse.StockMinNumber = 0
+		}
+
+		warehouse.Mtime = time.Now().Unix()
+
+		if warehouse.StockMinNumber < minNumber {
+
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
+			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
+		} else {
+			if minNumber > 0 {
+				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
+			}
+
+			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
+				if warehouse.StockMinNumber > 0 {
+					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+				}
+
+			}
+
+		}
+
+		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
+			if (warehouse.StockMinNumber - deliver_number) > 0 {
+				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+			}
+
+		}
+
+		if drup.MaxUnit != drup.MinUnit {
+			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
+				return errors.New("库存数量不足")
+			}
+		}
+		if warehouse.StockMinNumber <= 0 {
+			warehouse.StockMinNumber = 0
+		}
+
+		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
+
+		if errThree != nil {
+			return errThree
+		}
+
+		//查询剩余库存
+		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
+		var sum_count int64
+		for _, its := range stockInfo {
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
+		}
+
 		warehouseOutInfo := &models.DrugWarehouseOutInfo{
 			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
 			WarehouseOutId:          warehouseout.ID,
 			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
 			StorehouseId:            storeConfig.DrugStorehouseOut,
 			IsCheck:                 1,
+			OverCount:               sum_count,
 		}
 
 		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
 			StorehouseId:            storeConfig.DrugStorehouseOut,
 			WarehouseOutDetailId:    lastDrugOutInfo.ID,
 			LastPrice:               warehouse.Price,
+			OverCount:               sum_count,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			return errTwo
 		}
 
-		var maxNumber int64 = 0
-		var minNumber int64 = 0
-		//var stock_max_number int64 = 0
-		//stock_max_number = warehouse.StockMaxNumber
-
-		maxNumber = deliver_number / drup.MinNumber
-		minNumber = deliver_number % drup.MinNumber
-
-		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
-			minNumber = maxNumber
-		}
-
-		if drup.MaxUnit != drup.MinUnit {
-			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
-				return errors.New("库存数量不足")
-			}
-		}
-
-		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
-
-		if warehouse.StockMaxNumber < 0 {
-			warehouse.StockMaxNumber = 0
-		}
-		if warehouse.StockMinNumber < 0 {
-			warehouse.StockMinNumber = 0
-		}
-
-		warehouse.Mtime = time.Now().Unix()
-
-		if warehouse.StockMinNumber < minNumber {
-
-			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
-			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
-		} else {
-			if minNumber > 0 {
-				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
-			}
-
-			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
-				if warehouse.StockMinNumber > 0 {
-					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
-				}
-
-			}
-
-		}
-
-		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
-			if (warehouse.StockMinNumber - deliver_number) > 0 {
-				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
-			}
-
-		}
-
-		if drup.MaxUnit != drup.MinUnit {
-			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
-				return errors.New("库存数量不足")
-			}
-		}
-		if warehouse.StockMinNumber <= 0 {
-			warehouse.StockMinNumber = 0
-		}
-
-		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
-
-		if errThree != nil {
-			return errThree
+		var out_count int64
+		//查询出库数据
+		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
+		for _, item := range infoCountList {
+			out_count += item.Count
 		}
+		//出库数量相加
+		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)
 
 		return nil
 	} else {
 			return errThree
 		}
 
+		//查询剩余库存
+		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
+		var sum_count int64
+		for _, its := range stockInfo {
+			if its.MaxUnit == drup.MaxUnit {
+				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
+			}
+			sum_count += its.StockMaxNumber + its.StockMinNumber
+		}
+
+		var out_count int64
+
+		//查询出库数据
+		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
+		for _, item := range infoCountList {
+			out_count += item.Count
+		}
+
 		drugflow := models.DrugFlow{
 			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
 			WarehouseOutId:          warehouseout.ID,
 			StorehouseId:            storeConfig.DrugStorehouseOut,
 			WarehouseOutDetailId:    lastDrugOutInfo.ID,
 			LastPrice:               warehouse.Price,
+			OverCount:               sum_count,
 		}
 
 		CreateDrugFlowOne(drugflow)
+		//出库数量相加
+		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)
 
 		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
 		prescribingNumber_two_temp := deliver_number - stock_number
 			}
 		}
 
-		fmt.Println("goods999923932923923923223wode", goods)
 		for _, item := range goods {
 			var newCount int64 = 0
 			for _, it := range goodOne {
 				out_count += item.Count
 			}
 			cha_count = item.Count - out_count
-			fmt.Println("item.Count", item.Count)
-			fmt.Println("item.Count", out_count)
-			fmt.Println("cha_count2323223232323223", cha_count)
+			//fmt.Println("item.Count", item.Count)
+			//fmt.Println("item.Count", out_count)
+			//fmt.Println("cha_count2323223232323223", cha_count)
 			cha_count_two = out_count - item.Count
 
 			prepare := models.DialysisBeforePrepare{
 			BatchNumberCount:        warehouse.StockCount - goods.Count,
 			IsCheck:                 1,
 			OverCount:               sum_count,
+			RegisterNumber:          goods.RegisterNumber,
 		}
 		//创建出库流水
 		errflow := CreateStockFlowOne(stockFlow)
 			BatchNumberCount:        0,
 			IsCheck:                 1,
 			OverCount:               sum_count,
+			RegisterNumber:          goods.RegisterNumber,
 		}
 		//创建出库流水
 		errflow := CreateStockFlowOne(stockFlow)
 
 // 药品手动出库 递归方式
 func AutoDrugDeliverInfoFourtyOne(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {
-	//开事务
+
+	fmt.Println("出库数量", prescribingNumber)
+
 	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
 	var deliver_number int64 = 0
 	var stock_number int64 = 0
 		var stockMin int64
 		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
 		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
+		fmt.Println("stockmax", stockMax)
+		fmt.Println("stockMin", stockMin)
 		ChangeMaxNumber(lastWarehouse.ID, stockMax)
 		UpdateMinNumber(lastWarehouse.ID, stockMin)
 	}
 	}
 
 	// 将该批次的剩余库存数量转换为拆零数量
+	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
+		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
+	}
+	if warehouse.MaxUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
+		stock_number = warehouse.StockMaxNumber + warehouse.StockMinNumber
+	}
+	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit == drup.MinUnit {
+		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
+	}
 
-	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
-
+	fmt.Println("stock_number", stock_number)
+	fmt.Println("deliver_number", deliver_number)
 	// 当库存数量大于或等于出库数量的话，则正常出库该批次
 	if stock_number >= deliver_number {
 
 			}
 		}
 
-		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		if drup.MinUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
+		}
+		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
+		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
 
 		if warehouse.StockMaxNumber < 0 {
 			warehouse.StockMaxNumber = 0
 			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
 			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
 		} else {
+			fmt.Println("maxNumber23323323332322323w9", maxNumber)
+			fmt.Println("maxNumber23323323332322323w9", minNumber)
 			if minNumber > 0 {
 				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
 					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
 				} else {
-					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
+					if (warehouse.StockMinNumber - minNumber) >= 0 {
+						warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
+					}
+
 				}
 			}
 
 			if minNumber == 0 && maxNumber != 1 {
 				if warehouse.StockMinNumber > 0 {
-					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+					if (warehouse.StockMinNumber - deliver_number) >= 0 {
+						warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+					}
 				}
-
 			}
-
 		}
 
 		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
-			if (warehouse.StockMinNumber - deliver_number) > 0 {
+			if (warehouse.StockMinNumber - deliver_number) >= 0 {
 				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
 			}