11月8日库存管理

conf/app.conf

 appname = 血透
-httpport = 9531
+httpport = 9529
 runmode = dev
 
 #

controllers/dialysis_api_controller.go

 	startTime, _ := c.GetInt64("schedul_time", 0)
 	partitionType, _ := c.GetInt64("partition_type", 0)
 	keywords := c.GetString("keywords")
-
+	start_time, _ := c.GetInt64("start_time")
+	end_time, _ := c.GetInt64("end_time")
 	adminUserInfo := c.GetAdminUserInfo()
 	if len(keywords) > 0 {
-		dialysisSchedule, err, total := service.GetDialysisWatchByKeyword(adminUserInfo.CurrentOrgId, keywords, schedulType, partitionType, page, limit)
+
+		dialysisSchedule, err, total := service.GetDialysisWatchByKeyword(adminUserInfo.CurrentOrgId, keywords, schedulType, partitionType, page, limit, start_time/1000, end_time/1000)
 		if err == nil {
 			c.ServeSuccessJSON(map[string]interface{}{
 				"schedule": dialysisSchedule,
 		}
 
 	} else {
-		dialysisSchedule, err, total := service.GetDialysisWatch(adminUserInfo.CurrentOrgId, startTime/1000, schedulType, partitionType, page, limit)
+		dialysisSchedule, err, total := service.GetDialysisWatch(adminUserInfo.CurrentOrgId, startTime/1000, schedulType, partitionType, page, limit, start_time/1000, end_time/1000)
 		if err == nil {
 			c.ServeSuccessJSON(map[string]interface{}{
 				"schedule": dialysisSchedule,

controllers/his_api_controller.go

 	"reflect"
 	"strconv"
 	"strings"
-	"sync"
 	"syscall"
 	"time"
 	"unsafe"
 	})
 }
 
-var waitGroup sync.WaitGroup
-
 func (c *HisApiController) CreateHisPrescription() {
 	record_date := c.GetString("record_date")
 	patient_id, _ := c.GetInt64("patient_id")
 	_, stockConfig := service.FindAutomaticReduceRecordByOrgId(c.GetAdminUserInfo().CurrentOrgId)
 
 	if drugStockConfig.IsOpen == 1 {
-
 		//校验库存总量
 		if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
 			prescriptions, _ := dataBody["prescriptions"].([]interface{})
-
-			//GetPrescriptionById(prescriptions)
 			if len(prescriptions) > 0 {
 				for _, item := range prescriptions {
 					items := item.(map[string]interface{})
 								var drug_id int64
 								var prescribing_number float64
 								var prescribingNumberUnit string
+								var prescribingNumber string
 
 								var adviceId int64
 								if advice.(map[string]interface{})["id"] != nil || reflect.TypeOf(advice.(map[string]interface{})["id"]).String() == "float64" {
 								if advice.(map[string]interface{})["prescribing_number"] != nil || reflect.TypeOf(advice.(map[string]interface{})["prescribing_number"]).String() == "string" {
 									prescribing_number_str := advice.(map[string]interface{})["prescribing_number"].(string)
 									prescribing_number, _ = strconv.ParseFloat(prescribing_number_str, 64)
-
+									prescribingNumber = advice.(map[string]interface{})["prescribing_number"].(string)
 								}
 
 								if advice.(map[string]interface{})["prescribing_number_unit"] != nil && reflect.TypeOf(advice.(map[string]interface{})["prescribing_number_unit"]).String() == "string" {
 								//查询该药品是否存在开药记录
 								advicelist, _ := service.GetHisAdviceListByDrugIdEight(drug_id, patient_id, recordDateTime, adviceId)
 
+								//新增处方
+								if advicelist.ID == 0 {
+									all_count, _ := strconv.ParseFloat(totals, 64)
+									if prescribingNumberUnit == drug.MinUnit {
+										if prescribing_number > all_count {
+											c.ServeDynamicFailJsonSend(drug.DrugName + "库存不足")
+											return
+										}
+									} else {
+										if prescribingNumberUnit == drug.MaxUnit {
+											num := prescribing_number * float64(drug.MinNumber)
+											if num > all_count {
+												c.ServeDynamicFailJsonSend(drug.DrugName + "库存不足")
+												return
+											}
+										}
+									}
+								}
 								//修改处方
 								if advicelist.ID > 0 {
 									var device_number int64
+
 									if advicelist.PrescribingNumberUnit == drug.MaxUnit {
-										prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
-										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
+										prescribingNumberOne := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
+										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumberOne, 10, 64)
 										device_number = prescribingNumberInt * drug.MinNumber
 									}
 									if advicelist.PrescribingNumberUnit == drug.MinUnit {
-										prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
-										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
+										prescribingNumberOne := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
+										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumberOne, 10, 64)
 										device_number = prescribingNumberInt
 									}
 
 									var number_count int64
 									if prescribingNumberUnit == drug.MaxUnit {
-										prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
 										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
 										number_count = prescribingNumberInt * drug.MinNumber
 									}
 									if prescribingNumberUnit == drug.MinUnit {
-										prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
 										prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
 										number_count = prescribingNumberInt
 									}
+
+									fmt.Println("以前出库数量23323232322332323223233223232332", device_number)
+									fmt.Println("现在出库数量", number_count)
 									//如果修改的数量大于之前修改的数量
 									if (number_count - device_number) > 0 {
 										//如果修改的差数量 大于库存数量
 											return
 										}
 									}
-								}
 
-								//新增处方
-								if advicelist.ID == 0 {
-									all_count, _ := strconv.ParseFloat(totals, 64)
-									if prescribingNumberUnit == drug.MinUnit {
-										if prescribing_number > all_count {
-											c.ServeDynamicFailJsonSend(drug.DrugName + "库存不足")
-											return
+									if device_number != number_count {
+
+										// 查询该药品最后一次出库记录
+										druginfo, _ := service.GetLastDrugWarehouseOutByDrugId(drug_id, patient_id, recordDateTime, adviceId)
+										fmt.Println("以前出库数量23323232322332323223233223232332", device_number)
+										fmt.Println("现在出库数量", number_count)
+										//回退库存
+										if druginfo.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
+
+											service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, number_count)
 										}
-									} else {
-										if prescribingNumberUnit == drug.MaxUnit {
-											num := prescribing_number * float64(drug.MinNumber)
-											if num > all_count {
-												c.ServeDynamicFailJsonSend(drug.DrugName + "库存不足")
-												return
+										if druginfo.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
+											var stock_max_number int64
+											var stock_min_number int64
+
+											if number_count >= drug.MinNumber {
+												fmt.Println("尽力啊了吗332323322332233232332233223232323")
+												stock_max_number = device_number / drug.MinNumber
+												service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, stock_max_number)
+												stock_min_number = device_number % drug.MinNumber
+												service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, stock_min_number)
+
+											} else {
+												fmt.Println("99999999999999999999")
+												service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, device_number)
 											}
 										}
+
+										if druginfo.CountUnit == drug.MaxUnit && druginfo.CountUnit == drug.MinUnit && drug.MaxUnit == drug.MinUnit {
+											service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, device_number)
+										}
+										//删除记录
+										service.DeleteDrugAutoWarehouseSeven(drug_id, patient_id, recordDateTime, adviceId)
 									}
 								}
-
 							}
 						}
 					}
 			prescriptions, _ := dataBody["prescriptions"].([]interface{})
 			if len(prescriptions) > 0 {
 				for _, item := range prescriptions {
+
 					items := item.(map[string]interface{})
 					if items["project"] != nil && reflect.TypeOf(items["project"]).String() == "[]interface {}" {
 						projects := items["project"].([]interface{})
 								var project_id int64
 								var project_type int64
 								var totals float64
+								var project_name string
+								var parsetotal int64
 								if project.(map[string]interface{})["project_id"] != nil || reflect.TypeOf(project.(map[string]interface{})["project_id"]).String() == "float64" {
 									project_id = int64(project.(map[string]interface{})["project_id"].(float64))
 								}
 								}
 								if project.(map[string]interface{})["total"] != nil || reflect.TypeOf(project.(map[string]interface{})["total"]).String() == "string" {
 									total, _ := project.(map[string]interface{})["total"].(string)
-
 									totals, _ = strconv.ParseFloat(total, 64)
+									parsetotal, _ = strconv.ParseInt(total, 10, 64)
 								}
-								if project_type == 3 {
+								if project.(map[string]interface{})["project_name"] != nil || reflect.TypeOf(project.(map[string]interface{})["project_name"]).String() == "string" {
+									project_name = project.(map[string]interface{})["project_name"].(string)
 
+								}
+								if project_type == 3 {
 									//查找该耗材的出库记录
-									goodWarehouseInfo, _ := service.GetAutoRecordByGoodIdSeven(project_id, patient_id, recordDateTime)
-
-									if goodWarehouseInfo.ID == 0 {
-										good, _ := service.FindGoodInfoByIdSeven(project_id)
-										if good.ID == 0 {
-											c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-											return
-										}
+									goodWarehouseInfo, _ := service.GetAutoRecordByGoodIdSevenEight(project_id, patient_id, recordDateTime)
+									var total_count int64
+									for _, it := range goodWarehouseInfo {
+										total_count += it.Count
+									}
+									if len(goodWarehouseInfo) == 0 {
 										//查询耗材库存
 										list, _ := service.GetGoodWarehouseInfoSeven(project_id)
 										var stock_count int64
 										stock_counts := strconv.FormatInt(stock_count, 10)
 										stock_total_count, _ := strconv.ParseFloat(stock_counts, 64)
 										if totals > stock_total_count {
-											c.ServeDynamicFailJsonSend(good.GoodName + "库存不足")
+											c.ServeDynamicFailJsonSend(project_name + "库存不足")
 											return
 										}
 									}
-								}
-
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	ch := make(chan struct{})
-	count := 2 // count 表示活动的协程个数
-
-	go func() {
-		if drugStockConfig.IsOpen == 1 {
-			//校验库存总量
-			if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
-				prescriptions, _ := dataBody["prescriptions"].([]interface{})
-				if len(prescriptions) > 0 {
-					for _, item := range prescriptions {
-						items := item.(map[string]interface{})
-						if items["advices"] != nil && reflect.TypeOf(items["advices"]).String() == "[]interface {}" {
-							advices := items["advices"].([]interface{})
-							if len(advices) > 0 {
-								for _, advice := range advices {
-									var drug_id int64
-									var prescribingNumberUnit string
-									var prescribingNumber string
-									var adviceId int64
-									if advice.(map[string]interface{})["id"] != nil || reflect.TypeOf(advice.(map[string]interface{})["id"]).String() == "float64" {
-										drug_id = int64(advice.(map[string]interface{})["id"].(float64))
-									}
-									if advice.(map[string]interface{})["prescribing_number"] != nil || reflect.TypeOf(advice.(map[string]interface{})["prescribing_number"]).String() == "string" {
-
-										prescribingNumber = advice.(map[string]interface{})["prescribing_number"].(string)
-
-									}
-
-									if advice.(map[string]interface{})["prescribing_number_unit"] != nil && reflect.TypeOf(advice.(map[string]interface{})["prescribing_number_unit"]).String() == "string" {
-										prescribingNumberUnit, _ = advice.(map[string]interface{})["prescribing_number_unit"].(string)
-									}
-
-									if advice.(map[string]interface{})["advice_id"] != nil || reflect.TypeOf(advice.(map[string]interface{})["advice_id"]).String() == "float64" {
-										adviceId = int64(advice.(map[string]interface{})["advice_id"].(float64))
-									}
-
-									drug, _ := service.FindBaseDrugLibRecordSeven(adminInfo.CurrentOrgId, drug_id)
-									if drug.ID == 0 {
-										c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-										return
-									}
-
-									//查询药品的所有库存
-									list, _ := service.GetDrugWarehouseInfoPrescriptionSeven(drug_id, adminInfo.CurrentOrgId)
-									var total_count int64
-									for _, it := range list {
-										total_count += it.StockMaxNumber*drug.MinNumber + it.StockMinNumber
-									}
-
-									//查询该药品是否存在开药记录
-									advicelist, _ := service.GetHisAdviceListByDrugIdEight(drug_id, patient_id, recordDateTime, adviceId)
-
-									//修改处方
-									if advicelist.ID > 0 {
-										var device_number int64
-										if advicelist.PrescribingNumberUnit == drug.MaxUnit {
-											prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
-											prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
-											device_number = prescribingNumberInt * drug.MinNumber
-										}
-										if advicelist.PrescribingNumberUnit == drug.MinUnit {
-											prescribingNumber := strconv.FormatFloat(advicelist.PrescribingNumber, 'f', -1, 64)
-											prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
-											device_number = prescribingNumberInt
-										}
-
-										var sum_count int64
-										//判断是否做过修改
-										if prescribingNumberUnit == drug.MaxUnit {
-
-											prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
-
-											sum_count = prescribingNumberInt * drug.MinNumber
-										}
-										if prescribingNumberUnit == drug.MinUnit {
-											prescribingNumberInt, _ := strconv.ParseInt(prescribingNumber, 10, 64)
-											sum_count = prescribingNumberInt
-										}
-										fmt.Println("sum_count23322332323232323232323223322323", sum_count)
-										fmt.Println("devcie_number23333223333332232332233232323223", device_number)
-
-										if device_number != sum_count {
-
-											// 查询该药品最后一次出库记录
-											druginfo, _ := service.GetLastDrugWarehouseOutByDrugId(drug_id, patient_id, recordDateTime, adviceId)
-											fmt.Println("单位12332232322332322323233223", druginfo.CountUnit)
-											fmt.Println("单位2332233223323223322332332233223", drug.MaxUnit)
-											//回退库存
-											if druginfo.CountUnit == drug.MaxUnit && drug.MaxUnit != drug.MinUnit {
-
-												service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, device_number)
-											}
-											if druginfo.CountUnit == drug.MinUnit && drug.MaxUnit != drug.MinUnit {
-												var stock_max_number int64
-												var stock_min_number int64
-												if device_number >= drug.MinNumber {
-													stock_max_number = device_number / drug.MinNumber
-													//fmt.Println("大的值2323233232232323", stock_max_number)
-													service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, stock_max_number)
-													stock_min_number = device_number % drug.MinNumber
-													//	fmt.Println("小的值322332332323233223", stock_min_number)
-													if stock_min_number == drug.MinNumber {
-
-													}
-													service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, stock_min_number)
-
-												} else {
-
-													service.ModefyDrugByWarehouseInfoOne(druginfo.WarehouseInfoId, device_number)
-												}
-
-											}
-
-											if druginfo.CountUnit == drug.MaxUnit && druginfo.CountUnit == drug.MinUnit && drug.MaxUnit == drug.MinUnit {
-												service.ModefyDrugByWarehouseInfo(druginfo.WarehouseInfoId, device_number)
-											}
-
-											//删除记录
-											service.DeleteDrugAutoWarehouseSeven(drug_id, patient_id, recordDateTime, adviceId)
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-		ch <- struct{}{}
-	}()
-
-	go func() {
-		if stockConfig.IsOpen == 1 {
-			if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
-				prescriptions, _ := dataBody["prescriptions"].([]interface{})
-				if len(prescriptions) > 0 {
-					for _, item := range prescriptions {
-						items := item.(map[string]interface{})
-						if items["project"] != nil && reflect.TypeOf(items["project"]).String() == "[]interface {}" {
-							projects := items["project"].([]interface{})
-							if len(projects) > 0 {
-								for _, project := range projects {
-									var project_id int64
-									var project_type int64
-									var parsetotal int64
-									if project.(map[string]interface{})["project_id"] != nil || reflect.TypeOf(project.(map[string]interface{})["project_id"]).String() == "float64" {
-										project_id = int64(project.(map[string]interface{})["project_id"].(float64))
-									}
-									if project.(map[string]interface{})["type"] != nil || reflect.TypeOf(project.(map[string]interface{})["type"]).String() == "float64" {
-										project_type = int64(project.(map[string]interface{})["type"].(float64))
-									}
-									if project.(map[string]interface{})["total"] != nil || reflect.TypeOf(project.(map[string]interface{})["total"]).String() == "string" {
-										total, _ := project.(map[string]interface{})["total"].(string)
-										parsetotal, _ = strconv.ParseInt(total, 10, 64)
-									}
-
-									if project_type == 3 {
-										//查找该耗材的出库记录
-										goodWarehouseInfo, _ := service.GetAutoRecordByGoodIdSevenEight(project_id, patient_id, recordDateTime)
-										var total_count int64
-										for _, it := range goodWarehouseInfo {
-											total_count += it.Count
-										}
+									if len(goodWarehouseInfo) > 0 {
 										//查询该患者耗材的历史数据
 										ordProject, _ := service.GetHisProjectPrescriptionByPatientId(patient_id, recordDateTime)
 										if total_count > 0 {
 											if parsetotal != total_count || len(ordProject) != len(projects) {
 												//查找今日该患者已经出库的所有耗材
 												goodList, _ := service.GetAllAutoRecordByPatient(patient_id, recordDateTime)
+												fmt.Println("goodList3323223232323232323", goodList)
 												for _, item := range goodList {
 													//回退库存
 													service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
-													//删除记录
-													service.DeleteAutoWarehouse(item.PatientId, item.SysRecordTime)
 												}
+												//删除记录
+												service.DeleteAutoWarehouse(patient_id, recordDateTime)
 											}
 										}
 									}
 				}
 			}
 		}
-		ch <- struct{}{}
-	}()
-
-	for range ch {
-		// 每次从ch中接收数据，表明一个活动的协程结束
-		count--
-		// 当所有活动的协程都结束时，关闭管道
-		if count == 0 {
-			close(ch)
-		}
 	}
 
 	info, _ := service.FindHisPatientPrescriptionInfo(adminInfo.CurrentOrgId, patient_id, recordDateTime, p_type, his_patient_id)
 		defer redis.Close()
 	}
 
+	//定义切片
+
+	var adviceList []models.HisDoctorAdviceInfo
+	var projectList []models.HisPrescriptionProject
+
+	//var hisLis  []models.HisList
+
 	if dataBody["prescriptions"] != nil && reflect.TypeOf(dataBody["prescriptions"]).String() == "[]interface {}" {
 		prescriptions, _ := dataBody["prescriptions"].([]interface{})
 
 		var tempPrescription *models.HisPrescription
+
 		if len(prescriptions) > 0 {
 			for _, item := range prescriptions {
 				items := item.(map[string]interface{})
 
 							s.StartTime = pTime
 							service.CreateHisDoctorAdvice(&s)
+
+							//存储切片中
+							adviceList = append(adviceList, s)
+
 							redis := service.RedisClient()
 							key := strconv.FormatInt(adminInfo.CurrentOrgId, 10) + ":" + strconv.FormatInt(theTime.Unix(), 10) + ":his_advices_list_all"
 							redis.Set(key, "", time.Second)
 							}
 
 							service.CreateHisProjectTwo(&p)
+							projectList = append(projectList, p)
 							var randNum int
 							randNum = rand.Intn(10000) + 1000
 							timestamp := time.Now().Unix()
 
 							service.SaveHisProjectTwo(&p)
 
-							if p.Type == 3 { //处理透前准备耗材数量数据
-								consumables, _ := service.FindHisConsumablesByID(adminInfo.CurrentOrgId, patient_id, recordDateTime, p.ProjectId)
-								if consumables.ID > 0 {
-									cnt, _ := strconv.ParseInt(p.Count, 10, 64)
-									consumables.Count = cnt
-									service.UpdateConsumables(&consumables)
-								}
-							}
+							//if p.Type == 3 { //处理透前准备耗材数量数据
+							//	consumables, _ := service.FindHisConsumablesByID(adminInfo.CurrentOrgId, patient_id, recordDateTime, p.ProjectId)
+							//	if consumables.ID > 0 {
+							//		cnt, _ := strconv.ParseInt(p.Count, 10, 64)
+							//		consumables.Count = cnt
+							//		service.UpdateConsumables(&consumables)
+							//	}
+							//}
 
 						}
 					}
 		}
 	}
 
+	//redisClient := service.RedisClient()
+	//defer redisClient.Close()
+	//
+	//list := models.HisList{
+	//  Patient_id:  patient_id,
+	//  Advice_id:0,
+	//  Record_date: 0,
+	//  Advice:      adviceList,
+	//  Project:     nil,
+	//}
+	//hisLis = append(hisLis, list)
+	//
+	//advice_json, _ := json.Marshal(&hisLis)
+	//redisClient.RPush("111", advice_json).Result()
+	//result, _ := redisClient.RPop("111").Result()
+	//fmt.Println("resuilt2332323323232323232323232322323233232",redisClient.LLen("111"))
+	//
+	//var dat []map[string]interface{}
+	//json.Unmarshal([]byte(result), &dat)
+	//fmt.Println("hhhh2332323232233223322332322323232323",dat)
+	//
+	//for k,v:=range dat{
+	//  fmt.Println("第",k,"个数的值是:",v,v["Advice"],v["Patient_id"])
+	//}
+	//project_json, _ := json.Marshal(&projectList)
+	//redisClient.LPush("222", project_json).Result()
+
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"msg": "保存成功",
 		}
 	}
 
-	_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(advice.UserOrgId)
-
-	if drugStockConfig.IsOpen == 1 {
-
-		drug, _ := service.FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
-		if advice.ID == 0 { //医嘱不存在
-			if advice.PrescribingNumberUnit == drug.MinUnit { //当前数据单位与基础库一致为最小单位，直接计算
-				drug.Total = drug.Total - advice.PrescribingNumber
-				service.UpdateBaseDrugLib(&drug)
-
-			} else if advice.PrescribingNumberUnit == drug.MaxUnit { //当前数据单位为最大单位，需要将最大单位转为最小单位
-				num := advice.PrescribingNumber * float64(drug.MinNumber)
-				drug.Total = drug.Total - num
-				service.UpdateBaseDrugLib(&drug)
-			}
-
-		} else if advice.ID > 0 { //医嘱存在
-			hisAdvice, _ := service.GetHisDoctorAdvicesById(advice.ID)
-			var num float64
-
-			if advice.PrescribingNumberUnit == drug.MinUnit { //当前数据为最小单位
-				if hisAdvice.PrescribingNumberUnit == advice.PrescribingNumberUnit { //原数据为最小单位，三个单位一致为最小单位直接计算
-					if hisAdvice.PrescribingNumber > advice.PrescribingNumber {
-						num = hisAdvice.PrescribingNumber - advice.PrescribingNumber
-						drug.Total = drug.Total + num
-						service.UpdateBaseDrugLib(&drug)
-					} else if hisAdvice.PrescribingNumber < advice.PrescribingNumber {
-						num = advice.PrescribingNumber - hisAdvice.PrescribingNumber
-						drug.Total = drug.Total - num
-						service.UpdateBaseDrugLib(&drug)
-					}
-				} else { //原数据为最大单位，需要将最大单位数量转为最小单位数量
-					num2 := hisAdvice.PrescribingNumber * float64(drug.MinNumber)
-					if num2 > advice.PrescribingNumber {
-						num = num2 - advice.PrescribingNumber
-						drug.Total = drug.Total + num
-						service.UpdateBaseDrugLib(&drug)
-					} else if num2 < advice.PrescribingNumber {
-						num = advice.PrescribingNumber - num2
-						drug.Total = drug.Total - num
-						service.UpdateBaseDrugLib(&drug)
-					}
-
-				}
-
-			} else if advice.PrescribingNumberUnit == drug.MaxUnit { //当前数据为最大单位
-				if advice.PrescribingNumberUnit == hisAdvice.PrescribingNumberUnit { //原数据为最大单位， 当前数据单位和原数据单位都为最大单位，需要将两个数据转成最小单位
-					num1 := hisAdvice.PrescribingNumber * float64(drug.MinNumber)
-					num2 := advice.PrescribingNumber * float64(drug.MinNumber)
-					if num1 > num2 {
-						num = num1 - num2
-						drug.Total = drug.Total + num
-						service.UpdateBaseDrugLib(&drug)
-					} else if num1 < num2 {
-						num = num2 - num1
-						drug.Total = drug.Total - num
-						service.UpdateBaseDrugLib(&drug)
-					}
-
-				} else { //原数据为最小单位，当前数据为最大单位，需要将当前数据数量转为最小单位数量
-					num2 := advice.PrescribingNumber * float64(drug.MinNumber)
-					//num2 := hisAdvice.PrescribingNumber * (drug.Dose / float64(drug.MinNumber))
-					if hisAdvice.PrescribingNumber > num2 {
-						num = hisAdvice.PrescribingNumber - num2
-						drug.Total = drug.Total + num
-						service.UpdateBaseDrugLib(&drug)
-					} else if num2 < advice.PrescribingNumber {
-						num = num2 - hisAdvice.PrescribingNumber
-						drug.Total = drug.Total - num
-						service.UpdateBaseDrugLib(&drug)
-					}
-
-				}
-			}
-		}
-	}
+	//_, drugStockConfig := service.FindDrugStockAutomaticReduceRecordByOrgId(advice.UserOrgId)
+	//
+	//if drugStockConfig.IsOpen == 1 {
+	//
+	//	drug, _ := service.FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
+	//	if advice.ID == 0 { //医嘱不存在
+	//		if advice.PrescribingNumberUnit == drug.MinUnit { //当前数据单位与基础库一致为最小单位，直接计算
+	//			drug.Total = drug.Total - advice.PrescribingNumber
+	//			service.UpdateBaseDrugLib(&drug)
+	//
+	//		} else if advice.PrescribingNumberUnit == drug.MaxUnit { //当前数据单位为最大单位，需要将最大单位转为最小单位
+	//			num := advice.PrescribingNumber * float64(drug.MinNumber)
+	//			drug.Total = drug.Total - num
+	//			service.UpdateBaseDrugLib(&drug)
+	//		}
+	//
+	//	} else if advice.ID > 0 { //医嘱存在
+	//		hisAdvice, _ := service.GetHisDoctorAdvicesById(advice.ID)
+	//		var num float64
+	//
+	//		if advice.PrescribingNumberUnit == drug.MinUnit { //当前数据为最小单位
+	//			if hisAdvice.PrescribingNumberUnit == advice.PrescribingNumberUnit { //原数据为最小单位，三个单位一致为最小单位直接计算
+	//				if hisAdvice.PrescribingNumber > advice.PrescribingNumber {
+	//					num = hisAdvice.PrescribingNumber - advice.PrescribingNumber
+	//					drug.Total = drug.Total + num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				} else if hisAdvice.PrescribingNumber < advice.PrescribingNumber {
+	//					num = advice.PrescribingNumber - hisAdvice.PrescribingNumber
+	//					drug.Total = drug.Total - num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				}
+	//			} else { //原数据为最大单位，需要将最大单位数量转为最小单位数量
+	//				num2 := hisAdvice.PrescribingNumber * float64(drug.MinNumber)
+	//				if num2 > advice.PrescribingNumber {
+	//					num = num2 - advice.PrescribingNumber
+	//					drug.Total = drug.Total + num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				} else if num2 < advice.PrescribingNumber {
+	//					num = advice.PrescribingNumber - num2
+	//					drug.Total = drug.Total - num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				}
+	//
+	//			}
+	//
+	//		} else if advice.PrescribingNumberUnit == drug.MaxUnit { //当前数据为最大单位
+	//			if advice.PrescribingNumberUnit == hisAdvice.PrescribingNumberUnit { //原数据为最大单位， 当前数据单位和原数据单位都为最大单位，需要将两个数据转成最小单位
+	//				num1 := hisAdvice.PrescribingNumber * float64(drug.MinNumber)
+	//				num2 := advice.PrescribingNumber * float64(drug.MinNumber)
+	//				if num1 > num2 {
+	//					num = num1 - num2
+	//					drug.Total = drug.Total + num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				} else if num1 < num2 {
+	//					num = num2 - num1
+	//					drug.Total = drug.Total - num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				}
+	//
+	//			} else { //原数据为最小单位，当前数据为最大单位，需要将当前数据数量转为最小单位数量
+	//				num2 := advice.PrescribingNumber * float64(drug.MinNumber)
+	//				//num2 := hisAdvice.PrescribingNumber * (drug.Dose / float64(drug.MinNumber))
+	//				if hisAdvice.PrescribingNumber > num2 {
+	//					num = hisAdvice.PrescribingNumber - num2
+	//					drug.Total = drug.Total + num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				} else if num2 < advice.PrescribingNumber {
+	//					num = num2 - hisAdvice.PrescribingNumber
+	//					drug.Total = drug.Total - num
+	//					service.UpdateBaseDrugLib(&drug)
+	//				}
+	//
+	//			}
+	//		}
+	//	}
+	//}
 
 	//
 	//if json["execution_time"] != nil && reflect.TypeOf(json["execution_time"]).String() == "string" {
 	//	project.WeekDay = week_day
 	//}
 
-	_, stockConfig := service.FindAutomaticReduceRecordByOrgId(project.UserOrgId)
-
-	if project.ID == 0 {
-		if stockConfig.IsOpen == 1 {
-			if project.Type == 3 {
-				good, _ := service.FindGoodInfoByIdTwo(project.ProjectId)
-				f_count, _ := strconv.ParseFloat(project.Count, 64)
-				good.Total = good.Total - f_count
-				service.UpdateGoodInfo(&good)
-			}
-		}
-
-	} else {
-		temp_project, _ := service.GetHisPrescriptionProjectByID(project.ID)
-
-		if stockConfig.IsOpen == 1 {
-			if project.Type == 3 {
-				good, _ := service.FindGoodInfoByIdTwo(project.ProjectId)
-				if project.Count < temp_project.Count {
-					f_count_one, _ := strconv.ParseFloat(project.Count, 64)
-					f_count_two, _ := strconv.ParseFloat(temp_project.Count, 64)
-
-					other_count := f_count_two - f_count_one
-					other_count_two, _ := strconv.ParseFloat(strconv.FormatInt(int64(other_count), 10), 64)
-					good.Total = good.Total + other_count_two
-					service.UpdateGoodInfo(&good)
-				} else if project.Count > temp_project.Count {
-					f_count_one, _ := strconv.ParseFloat(project.Count, 64)
-					f_count_two, _ := strconv.ParseFloat(temp_project.Count, 64)
-
-					other_count := f_count_one - f_count_two
-					other_count_two, _ := strconv.ParseFloat(strconv.FormatInt(int64(other_count), 10), 64)
-					good.Total = good.Total - other_count_two
-					service.UpdateGoodInfo(&good)
-				}
-
-			}
-		}
-
-	}
+	//_, stockConfig := service.FindAutomaticReduceRecordByOrgId(project.UserOrgId)
+	//
+	//if project.ID == 0 {
+	//	if stockConfig.IsOpen == 1 {
+	//		if project.Type == 3 {
+	//			good, _ := service.FindGoodInfoByIdTwo(project.ProjectId)
+	//			f_count, _ := strconv.ParseFloat(project.Count, 64)
+	//			good.Total = good.Total - f_count
+	//			service.UpdateGoodInfo(&good)
+	//		}
+	//	}
+	//
+	//} else {
+	//	temp_project, _ := service.GetHisPrescriptionProjectByID(project.ID)
+	//
+	//	if stockConfig.IsOpen == 1 {
+	//		if project.Type == 3 {
+	//			good, _ := service.FindGoodInfoByIdTwo(project.ProjectId)
+	//			if project.Count < temp_project.Count {
+	//				f_count_one, _ := strconv.ParseFloat(project.Count, 64)
+	//				f_count_two, _ := strconv.ParseFloat(temp_project.Count, 64)
+	//
+	//				other_count := f_count_two - f_count_one
+	//				other_count_two, _ := strconv.ParseFloat(strconv.FormatInt(int64(other_count), 10), 64)
+	//				good.Total = good.Total + other_count_two
+	//				service.UpdateGoodInfo(&good)
+	//			} else if project.Count > temp_project.Count {
+	//				f_count_one, _ := strconv.ParseFloat(project.Count, 64)
+	//				f_count_two, _ := strconv.ParseFloat(temp_project.Count, 64)
+	//
+	//				other_count := f_count_one - f_count_two
+	//				other_count_two, _ := strconv.ParseFloat(strconv.FormatInt(int64(other_count), 10), 64)
+	//				good.Total = good.Total - other_count_two
+	//				service.UpdateGoodInfo(&good)
+	//			}
+	//
+	//		}
+	//	}
+	//
+	//}
 
 	return 0
 }
 	})
 	return
 }
-
-func GetPrescriptionById(prescription []interface{}) {
-
-	fmt.Println("prescription222222222222225555532323332323233223323323322332323232323232332322323323232", prescription)
-}

controllers/print_data_api_controller.go

 	idStrs := strings.Split(schIDStr, ",")
 	adminUserInfo := this.GetAdminUserInfo()
 	schedules, getScheduleErr := service.GetSchedules(adminUserInfo.CurrentOrgId, idStrs)
+	for _, item := range schedules {
+		list, _ := service.GetDialysisOrderCountSeven(item.PatientID, item.ScheduleDate)
+		if this.GetAdminUserInfo().CurrentOrgId != 10101 {
+			item.Count = list.Count
+		}
 
+	}
 	if getScheduleErr != nil {
 		this.ErrorLog("获取打印透析记录失败：%v", getScheduleErr)
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)

controllers/schedule_api_controller.go

 	beego.Router("/api/schedule/getnextweekpanels", &ScheduleApiController{}, "Get:GetNextWeekPanels")
 	beego.Router("/api/schedule/synchroschedule", &ScheduleApiController{}, "Get:SynchroSchedule")
 	beego.Router("/api/schedule/getpatientscheduletemplate", &ScheduleApiController{}, "Get:GetPatientScheduleTempalate")
+	beego.Router("/api/schedule/getsolutionschedule", &ScheduleApiController{}, "Get:GetSolutionSchedule")
 }
 
 func (c *ScheduleApiController) GetWeekPanels() {
 		"schedule": tempalate,
 	})
 }
+
+func (c *ScheduleApiController) GetSolutionSchedule() {
+
+	orgId := c.GetAdminUserInfo().CurrentOrgId
+	solution, _ := service.GetSolutionSchedule(orgId)
+	c.ServeSuccessJSON(map[string]interface{}{
+		"solution": solution,
+	})
+	return
+}

main.go

 }
 
 func main() {
-	service.BeginAutoCreateWeekSchedulesJob()
+	//service.BeginAutoCreateWeekSchedulesJob()
 	//service.BeginAutoCreateWeekDisinfectionJob()
 	//service.BeginAutoCreatePlanJob()
 	//service.AutoClearSchedules()
 	//service.BeginAutoCreateStaffScheduleJob()
 	//service.BeginAutoCreateDrugJob()
 	//service.BeginAutoCreateStockJob()
+
 	//beego.BConfig.WebConfig.Session.SessionGCMaxLifetime = 6000
 	beego.Run()
 }

