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

conf/app.conf

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

controllers/manager_center_api_controller.go

 	good_kind, _ := c.GetInt64("good_kind")
 	is_mark, _ := c.GetInt64("is_mark")
 	manufacturer, _ := c.GetInt64("manufacturer")
+	is_type, _ := c.GetInt64("is_type")
 	adminUserInfo := c.GetAdminUserInfo()
-	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind, is_mark, manufacturer)
+	goodInfos, total, err := service.FindGoodInfoList(adminUserInfo.CurrentOrgId, page, limit, keyword, is_use, is_charge, good_kind, is_mark, manufacturer, is_type)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list":  goodInfos,

controllers/mobile_api_controllers/dialysis_api_controller.go

 
 				count, _ := strconv.ParseInt(items["count"].(string), 10, 64)
 
+				if items["project_id"] == nil || reflect.TypeOf(items["project_id"]).String() != "float64" {
+					utils.ErrorLog("project_id")
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+					return
+				}
+				project_id := int64(items["project_id"].(float64))
 				prepare := &models.DialysisBeforePrepareGoods{
 					GoodId:     good_id,
 					GoodTypeId: good_type_id,
 					Count:      count,
+					ProjectId:  project_id,
 				}
 				beforePrepares = append(beforePrepares, prepare)
 
 					GoodId:     good_id,
 					GoodTypeId: good_type_id,
 					Count:      count,
+					ProjectId:  project_id,
 				}
 				newBeforePrepares = append(newBeforePrepares, newPrepare)
 			}
 			Creater:    adminInfo.AdminUser.Id,
 			Status:     1,
 			Ctime:      time.Now().Unix(),
+			ProjectId:  item.ProjectId,
 		}
 		//清空准备表的数据
 		err = service.DeleteDialysisBefor(adminInfo.Org.Id, patient_id, record_time, item.GoodId, item.GoodTypeId)

controllers/mobile_api_controllers/patient_api_controller.go

 
 			fmt.Println("theTIME", theTime)
 			keyFour := "scheduals_" + theTime + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
-			fmt.Println("keyFour323223323232323232", keyFour)
+
 			redis.Set(keyFour, "", time.Second)
 			keyFive := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(advice.AdviceDate, 10) + ":his_advices_list_all"
 			redis.Set(keyFive, "", time.Second)

models/dialysis.go

 	CommdityCode string                   `gorm:"column:commdity_code" json:"commdity_code" form:"commdity_code"`
 	NewCount     int64                    `gorm:"column:new_count" json:"new_count" form:"new_count"`
 	Children     []*DialysisBeforePrepare `gorm:"column:children" json:"children" form:"children"`
