11月8日库存管理

controllers/device_api_controller.go

 	number.ZoneID = zoneID
 	number.GroupID = groupID
 	number.Sort = sort
-	byName, _ := service.GetDeviceNumberByName(num, adminInfo.CurrentOrgId)
+	byName, _ := service.GetDeviceNumberByName(num, zoneID, adminInfo.CurrentOrgId)
 	if byName.ID > 0 && byName.ID != id {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDataException)
 		return

controllers/drug_stock_api_contorller.go

 
 				dealer := int64(items["dealer"].(float64))
 
+				if items["retail_price"] == nil || reflect.TypeOf(items["retail_price"]).String() != "string" {
+					utils.ErrorLog("retail_price")
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+					return
+				}
+				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
+
 				warehouseInfo := &models.DrugWarehouseInfo{
 					WarehousingOrder: warehousing.WarehousingOrder,
 					WarehousingId:    warehousing.ID,
 					BatchNumber:      batch_number,
 					MaxUnit:          max_unit,
 					MinUnit:          min_unit,
+					RetailPrice:      retail_price,
+				}
+
+				if max_unit == min_unit {
+					warehouseInfo.StockMaxNumber = 0
+					warehouseInfo.StockMinNumber = warehousing_count
+					warehouseInfo.MaxUnit = min_unit
 				}
 				warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 					IsSys:            0,
 				}
 
+				if max_unit == min_unit {
+					drugflow.MaxUnit = min_unit
+				}
 				drugFlow = append(drugFlow, drugflow)
 
 			}
 	}
 
 	adminUserInfo := c.GetAdminUserInfo()
-	fmt.Println("hhh2h3h23h2h32h3h2h32h32h3h2h3", keywords)
 	//按药品名称搜索
 	var ids []int64
 	var idArray []int64
 
 				retail_price_total := float64(warehousing_count) * last_price
 
+				retail_price, _ := strconv.ParseFloat(items["retail_price"].(string), 64)
+
 				var productDates int64
 				var expiryDates int64
 
 						Type:             types,
 						Manufacturer:     manufacturer,
 						Dealer:           dealer,
-						RetailPrice:      last_price,
+						RetailPrice:      retail_price,
 						RetailTotalPrice: retail_price_total,
 						BatchNumber:      batch_number,
 						MaxUnit:          max_unit,
 						MinUnit:          min_unit,
 						StockMaxNumber:   warehousing_count,
 					}
+					if max_unit == min_unit {
+						warehouseInfo.StockMaxNumber = 0
+						warehouseInfo.StockMinNumber = warehousing_count
+						warehouseInfo.MaxUnit = min_unit
+					}
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 				} else {
 						Type:             types,
 						Manufacturer:     manufacturer,
 						Dealer:           dealer,
-						RetailPrice:      last_price,
+						RetailPrice:      retail_price,
 						RetailTotalPrice: retail_price_total,
 						MaxUnit:          max_unit,
 						MinUnit:          min_unit,
 						BatchNumber:      batch_number,
 					}
+					if max_unit == min_unit {
+						warehouseInfo.StockMaxNumber = 0
+						warehouseInfo.StockMinNumber = warehousing_count
+						warehouseInfo.MaxUnit = min_unit
+					}
+
 					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
 
 					drugflow := &models.DrugFlow{
 					IsSys:               0,
 					WarehousingDetailId: info.ID,
 				}
+				if info.MaxUnit == info.MinUnit {
+					flows.MaxUnit = info.MinUnit
+				}
 				_, existerrcodes := service.GetDrugFlowIsExist(info.ID, info.DrugId)
 
 				if existerrcodes == gorm.ErrRecordNotFound {
 			//历史入库总数
 			total = orderInfo.StockMaxNumber * info.MinNumber
 
-			//当前入库总数
 			allTotal = item.WarehousingCount * info.MinNumber
 
 			//如果历史的入库总数 大于当前入库总数 则需要扣减
 							BatchNumber:  it.BatchNumber,
 							Price:        it.Price,
 						}