models/dialysis.go

 	Number         string       `gorm:"column:number" json:"number"`
 }
 
+type VmDialysisOrder struct {
+	Count        int64
+	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"`
+	Status       int64 `gorm:"column:status" json:"status"`
+}
+
+func (VmDialysisOrder) TableName() string {
+	return "xt_dialysis_order"
+}
+
 type DialysisOrder struct {
 	ID                     int64         `gorm:"column:id" json:"id"`
 	DialysisDate           int64         `gorm:"column:dialysis_date" json:"dialysis_date"`

models/his_models.go

 	return "his_case_history_template"
 }
 
+type HisList struct {
+	Patient_id  int64
+	Advice_id   int64
+	Record_date int64
+	Advice      []HisDoctorAdviceInfo    `gorm:json:"advices"`
+	Project     []HisPrescriptionProject `gorm:json:"project"`
+}
+
 type HisDoctorAdviceInfo 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"`
 	return "his_stock_price_config"
 }
 
-
 type SgjAdmin struct {
 	ID           int64  `gorm:"column:id" json:"id" form:"id"`
 	Account      string `gorm:"column:account" json:"account" form:"account"`

models/stock_models.go

 	return "xt_warehouse_out_info"
 }
 
+type WarehouseOutInfoNight struct {
+	ID               int64 `gorm:"column:id" json:"id"`
+	Count            int64 `gorm:"column:count" json:"count"`
+	GoodId           int64 `gorm:"column:good_id" json:"good_id"`
+	SysRecordTime    int64 `gorm:"column:sys_record_time" json:"sys_record_time"`
+	PatientId        int64 `gorm:"column:patient_id" json:"patient_id"`
+	ProjectId        int64 `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	WarehouseInfotId int64 `gorm:"column:warehouse_info_id" json:"warehouse_info_id"`
+	IsSys            int64 `gorm:"column:is_sys" json:"is_sys"`
+	Status           int64 `gorm:"column:status" json:"status"`
+}
+
+func (WarehouseOutInfoNight) TableName() string {
+	return "xt_warehouse_out_info"
+}
+
 type WarehouseOutInfoSeven struct {
 	ID    int64 `gorm:"column:id" json:"id"`
 	Count int64 `gorm:"column:count" json:"count"`

service/dialysis_service.go

 	return err, receiveTreatmentAsses
 }
 
-func GetDialysisWatch(orgID int64, schedulDate int64, schedulType int64, partitionType int64, page int64, limit int64) (schedule []*models.DialysisSchedule, err error, total int64) {
+func GetDialysisWatch(orgID int64, schedulDate int64, schedulType int64, partitionType int64, page int64, limit int64, start int64, end int64) (schedule []*models.DialysisSchedule, err error, total int64) {
 	db := readDb.
 		Model(&models.MonitorDialysisSchedule{}).
 		Preload("DeviceNumber", "status = 1 AND org_id = ?", orgID).
 	if schedulType > 0 {
 		db = db.Where("schedule_type = ?", schedulType)
 	}
+	if start > 0 {
+		db = db.Where("schedule_date >= ?", start)
+	}
+	if end > 0 {
+		db = db.Where("schedule_date <= ?", end)
+	}
 	if partitionType > 0 {
 		db = db.Joins("inner join xt_device_number on xt_device_number.id = xt_schedule.bed_id and xt_device_number.zone_id = ? and xt_device_number.status = 1", partitionType)
 		// db = db.Where("partition_id = ?", partitionType)
 //	return schedules, err, total
 //}
 
-func GetDialysisWatchByKeyword(orgID int64, keyword string, schedulType int64, partitionType int64, page int64, limit int64) ([]*models.DialysisSchedule, error, int64) {
+func GetDialysisWatchByKeyword(orgID int64, keyword string, schedulType int64, partitionType int64, page int64, limit int64, start int64, end int64) ([]*models.DialysisSchedule, error, int64) {
 	var patients []*models.Patients
 	getPatientErr := readDb.Model(&models.Patients{}).Where("status = 1 AND user_org_id = ? AND (name like ? OR dialysis_no like ?)", orgID, "%"+keyword+"%", "%"+keyword+"%").Find(&patients).Error
 	if getPatientErr != nil {
 	if schedulType > 0 {
 		db = db.Where("schedule_type = ?", schedulType)
 	}
+	if start > 0 {
+		db = db.Where("schedule_date >= ?", start)
+	}
+	if end > 0 {
+		db = db.Where("schedule_date<=?", end)
+	}
 	if partitionType > 0 {
 		db = db.Joins("inner join xt_device_number as d_n on d_n.id = xt_schedule.bed_id and d_n.zone_id = ? and d_n.status = 1", partitionType)
 		// db = db.Where("partition_id = ?", partitionType)

service/his_project_service.go

 	if isMark > 0 {
 		db = db.Where("x.is_mark = ?", isMark)
 	}
-	err = db.Select("x.id,x.project_name,x.pinyin,x.wubi,x.price,x.unit,x.cost_classify,x.executive_section,x.medical_coverage,x.statistical_classification,x.disease_directory,x.is_record,x.medical_code,x.tube_color,x.medical_status,x.remark,x.sign,x.default_number,x.is_default,x.is_charge,x.is_estimate,x.is_workload,x.sort,x.doctor_advice,x.user_org_id,x.status,x.created_time,x.is_mark").Count(&total).Offset(offset).Limit(limit).Order("created_time desc").Find(&hisproject).Error
+	err = db.Select("x.id,x.project_name,x.pinyin,x.wubi,x.price,x.unit,x.cost_classify,x.executive_section,x.medical_coverage,x.statistical_classification,x.disease_directory,x.is_record,x.medical_code,x.tube_color,x.medical_status,x.remark,x.sign,x.default_number,x.is_default,x.is_charge,x.is_estimate,x.is_workload,x.sort,x.doctor_advice,x.user_org_id,x.status,x.created_time,x.is_mark,x.social_security_directory_code").Count(&total).Offset(offset).Limit(limit).Order("created_time desc").Find(&hisproject).Error
 	return hisproject, total, err
 }
 

service/print_data_service/schedule_dialysis/print_schedule_dialysis_models.go

 	LastAfterWeight          XtAssessmentAfterDislysisVM      `gorm:"ForeignKey:PatientID;AssociationForeignKey:PatientID" json:"lastafterweight"`
 	HisAdvices               []*models.HisDoctorAdviceInfo    `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"his_advices"`
 	HisPrescriptionProject   []*models.HisPrescriptionProject `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"his_project"`
-	Count                    int
+	Count                    int64
 }
 
 func (ScheduleVM) TableName() string {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_service.go

 		return nil, err
 	}
 	for _, item := range schedules {
-
 		if orgID != 10101 {
-			dialysis_count, _ := GetDialysisOrderCountOne(orgID, item.PatientID, item.ScheduleDate)
+			dialysis_count, _ := GetDialysisOrderCount(orgID, item.PatientID, item.ScheduleDate)
+
 			item.Patient.TotalDialysis = dialysis_count
+
 		}
 		if orgID == 10101 {
 			dialysis_count, _ := GetDialysisOrderCountOne(orgID, item.PatientID, item.ScheduleDate)
 			item.Patient.TotalDialysis = dialysis_count
 		}
-
-		fmt.Println(item.Patient.TotalDialysis)
-
 	}
 	return schedules, nil
 }
 	return
 }
 
-//func GetDialysisOrderCount(orgID int64, patient_id int64, recordDate int64)(order []*models.DialysisOrder,err error) {
-// err = p_service.XTReadDB().Where("dialysis_date <= ? AND status = 1 AND user_org_id = ? AND patient_id = ?", recordDate, orgID, patient_id).Find(&order).Error
-// return order,err
-//}
+func GetDialysisOrderCountSeven(patient_id int64, recordDate int64) (models.VmDialysisOrder, error) {
+	order := models.VmDialysisOrder{}
+	err := p_service.XTReadDB().Raw("SELECT Count(id) as count,Max(dialysis_date) as dialysis_date  from xt_dialysis_order where dialysis_date <= ? AND status = 1 AND stage = 2 AND patient_id = ?", recordDate, patient_id).Scan(&order).Error
+	return order, err
+}
 
 func GetDialysisOrderCountOne(orgID int64, patient_id int64, recordDate int64) (count int64, err error) {
-	err = p_service.XTReadDB().Model(&models.DialysisOrder{}).Where("dialysis_date >=1640966400 and dialysis_date <= ? AND status = 1 AND stage = 2 AND user_org_id = ? AND patient_id = ?", recordDate, orgID, patient_id).Count(&count).Error
+	err = p_service.XTReadDB().Where("dialysis_date >=1640966400 and dialysis_date <= ? AND status = 1 AND stage = 2 AND user_org_id = ? AND patient_id = ?", recordDate, orgID, patient_id).Count(&count).Error
 	return
 }
 

service/schedule_service.go

 	err := XTReadDB().Where("org_id = ? and status =1", orgid).Find(&mode).Error
 	return mode, err
 }
+
+func GetSolutionSchedule(orgid int64) (solution []*models.DialysisSolution, err error) {
+
+	err = XTReadDB().Model(&solution).Where("org_id = ? and status = 1", orgid).Group("mode_id").Order("created_time desc").Find(&solution).Error
+	return solution, err
+}

service/stock_service.go

 	return project, err
 }
 
-func GetAllAutoRecordByPatient(patientid int64, recorddate int64) (auto []*models.WarehouseOutInfo, err error) {
+func GetAllAutoRecordByPatient(patientid int64, recorddate int64) (auto []*models.WarehouseOutInfoNight, err error) {
 
-	err = XTReadDB().Model(&auto).Where("patient_id = ? and sys_record_time = ? and status = 1", patientid, recorddate).Find(&auto).Error
+	err = XTReadDB().Select("count,warehouse_info_id").Where(" patient_id = ? and sys_record_time = ?  and status = 1 and is_sys = 1 and count>0", patientid, recorddate).Find(&auto).Error
 	return auto, err
+
 }
 
+//func GetAllAutoRecordByPatient(patientid int64, recorddate int64) (auto []*models.VmStockFlow, err error) {
+//
+//	err = XTReadDB().Select("count,warehousing_id").Where(" patient_id = ? and system_time = ?  and status = 1 and is_sys = 1 and count>0",patientid,recorddate).Find(&auto).Error
+//	return auto, err
+//
+//}
+
 func ModefyWarehouseInfo(count int64, id int64) error {
 
 	err := XTWriteDB().Model(models.WarehousingInfo{}).Where(" id =? and status = 1", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
 
 	err := XTWriteDB().Model(models.AutomaticReduceDetail{}).Where("patient_id = ? and record_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
 	err = XTWriteDB().Model(models.DialysisBeforePrepare{}).Where("patient_id = ? and record_date = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
-	err = XTWriteDB().Model(models.WarehouseOutInfo{}).Where("patient_id = ? and sys_record_time =? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
 	err = XTWriteDB().Model(models.VmStockFlow{}).Where("patient_id = ? and system_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
+	err = XTWriteDB().Model(models.WarehouseOutInfoNight{}).Where("patient_id = ? and sys_record_time = ? and status = 1", patient_id, record_time).Updates(map[string]interface{}{"status": 0}).Error
+	fmt.Println("err2332332322323322323232323232332", err)
 	return err
 }
 

service/warhouse_service.go

 		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
 		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
 				return errors.New("库存数量不足")
 			}
 		}
-		if minNumber != 0 {
-			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
-		}
+		fmt.Println("minNumber23323323232323232322332", maxNumber, minNumber)
+
+		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
 
 		if warehouse.StockMaxNumber < 0 {
 			warehouse.StockMaxNumber = 0
 		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
 			fmt.Println("2223232332322323", warehouse.StockMinNumber)
 			warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
-
+			if warehouse.StockMinNumber == 0 {
+				warehouse.StockMaxNumber = stock_max_number
+			}
 		}
 
 		if drup.MaxUnit != drup.MinUnit {