+	ProjectId    int64                    `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 func (DialysisBeforePrepare) TableName() string {
 	GoodTypeId        int64  `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
 	TypeName          string `gorm:"column:type_name" json:"type_name" form:"type_name"`
 	SpecificationName string `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
+	ProjectId         int64  `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 type NewDialysisBeforePrepareGoods struct {
 	TypeName          string `gorm:"column:type_name" json:"type_name" form:"type_name"`
 	SpecificationName string `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
 	NewCount          int64  `gorm:"column:new_count" json:"new_count" form:"new_count"`
+	ProjectId         int64  `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 type QueueCallConfig struct {

models/dialysis_parameter_models.go

 	GoodId                  int64  `gorm:"column:good_id" json:"good_id" form:"good_id"`
 	GoodTypeId              int64  `gorm:"column:good_type_id" json:"good_type_id" form:"good_type_id"`
 	Count                   int64  `gorm:"column:count" json:"count" form:"count"`
+	ProjectId               int64  `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 func (BloodAutomaticReduceDetail) TableName() string {

models/stock_models.go

 	Number                  string       `gorm:"column:number" json:"number" form:"number"`
 	LicenseNumber           string       `gorm:"column:license_number" json:"license_number" form:"license_number"`
 	ConsumableType          int64        `gorm:"column:consumable_type" json:"consumable_type" form:"consumable_type"`
+	ProjectId               int64        `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 func (WarehouseOutInfo) TableName() string {
 	return "xt_warehouse_out_info"
 }
 
+type WarehouseOutInfoSeven struct {
+	ID    int64 `gorm:"column:id" json:"id"`
+	Count int64 `gorm:"column:count" json:"count"`
+}
+
+func (WarehouseOutInfoSeven) TableName() string {
+	return "xt_warehouse_out_info"
+}
+
 type SalesReturn struct {
 	ID           int64  `gorm:"column:id" json:"id"`
 	OrderNumber  string `gorm:"column:order_number" json:"order_number"`
 	Count                   int64               `gorm:"column:count" json:"count"`
 	Type                    int64               `gorm:"column:type" json:"type"`
 	WarehouseOutInfo        []*WarehouseOutInfo `gorm:"ForeignKey:PatientId;AssociationForeignKey:PatientId" json:"warehouseOutInfo"`
+	ProjectId               int64               `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 func (AutomaticReduceDetail) TableName() string {
 	ProductDate             int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
 	ExpireDate              int64   `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
 	ReturnCount             int64   `gorm:"column:return_count" json:"return_count" form:"return_count"`
+	ProjectId               int64   `gorm:"column:project_id" json:"project_id" form:"project_id"`
 }
 
 func (VmStockFlow) TableName() string {
 	WarehouseInfoId int64              `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
 	GoodInfo        GoodInfo           `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
 	WarehousingInfo []*WarehousingInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:GoodId" json:"xt_warehouse_info"`
+	PatientId       int64              `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	RecordDate      int64              `gorm:"column:record_date" json:"record_date" form:"record_date"`
 }
 
 func (CancelStockInfo) TableName() string {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_models.go

 }
 
 type ScheduleVM struct {
-	ID           int64 `gorm:"column:id" json:"id"`
-	PatientID    int64 `gorm:"column:patient_id" json:"patient_id"`
-	ScheduleDate int64 `gorm:"column:schedule_date" json:"schedule_date"`
-	BedID        int64 `gorm:"column:bed_id" json:"bed_id"`
-	PartitionId  int64 `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
-
+	ID                       int64                            `gorm:"column:id" json:"id"`
+	PatientID                int64                            `gorm:"column:patient_id" json:"patient_id"`
+	ScheduleDate             int64                            `gorm:"column:schedule_date" json:"schedule_date"`
+	BedID                    int64                            `gorm:"column:bed_id" json:"bed_id"`
+	PartitionId              int64                            `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
 	Patient                  *PatientVM                       `gorm:"ForeignKey:PatientID" json:"patient"`
 	DialysisOrder            DialysisOrderVM                  `gorm:"ForeignKey:DialysisDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"dialysis_order"`
 	Prescription             PrescriptionVM                   `gorm:"ForeignKey:RecordDate,PatientID;AssociationForeignKey:ScheduleDate,PatientID" json:"prescription"`
 	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
 }
 
 func (ScheduleVM) TableName() string {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_service.go

 	for _, item := range schedules {
 
 		if orgID != 10101 {
-			dialysis_count, _ := GetDialysisOrderCount(orgID, item.PatientID, item.ScheduleDate)
+			dialysis_count, _ := GetDialysisOrderCountOne(orgID, item.PatientID, item.ScheduleDate)
 			item.Patient.TotalDialysis = dialysis_count
 		}
 		if orgID == 10101 {
 	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 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
 	return

service/stock_service.go

 
 }
 
-func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64, is_mark int64, manufacturer int64) (list []*models.GoodInfo, total int64, err error) {
+func FindGoodInfoList(orgId int64, page int64, limit int64, keyword string, is_use int64, is_charge int64, good_kind int64, is_mark int64, manufacturer int64, is_type int64) (list []*models.GoodInfo, total int64, err error) {
 	offset := (page - 1) * limit
 	db := readDb.Model(&models.GoodInfo{})
 	db = db.Where("org_id = ? AND status = 1", orgId)
 		if manufacturer > 0 {
 			db = db.Where("manufacturer = ?", manufacturer)
 		}
+		if is_type > 0 {
+			db = db.Where("good_type_id = ?", is_type)
+		}
 	} else {
 		if is_use > 0 {
 			if is_use == 1 {
 		if manufacturer > 0 {
 			db = db.Where("manufacturer = ?", manufacturer)
 		}
+		if is_type > 0 {
+			db = db.Where("good_type_id = ?", is_type)
+		}
 	}
 
 	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Find(&list).Error
 	return err
 }
 
+func GetWarehosueOutByStockFlow(patient_id int64, recrod_date int64, goodid int64) (stockflow []*models.VmStockFlow, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and system_time = ? and good_id = ? and consumable_type = 3 and status = 1", patient_id, recrod_date, goodid).Find(&stockflow).Error
+	return stockflow, err
+}
+
 func DeleteAutoRedeceDetailTen(orgid int64, patient_id int64, recordtime int64, goodid int64) error {
 
 	detail := models.BloodAutomaticReduceDetail{}
 	err = XTWriteDB().Model(&info).Where("org_id = ? and patient_id = ? and sys_record_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
 	prepare := models.DialysisBeforePrepare{}
 	err = XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
+	flow := models.VmStockFlow{}
+	err = XTWriteDB().Model(&flow).Where("user_org_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", orgid, patient_id, recordtime, goodid).Updates(map[string]interface{}{"status": 0, "count": 0}).Error
 	return err
 
 }
 
 func UpDateWarehouseInfoByStockDelete(id int64, count int64) (err error) {
+
 	err = writeDb.Model(&models.WarehousingInfo{}).Where("id = ?", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
 	return err
 }
 
+func GetCancelStockInfoByPatientId(patientid int64, goodid int64, record_date int64) (info []*models.CancelStockInfo, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and good_id = ? and record_date = ? and status = 1", patientid, goodid, record_date).Find(&info).Error
+	return info, err
+}
+
+func GetHisPrepscritionByPatientId(patientid int64, goodid int64, record_date int64) (list []*models.HisPrescriptionProject, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and project_id = ? and record_date = ? and status = 1", patientid, goodid, record_date).Find(&list).Error
+	return list, err
+}
+
 func UpDateWarehouStockFlowByStockDelete(id int64, recordtime int64, good_id int64, count int64, patient_id int64) (err error) {
 
 	err = writeDb.Model(&models.VmStockFlow{}).Where("warehousing_id = ? and system_time = ? and good_id = ? and patient_id = ?", id, recordtime, good_id, patient_id).UpdateColumn("count", gorm.Expr("count - ?", count)).Error
 	return &autoreduece, nil
 }
 
-func GetAutoRecordByGoodId(goodid int64, patientid int64, recorddate int64) (models.WarehouseOutInfo, error) {
-	detail := models.WarehouseOutInfo{}
-	err := XTReadDB().Model(&detail).Where("good_id = ? and patient_id = ? and sys_record_time = ? and status = 1", goodid, patientid, recorddate).Find(&detail).Error
+func GetAutoRecordByGoodIdSeven(goodid int64, patientid int64, recorddate int64) (models.WarehouseOutInfoSeven, error) {
+	detail := models.WarehouseOutInfoSeven{}
+	err := XTReadDB().Select("id,count").Where(" good_id = ? and sys_record_time = ?  and patient_id = ?  and status = 1", goodid, recorddate, patientid).Find(&detail).Error
+	return detail, err
+}
+
+func GetAutoRecordByGoodIdSevenEight(goodid int64, patientid int64, recorddate int64) (detail []*models.WarehouseOutInfoSeven, err error) {
+	err = XTReadDB().Select("id,count").Where("good_id = ? and sys_record_time = ?  and patient_id = ?  and status = 1", goodid, recorddate, patientid).Find(&detail).Error
 	return detail, err
 }
 
 	return info, err
 }
 
-func GetLastDrugWarehouseOutByDrugId(drugid int64, patient_id int64, advice_date int64) (models.DrugAutomaticReduceDetail, error) {
+func GetLastDrugWarehouseOutByDrugId(drugid int64, patient_id int64, advice_date int64, advice_id int64) (models.DrugAutomaticReduceDetail, error) {
 	detail := models.DrugAutomaticReduceDetail{}
-	err := XTReadDB().Model(&detail).Where("drug_id = ? and patient_id = ? and record_time = ? and status = 1", drugid, patient_id, advice_date).Last(&detail).Error
+	err := XTReadDB().Model(&detail).Where("drug_id = ? and patient_id = ? and record_time = ? and status = 1 and advice_id = ?", drugid, patient_id, advice_date, advice_id).Last(&detail).Error
 	return detail, err
 }
 

service/warhouse_service.go

 		var maxNumber int64 = 0
 		var minNumber int64 = 0
 
-		//fmt.Println("deliver_number23332323232333232323233232323232",deliver_number)
 		maxNumber = deliver_number / drup.MinNumber
-
-		if deliver_number <= drup.MinNumber {
-			minNumber = deliver_number % drup.MinNumber
-		} else {
-			minNumber = deliver_number
-		}
-
-		if deliver_number <= drup.MinNumber && warehouse.StockMaxNumber == 0 {
-			minNumber = deliver_number
-		}
+		minNumber = deliver_number % drup.MinNumber
 
 		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
 			minNumber = maxNumber
 				return errors.New("库存数量不足")
 			}
 		}
+		if minNumber != 0 {
+			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
+		}
 
-		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
-		//fmt.Println("最大单位23323232323232332323233232323",warehouse.StockMaxNumber)
 		if warehouse.StockMaxNumber < 0 {
 			warehouse.StockMaxNumber = 0
 		}
+		if warehouse.StockMinNumber < 0 {
+			warehouse.StockMinNumber = 0
+		}
 
 		warehouse.Mtime = time.Now().Unix()
-		//fmt.Println("最小单位2323223233232233233232323232323323232",warehouse.StockMinNumber)
-		//fmt.Println("最小换算量233232332322323322332323232332323223",minNumber)
+		fmt.Println("w23332233232232332", warehouse.StockMinNumber, minNumber)
+
 		if warehouse.StockMinNumber < minNumber {
+			fmt.Println("进来的风3232332322323")
 			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
 			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
 		} else {
-			//fmt.Println("hhhhhhhhhhhhhhhhhhhhhhhhh",warehouse.StockMinNumber,minNumber)
+			fmt.Println("进3232332322323")
 			warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
-			//fmt.Println("我的魏2232332322323323",warehouse.StockMinNumber)
+		}
+
+		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
+			fmt.Println("2223232332322323", warehouse.StockMinNumber)
+			warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
+
 		}
 
 		if drup.MaxUnit != drup.MinUnit {
 				return errors.New("库存数量不足")
 			}
 		}
+		if warehouse.StockMinNumber <= 0 {
+			warehouse.StockMinNumber = 0
+		}
 
 		//扣减库存232332332332
 		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
 				GoodTypeId: item.GoodTypeId,
 				GoodId:     item.GoodId,
 				Count:      item.Count,
+				ProjectId:  item.ProjectId,
 			}
 
 			ConsumablesDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
 //耗材出库
 func ConsumablesDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) {
 
+	fmt.Println("count23323223233232323232332232323", count, goods.Count)
 	var deliver_number int64 = 0
 	var stock_number int64 = 0
 	var maxNumber int64 = 0
 			Price:                   info.PackingPrice,
 			ExpiryDate:              warehouse.ExpiryDate,
 			ProductDate:             warehouse.ProductDate,
+			ProjectId:               goods.ProjectId,
 		}
 		warehouseOutInfo.Count = count
 
 			GoodId:                  goods.GoodId,
 			GoodTypeId:              goods.GoodTypeId,
 			Count:                   count,
+			ProjectId:               goods.ProjectId,
 		}
 		//查询当天耗材是否已经存在数据
 		_, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
 				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 				IsSys:                   1,
 				PatientId:               patient_id,
+				ProjectId:               goods.ProjectId,
 			}
 			//查询流水是否存在
 			exsit, errflow := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
 					IsSys:                   1,
 					PatientId:               patient_id,
 					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+					ProjectId:               goods.ProjectId,
 				}
 
 				errFour := UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
 				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 				IsSys:                   1,
 				PatientId:               patient_id,