+						if info.MaxUnit == info.MinUnit {
+							flow.MaxUnit = info.MinUnit
+						}
 						parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, warehouseInfo.WarehousingId)
 						fmt.Println(parseDateErr)
 
 					for _, it := range drugFlow {
 						fmt.Println(it)
 						flow := models.DrugFlow{
-							Count: item.StockMaxNumber,
+							Count:   item.StockMaxNumber,
+							MaxUnit: item.MaxUnit,
+							MinUnit: item.MinUnit,
 						}
 						parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, warehouseInfo.WarehousingId)
 						fmt.Println(parseDateErr)
 					Manufacturer: item.Manufacturer,
 					Remark:       item.Remark,
 					BatchNumber:  item.BatchNumber,
+					MaxUnit:      item.MaxUnit,
+					MinUnit:      item.MinUnit,
+					RetailPrice:  item.RetailPrice,
 				}
 				errs = service.UpDateDrugWarehousingInfoTwo(item.ID, warehouseinfo)
 			}
 		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
 		var total_count int64
 		total_count = infoWareInfo.WarehousingCount * medical.MinNumber
-		fmt.Println("当前批次总库存", total_count)
 
 		//查询该批次的出库数量
 		outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
 			})
 			return
 		}
-
+		fmt.Println("当前退库数", total_count)
+		fmt.Println("当前批次总库存", total_count)
+		fmt.Println("总出库数", out_number)
 		//判断退库数量是否大于总入库数量
 		if total_number > total_count {
 			service.UpdateDrugCancel(item.CancelStockId)
 	}
 
 	idArray := strings.Split(ids, ",")
+	//获取入库数据
+	list, _ := service.GetDrugWareInfoByCancelId(idArray)
+	for _, item := range list {
+		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+		if item.MaxUnit == medical.MaxUnit {
+			//回退库存
+			service.ModifyDrugWarehouseByInfoId(item.CancelStockId, item.Count)
+		}
+		if item.MaxUnit == medical.MinUnit {
+			service.ModifyDrugWarehouseByStockMin(item.CancelStockId, item.Count)
+		}
+	}
 	err := service.DeleteDrugCancelStock(idArray)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDeleteFail)
 }
 func (this *StockDrugApiController) DeleteDrugCancelStockInfo() {
 	id, _ := this.GetInt64("id", 0)
-	fmt.Println(id)
+
 	if id == 0 {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 		return

controllers/his_api_controller.go

 										number_count = prescribingNumberInt
 									}
 
-									fmt.Println("以前出库数量23323232322332323223233223232332", device_number)
-									fmt.Println("现在出库数量", number_count)
 									//如果修改的数量大于之前修改的数量
 									if (number_count - device_number) > 0 {
 										//如果修改的差数量 大于库存数量
 
 										// 查询该药品最后一次出库记录
 										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 {
 
 											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)
 											}
 										}
 									project_name = project.(map[string]interface{})["project_name"].(string)
 
 								}
-								fmt.Println("id3232322332232323323223322323", id)
 								if project_type == 3 {
 
 									//查找该耗材的出库记录
 										}
 										//查找今日该患者已经出库的所有耗材
 										goodList, _ := service.GetAllAutoRecordByPatient(patient_id, recordDateTime)