+				ProjectId:               goods.ProjectId,
 			}
 			//查询流水是否存在
 			exsit, errflow := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
 					IsSys:                   1,
 					PatientId:               patient_id,
 					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+					ProjectId:               goods.ProjectId,
 				}
 				//UpdatedStockFlow(flow)
 				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
 			Price:                   info.PackingPrice,
 			ExpiryDate:              warehouse.ExpiryDate,
 			ProductDate:             warehouse.ProductDate,
+			ProjectId:               goods.ProjectId,
 		}
 		warehouseOutInfo.Count = stock_number
 
 				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 				IsSys:                   1,
 				PatientId:               patient_id,
+				ProjectId:               goods.ProjectId,
 			}
 			//查询流水是否存在
 			exsit, errflows := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
 					IsSys:                   1,
 					PatientId:               patient_id,
 					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+					ProjectId:               goods.ProjectId,
 				}
 				//UpdatedStockFlow(flow)
 				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
 				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 				IsSys:                   1,
 				PatientId:               patient_id,
+				ProjectId:               goods.ProjectId,
 			}
 			//查询流水是否存在
 			exsit, errflows := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					IsSys:                   1,
 					PatientId:               patient_id,
+					ProjectId:               goods.ProjectId,
 				}
 				//UpdatedStockFlow(flow)
 				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
 			PatientId:               advice.PatientId,
 			Count:                   deliver_number, //出最小单位
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			IsSys:                   1,
 			PatientId:               advice.PatientId,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			PatientId:               advice.PatientId,
 			Count:                   deliver_number,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
 		if errOne != nil {
 			IsSys:                   1,
 			PatientId:               advice.PatientId,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			PatientId:               advice.PatientId,
 			WarehouseInfoId:         warehouse.ID,
 			Count:                   deliver_number,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			PatientId:               advice.PatientId,
 			SystemTime:              advice.RecordDate,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
 		if errTwo != nil {
 		if warehouse.StockMaxNumber < 0 {
 			return errors.New("库存数量不足")
 		}
+		if warehouse.StockMinNumber <= 0 {
+			warehouse.StockMinNumber = 0
+		}
 
 		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
 
 			WarehouseInfoId:         warehouse.ID,
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
+			AdviceId:                advice.ID,
 		}
 
 		drugflow := models.DrugFlow{
 			PatientId:               advice.PatientId,
 			SystemTime:              advice.RecordDate,
 			WarehousingDetailId:     warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 
 		CreateDrugFlowOne(drugflow)
 			Count:                   deliver_number,
 			CountUnit:               drup.MinUnit,
 			WarehouseInfoId:         warehouse.ID,
+			AdviceId:                advice.ID,
 		}
 		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
 		if errTwo != nil {