-										fmt.Println("goodList3323223232323232323", goodList)
+
 										for _, item := range goodList {
 											//回退库存
 											service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)
 									if len(goodWarehouseInfo) > 0 {
 										//查询该患者耗材的历史数据
 										ordProject, _ := service.GetHisProjectPrescriptionByPatientIdOne(id)
-										fmt.Println("ordOr2323233232323232323223232", ordProject)
+
 										count, _ := strconv.ParseInt(ordProject.Count, 10, 64)
-										fmt.Println("id3232322332232323323223322323", id)
-										fmt.Println("parsetotal33223232323232323", parsetotal)
-										fmt.Println("count2332322332232332", count)
+
 										//数量发生改变
 										if parsetotal != count {
 											//查找今日该患者已经出库的所有耗材
 											goodList, _ := service.GetAllAutoRecordByPatient(patient_id, recordDateTime)
-											fmt.Println("goodList3323223232323232323", goodList)
+
 											for _, item := range goodList {
 												//回退库存
 												service.ModefyWarehouseInfo(item.Count, item.WarehouseInfotId)

controllers/new_mobile_api_controllers/staff_schedule_api_controller.go

 	return
 
 }
+
+func (c *StaffScheduleApiController) GetSolutionSchedule() {
+
+	orgId := c.GetMobileAdminUserInfo().Org.Id
+	solution, _ := service.GetSolutionSchedule(orgId)
+	c.ServeSuccessJSON(map[string]interface{}{
+		"solution": solution,
+	})
+}

controllers/new_mobile_api_controllers/staff_schedule_api_router.go

 	beego.Router("/m/api/updateschedule", &StaffScheduleApiController{}, "Get:UpdateBloodSchedule")
 	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")
 }

controllers/patient_dataconfig_api_controller.go

 	patientID, _ := this.GetInt64("patient_id")
 	fmt.Println(patientID)
 	content := this.GetString("content")
-	fmt.Println("content22222222222222222222", content)
+
 	record_time_str := this.GetString("record_time")
 	title := this.GetString("title")
 

controllers/print_data_api_controller.go

 		}
 		if this.GetAdminUserInfo().CurrentOrgId == 10101 || this.GetAdminUserInfo().CurrentOrgId == 9671 {
 			listOne, _ := service.GetDialysisOrderCountEight(adminUserInfo.CurrentOrgId, item.PatientID, item.ScheduleDate)
-			fmt.Println("lisntONE2323223323232", listOne.Count)
+
 			item.Patient.TotalDialysis = listOne.Count
 			item.Count = listOne.Count
 		}
 	adminUserInfo := this.GetAdminUserInfo()
 	patient_id, _ := this.GetInt64("patient_id")
 
-	//timeLayout := "2006-01-02 15:04:05"
 	record, err := service.GetPatientCoursesRecords(adminUserInfo.CurrentOrgId, ids_arr)
-	//dataTimeStr := time.Unix(record.RecordTime, 0).Format(timeLayout) //设置时间戳 使用模板格式化为日期字符串
-	//tempTime := strings.Split(dataTimeStr, " ")
-	//
-	//recordDate, parseDateErr := utils.ParseTimeStringToTime("2006-01-02", tempTime[0])
-	//if parseDateErr != nil {
-	//	this.ErrorLog("日期(%v)解析错误：%v", tempTime[0], parseDateErr)
-	//	//this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
-	//	//return
-	//}
 
 	//patient, _ := service.FindPatientWithDeviceById(adminUserInfo.CurrentOrgId, patient_id)
 	patient, _ := service.GetPatientDetail(adminUserInfo.CurrentOrgId, patient_id)

controllers/schedule_api_controller.go

 	theEndTime, _ := time.ParseInLocation(timeLayout, weekEndTime, loc)
 	weekStartPoint := theStarTime.Unix()
 	weekEndPoint := theEndTime.Unix()
-	fmt.Println("startTime222222222222222", weekStartPoint)
-	fmt.Println("endtime33333333333333", weekEndPoint)
+
 	list, err := service.GetPatientScheduleCount(orgId, weekStartPoint, weekEndPoint, ids)
 	_, total, _ := service.GetTotalBedNumber(orgId, ids)
 	if err != nil {
 
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	solution, _ := service.GetSolutionSchedule(orgId)
-	fmt.Println("solution33232323223233233323232332323232", solution)
+
 	c.ServeSuccessJSON(map[string]interface{}{
 		"solution": solution,
 	})

models/patient_models.go

 func (XtHospitalSummary) TableName() string {
 	return "xt_hospital_summary"
 }
+
+type VmDialysisSolution struct {
+	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"`
+	DialysisDialyszers         string                `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation         string                `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialyzerPerfusionApparatus string                `gorm:"column:dialyzer_perfusion_apparatus" json:"dialyzer_perfusion_apparatus"`
+	ModeName                   string                `gorm:"column:mode_name" json:"mode_name" form:"mode_name"`
+	ModeId                     int64                 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Anticoagulant              int64                 `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
+	DialysisSolution           VmDialysisSolutionOne `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"solution"`
+}
+
+func (VmDialysisSolution) TableName() string {
+	return "xt_dialysis_solution"
+}
+
+type VmDialysisSolutionOne struct {
+	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"`
+	DialysisDialyszers         string `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation         string `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialyzerPerfusionApparatus string `gorm:"column:dialyzer_perfusion_apparatus" json:"dialyzer_perfusion_apparatus"`
+	ModeName                   string `gorm:"column:mode_name" json:"mode_name" form:"mode_name"`
+	ModeId                     int64  `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+}
+
+func (VmDialysisSolutionOne) TableName() string {
+	return "xt_dialysis_solution"
+}
+
+type VmDialysisPrescription struct {
+	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"`
+	DialysisDialyszers         string `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
+	DialysisIrrigation         string `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialyzerPerfusionApparatus string `gorm:"column:dialyzer_perfusion_apparatus" json:"dialyzer_perfusion_apparatus"`
+	ModeName                   string `gorm:"column:mode_name" json:"mode_name" form:"mode_name"`
+	ModeId                     int64  `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	Anticoagulant              int64  `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
+}
+
+func (VmDialysisPrescription) TableName() string {
+	return "xt_dialysis_prescription"
+}

models/self_drug_models.go

 	StockMaxNumber    int64      `gorm:"column:stock_max_number" json:"stock_max_number"`
 	StockMinNumber    int64      `gorm:"column:stock_min_number" json:"stock_min_number"`
 	BatchNumber       string     `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
+	MinUnit           string     `gorm:"column:min_unit" json:"max_unit" form:"min_unit"`
 	MaxUnit           string     `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
 	WarehousingInfoId int64      `gorm:"column:warehousing_info_id" json:"warehousing_info_id" form:"warehousing_info_id"`
 	XtBaseDrug        XtBaseDrug `gorm:"ForeignKey:ID;AssociationForeignKey:DrugId" `

service/device_service.go

 	return &numberModel, nil
 }
 
-func GetDeviceNumberByName(num string, orgid int64) (number models.DeviceNumber, err error) {
+func GetDeviceNumberByName(num string, zoneId int64, orgid int64) (number models.DeviceNumber, err error) {
 
-	err = XTReadDB().Model(&number).Where("number = ? and org_id = ? and status =1", num, orgid).First(&number).Error
+	err = XTReadDB().Model(&number).Where("number = ? and zone_id = ? and org_id = ? and status =1", num, zoneId, orgid).First(&number).Error
 	return number, err
 }
 

service/manage_center_service.go

 	}
 
 	if is_use != 0 {
-		if is_use == 1 {
+		if is_use == 2 {
 			db = db.Where("find_in_set('停用',drug_status) = 0")
 
 		} else {
 		}
 	}
 
-	if is_charge != 0 {
-		//db = db.Where("drug_name Like ?", keyword)
-		if is_charge == 1 {
-			db = db.Where("find_in_set('收费',drug_status) > 0")
+	if is_charge == 1 {
+		//if is_charge == 1 {
+		//	db = db.Where("find_in_set('收费',drug_status) > 0")
+		//
+		//} else {
+		//	db = db.Where("find_in_set('收费',drug_status) = 0")
+		//}
+		db = db.Where("is_record = ?", is_charge)
+	}
 
-		} else {
-			db = db.Where("find_in_set('收费',drug_status) = 0")
-		}
+	if is_charge == 2 {
+		db = db.Where("is_record= 0 || is_record = 2")
 	}
 
 	if is_inject != 0 {

service/print_data_service/schedule_dialysis/print_schedule_dialysis_service.go

 		Preload("HisPrescriptionProject", func(db *gorm.DB) *gorm.DB {
 			return db.Where("user_org_id = ? AND status = 1", orgID).Preload("HisProject").Preload("GoodInfo", "status=1")
 		}).
-		Where("user_org_id = ? AND status = 1 AND id in (?)", orgID, schIDs).Order("schedule_date desc").
+		Where("user_org_id = ? AND status = 1 AND id in (?)", orgID, schIDs).Order("schedule_date asc").
 		Find(&schedules).
 		Error
 	if err != nil {
 
 func GetPatientCoursesRecords(orgID int64, id []string) (records []*models.PatientDiseaseCourse, err error) {
 	db := p_service.XTReadDB()
-	err = db.Model(&models.PatientDiseaseCourse{}).Where("org_id = ? and id in(?) and status = 1", orgID, id).Find(&records).Error
+	err = db.Model(&models.PatientDiseaseCourse{}).Where("org_id = ? and id in(?) and status = 1", orgID, id).Order("record_time desc").Find(&records).Error
 	return
 }
 

service/schedule_service.go

 	return mode, err
 }
 
-func GetSolutionSchedule(orgid int64) (solution []*models.DialysisSolution, err error) {
+func GetSolutionSchedule(orgid int64) (solution []*models.VmDialysisSolution, err error) {
 
-	err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Group("patient_id,mode_id").Order("created_time desc").Find(&solution).Error
+	err = XTReadDB().Where("user_org_id = ? and status = 1", orgid).Group("patient_id,mode_id").Order("created_time desc").Preload("DialysisSolution", func(db *gorm.DB) *gorm.DB {
+		return db.Where("user_org_id = ? and status = 1", orgid).Order("id asc")
+	}).Find(&solution).Error
 	return solution, err
 }

service/self_drug_service.go

 	return drug, err
 }
 
+func ModifyDrugWarehouseByInfoId(id int64, stock_max_number int64) error {
+	info := models.DrugWarehouseInfo{}
+	err := XTWriteDB().Model(&info).Where("id = ?", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number - ?", stock_max_number)).Error
+	return err
+}
+
+func ModifyDrugWarehouseByStockMin(id int64, stock_min_number int64) error {
+	info := models.DrugWarehouseInfo{}
+	err := XTWriteDB().Model(&info).Where("id = ?", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number - ?", stock_min_number)).Error
+	return err
+}
+
 func GetSelfMedicalByDrugName(drugname string, drug_spec string, patientid int64) (*models.XtSelfMedical, error) {
 	medical := models.XtSelfMedical{}
 	err := XTReadDB().Model(&medical).Where("drug_name = ? and drug_spec = ? and patient_id = ? and status = 1", drugname, drug_spec, patientid).Find(&medical).Error

service/stock_service.go

 		likeKey := "%" + keyword + "%"
 		db = db.Where("good_code LIKE ? OR good_name LIKE ?", likeKey, likeKey)
 		if is_use > 0 {
-			if is_use == 1 {
+			if is_use == 2 {
 				db = db.Where("find_in_set('停用',good_status) = 0")
 			} else {
 				db = db.Where("find_in_set('停用',good_status) > 0")
 		}
 	} else {
 		if is_use > 0 {
-			if is_use == 1 {
+			if is_use == 2 {
 				db = db.Where("find_in_set('停用',good_status) = 0")
 			} else {
 				db = db.Where("find_in_set('停用',good_status) > 0")
 	if len(warehousingInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(warehousingInfo) > 0 {
-			thisSQL := "INSERT INTO xt_drug_warehouse_info (warehousing_id, drug_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,retail_price,retail_total_price,stock_max_number,max_unit,min_unit,batch_number) VALUES "
+			thisSQL := "INSERT INTO xt_drug_warehouse_info (warehousing_id, drug_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,retail_price,retail_total_price,stock_max_number,max_unit,min_unit,batch_number,stock_min_number) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range warehousingInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.WarehousingId)
 				insertData = append(insertData, info.DrugId)
 				insertData = append(insertData, info.Number)
 				insertData = append(insertData, info.MaxUnit)
 				insertData = append(insertData, info.MinUnit)
 				insertData = append(insertData, info.BatchNumber)
+				insertData = append(insertData, info.StockMinNumber)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 	RetailPrice      float64 `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
 	RetailTotalPrice float64 `gorm:"column:retail_total_price" json:"retail_total_price" form:"retail_total_price"`
 	BatchNumber      string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
+	MaxUnit          string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit          string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
 	Drug             *Drug   `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug"`
 }
 
 }
 
 func UpDateDrugWarehousingInfoTwo(id int64, info *models.DrugWarehouseInfo) (err error) {
-	err = writeDb.Model(&info).Where("id= ? and status = 1", id).Updates(map[string]interface{}{"number": info.Number, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "price": info.Price, "total_price": info.TotalPrice, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "remark": info.Remark, "batch_number": info.BatchNumber}).Error
+	err = writeDb.Model(&info).Where("id= ? and status = 1", id).Updates(map[string]interface{}{"number": info.Number, "product_date": info.ProductDate, "expiry_date": info.ExpiryDate, "price": info.Price, "total_price": info.TotalPrice, "dealer": info.Dealer, "manufacturer": info.Manufacturer, "remark": info.Remark, "batch_number": info.BatchNumber, "max_unit": info.MaxUnit, "min_unit": info.MinUnit, "retail_price": info.RetailPrice}).Error
 	return err
 }
 
 	return info, err
 }
 
-func GetDrugWarehouseOrder(id int64) (models.DrugWarehouseInfo, error) {
-
-	info := models.DrugWarehouseInfo{}
-	err = XTReadDB().Model(&info).Where("id = ?", id).Find(&info).Error
-	return info, err
-}
-
 func EditWarehousing(warehouse models.Warehousing) {
 	err = readDb.Model(&models.Warehousing{}).Where("warehousing_order = ? AND status = 1", warehouse.WarehousingOrder).Update(map[string]interface{}{"mtime": time.Now().Unix(), "warehousing_time": warehouse.WarehousingTime, "modifier": warehouse.Modifier, "dealer": warehouse.Dealer, "manufacturer": warehouse.Manufacturer}).Error
 
 	return
 }
 
+func GetDrugWareInfoByCancelId(ids []string) (info []*models.DrugCancelStockInfo, err error) {
+	err = XTReadDB().Where("cancel_stock_id IN(?) and status = 1", ids).Find(&info).Error
+	return info, err
+}
+
 func DeleteDrugCancelStock(ids []string) (err error) {
 	ut := writeDb.Begin()
 	err = ut.Model(&models.DrugCancelStock{}).Where("id IN (?)", ids).Updates(map[string]interface{}{"status": 0, "mtime": time.Now().Unix()}).Error
 func UpdateDrugFlow(flow models.DrugFlow, drugid int64, warehousing_id int64) error {
 
 	drugFlow := models.DrugFlow{}
-	err := XTWriteDB().Model(&drugFlow).Where("drug_id = ? and warehousing_id= ? and status = 1", drugid, warehousing_id).Updates(map[string]interface{}{"count": flow.Count}).Error
+	err := XTWriteDB().Model(&drugFlow).Where("drug_id = ? and warehousing_id= ? and status = 1", drugid, warehousing_id).Updates(map[string]interface{}{"count": flow.Count, "max_unit": flow.MaxUnit, "min_unit": flow.MinUnit}).Error
 	return err
 }