耗材参数

controllers/drug_stock_api_contorller.go

 			}
 
 			if medical.MinUnit == item.CountUnit {
-				max_number = outInfo.Count
+				max_number = item.Count
 			}
 
 			all_number = info.Count*medical.MinNumber + info.StockMinNumber
 			fmt.Println("总库存223232", all_number)
-			fmt.Println("当前库存", max_number)
+			fmt.Println("当前库存00000000000000000000000000000000000000000", max_number)
 			////比较当前出库数量 和 最后一次出库数量,正常出库
 			if max_number <= min_number {
 				errs = service.UpDateDrugWarehouseOutInfo(item)
 				cha_number = min_number - max_number
 				fmt.Println("差库存", cha_number)
-				fmt.Println("最后一次库存", min_number)
+				fmt.Println("最后一次库存0000000000000000000000000000000000000000", min_number)
 				if item.CountUnit == medical.MaxUnit {
 					maxNumber = cha_number / medical.MinNumber
 					parseDateErr := service.UpdateWarehouseInfo(maxNumber, item.DrugId, item.OrgId)
 
 			}
 
+			fmt.Println("当前出库", max_number)
+			fmt.Println("最后一次232233", min_number)
 			//退库操作
 			if max_number > min_number {
+
 				cha_number = min_number - max_number
 				//如果总库存大于差,正常出库
 				if all_number >= cha_number {
-					fmt.Println("金立2323323322323233232323", all_number, cha_number)
+
 					errs = service.UpDateDrugWarehouseOutInfo(item)
 					fmt.Println("232322332233232", item.CountUnit, medical.MaxUnit)
 					if item.CountUnit == medical.MaxUnit {
 				batch_number := items["batch_number"].(string)
 				max_unit := items["max_unit"].(string)
 				batch_number_id := int64(items["batch_number_id"].(float64))
+
+				fmt.Println("99999999999999999999", batch_number_id)
 				cancelStockInfo := &models.DrugCancelStockInfo{
 					OrderNumber:      cancelStock.OrderNumber,
 					CancelStockId:    cancelStock.ID,
 	}
 	//扣减库存逻辑
 	for _, item := range cancelStockInfos {
+		var total_number int64
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
-		//查询当前药品退库的批次号的总入库数
-		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
-		fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit)
-		var total_count int64
+		//将当前退库数转为最小单位
 		if item.MaxUnit == medical.MaxUnit {
-			total_count = infoWareInfo.WarehousingCount
-			fmt.Println("进来了吗发大发阿道夫阿方阿道夫撒发大发阿方阿方阿方阿道夫阿方暗示法", total_count)
+			total_number = item.Count * medical.MinNumber
 		}
-		//转化为最小库存
 		if item.MaxUnit == medical.MinUnit {
-			total_count = infoWareInfo.WarehousingCount * medical.MinNumber
+			total_number = item.Count
 		}
-		fmt.Println("itme.count2323232323232323232332", item.Count)
-		fmt.Println("23232322322323232332", total_count)
+		fmt.Println("当前库存", total_number)
+		//查询当前药品退库的批次号的总入库数
+		infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
+		fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit, infoWareInfo.StockMaxNumber, infoWareInfo.StockMinNumber)
+		var total_count int64
+		total_count = infoWareInfo.StockMaxNumber*medical.MinNumber + infoWareInfo.StockMinNumber
+		fmt.Println("当前批次总库存", total_count)
+
 		//判断退库数量是否大于总入库数量
-		if item.Count > total_count {
+		if total_number > total_count {
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg": "2",
 			})
 			return
 		}
 		//正常退库
-		if item.Count <= infoWareInfo.WarehousingCount {
+		if total_number <= total_count {
 			//创建退库详情
 			errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
 			//创建库存明细
 			errs = service.CreateDrugFlow(drugFlow)
 
 			var total int64
-			//退库到当前批次,获取当前退库批次的库存
-			info, _ := service.GetDrugWarehouseInfoById(item.BatchNumberId)
+			////退库到当前批次,获取当前退库批次的库存
+			//info, _ := service.GetDrugWarehouseInfoById(item.BatchNumberId)
 
-			if info.MaxUnit == item.MaxUnit {
-				total = item.Count + info.StockMaxNumber
+			if medical.MaxUnit == item.MaxUnit {
+				total = item.Count
 
 				warehouseInfo := models.XtDrugWarehouseInfo{
 					StockMaxNumber: total,
 				})
 			}
 			if medical.MinUnit == item.MaxUnit {
-				total = item.Count + info.StockMinNumber
+				fmt.Println("hhhhhh2323323232322332232332999999999进来", item.Count)
+				total = item.Count
 				warehouseInfo := models.XtDrugWarehouseInfo{
 					StockMinNumber: total,
 				}
 			infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
 			fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit)
 			var total_count int64
+			total_count = infoWareInfo.StockMaxNumber*medical.MinNumber + infoWareInfo.StockMinNumber
+			//转化为最小单位
+			var total_number int64
 			if item.MaxUnit == medical.MaxUnit {
-				total_count = infoWareInfo.WarehousingCount
+				total_number = item.Count * medical.MinNumber
 			}
-			//转化为最小库存
 			if item.MaxUnit == medical.MinUnit {
-				total_count = infoWareInfo.WarehousingCount * medical.MinNumber
+				total_number = item.Count
 			}
+			//if item.MaxUnit == medical.MaxUnit {
+			//	total_count = infoWareInfo.WarehousingCount
+			//}
+			////转化为最小库存
+			//if item.MaxUnit == medical.MinUnit {
+			//	total_count = infoWareInfo.WarehousingCount * medical.MinNumber
+			//}
 			//判断退库数量是否大于总入库数量
-			if item.Count > total_count {
+			if total_number > total_count {
 				c.ServeSuccessJSON(map[string]interface{}{
 					"msg": "2",
 				})
 				return
 			}
+
 			//正常退库
-			if item.Count <= infoWareInfo.WarehousingCount {
+			if total_number <= total_count {
 				//创建退库详情
 				errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
 				//创建库存明细
 				errs = service.CreateDrugFlow(drugFlow)
 
+				//获取该批次最后一条退库详情
+				lastCancel, _ := service.GetLastCancelStockInfo(id)
+				var cancel_number int64
+				if lastCancel.MaxUnit == medical.MaxUnit {
+					cancel_number = lastCancel.Count * medical.MinNumber
+				}
+
+				if lastCancel.MaxUnit == medical.MinUnit {
+					cancel_number = lastCancel.Count
+				}
+				fmt.Println("999999232323232232232323232323", lastCancel)
 				var total int64
-				//退库到当前批次,获取当前退库批次的库存
-				info, _ := service.GetDrugWarehouseInfoById(item.BatchNumberId)
 
-				if info.MaxUnit == item.MaxUnit {
-					total = item.Count + info.StockMaxNumber
+				if medical.MaxUnit == item.MaxUnit {
+					total = item.Count - cancel_number
 
 					warehouseInfo := models.XtDrugWarehouseInfo{
 						StockMaxNumber: total,
 					})
 				}
 				if medical.MinUnit == item.MaxUnit {
-					total = item.Count + info.StockMinNumber
+					total = item.Count - cancel_number
 					warehouseInfo := models.XtDrugWarehouseInfo{
 						StockMinNumber: total,
 					}

controllers/mobile_api_controllers/patient_api_controller.go

 								prescribing_number_total = count * medical.MinNumber
 							}
 							if medical.MinUnit == item.PrescribingNumberUnit {
-								total = list.Count
-								prescribing_number_total = list.Count
+								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
+								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+								total = list.Count*medical.MinNumber + list.StockMinNumber
+								prescribing_number_total = count
 							}
 
 							fmt.Println("数量一", prescribing_number_total)
 							fmt.Println("数量二", total)
 
-							if list.Count == 0 {
+							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 								c.ServeSuccessJSON(map[string]interface{}{
 									"msg":    "3",
 									"advice": advice,
 								prescribing_number_total = count * medical.MinNumber
 							}
 							if medical.MinUnit == item.PrescribingNumberUnit {
-								total = list.Count
-								prescribing_number_total = list.Count
+								prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
+								count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+								total = list.Count*medical.MinNumber + list.StockMinNumber
+								prescribing_number_total = count
 							}
 
 							fmt.Println("数量一", prescribing_number_total)
 							fmt.Println("数量二", total)
 
-							if list.Count == 0 {
+							if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 								c.ServeSuccessJSON(map[string]interface{}{
 									"msg":    "3",
 									"advice": advice,
 					prescribing_number_total = count * medical.MinNumber
 				}
 				if medical.MinUnit == advice.PrescribingNumberUnit {
-					total = list.Count
-					prescribing_number_total = list.Count
+					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
+					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+					total = list.Count*medical.MinNumber + list.StockMinNumber
+					prescribing_number_total = count
 				}
 
 				fmt.Println("数量一", prescribing_number_total)
 				fmt.Println("数量二", total)
 
-				if list.Count == 0 {
+				if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 					c.ServeSuccessJSON(map[string]interface{}{
 						"msg":    "3",
 						"advice": advice,

controllers/patient_api_controller.go

 		fmt.Println("999999992322322323232", drugStockConfig.IsOpen)
 		//自备药信息
 		privateDrugConfig, _ := service.GetDrugSetByUserOrgId(adminUserInfo.CurrentOrgId)
-
+		fmt.Println("drugStockConfig2323232332232332", drugStockConfig.IsOpen)
 		if drugStockConfig.IsOpen == 1 {
-
+			var total int64
+			var prescribing_number_total int64
 			advices, _ := service.GetExecutionDoctors(adminUserInfo.CurrentOrgId, patient, id)
 			for _, item := range advices {
 				fmt.Println("imte00000000000000", item.PrescribingNumber)
-
 				//查询该药品是否有库存
 				list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
-				prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
-				count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
-				if list.Count == 0 {
+				fmt.Println("list23232323232232323232323232", list)
+				//查询改药品信息
+				medical, _ := service.GetBaseDrugMedical(item.DrugId)
+				//判断单位是否相等
+				if medical.MaxUnit == item.PrescribingNumberUnit {
+					prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
+					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+					//转化为最小单位
+					total = list.Count * medical.MinNumber
+					prescribing_number_total = count * medical.MinNumber
+				}
+				if medical.MinUnit == item.PrescribingNumberUnit {
+					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
+					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+					total = list.Count*medical.MinNumber + list.StockMinNumber
+					prescribing_number_total = count
+				}
+
+				fmt.Println("数量一", prescribing_number_total)
+				fmt.Println("数量二", total)
+
+				if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 					c.ServeSuccessJSON(map[string]interface{}{
-						"msg":    "1",
+						"msg":    "3",
 						"advice": advice,
 					})
 					return
 				}
-				if count > list.Count {
+				if prescribing_number_total > total {
 					c.ServeSuccessJSON(map[string]interface{}{
 						"msg":    "2",
 						"advice": advice,
 					})
 					return
 				}
-				//调用药品出库接口
-				service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
+				if prescribing_number_total <= total {
+					service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
+					break
+					c.ServeSuccessJSON(map[string]interface{}{
+						"msg":    "1",
+						"advice": advice,
+					})
+					return
+				}
+
+				////查询该药品是否有库存
+				//list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
+				//prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
+				//count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+				//if list.Count == 0 {
+				//	c.ServeSuccessJSON(map[string]interface{}{
+				//		"msg":    "1",
+				//		"advice": advice,
+				//	})
+				//	return
+				//}
+				//if count > list.Count {
+				//	c.ServeSuccessJSON(map[string]interface{}{
+				//		"msg":    "2",
+				//		"advice": advice,
+				//	})
+				//	return
+				//}
+				////调用药品出库接口
+				//service.DrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
 
 			}
 		}
 		}
 
 		c.ServeSuccessJSON(map[string]interface{}{
-			"msg":    "ok",
+			"msg":    "1",
 			"advice": advice,
 		})
 		return
 			//查询已经执行的医嘱
 			advices, _ := service.GetHisExecutionDoctors(adminUserInfo.CurrentOrgId, patient, id)
 			for _, item := range advices {
+				var total int64
+				var prescribing_number_total int64
 				//查询该药品是否有库存
-				list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
-				prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
-				count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
-				if list.Count == 0 {
+				list, _ := service.GetDrugTotalCount(advice.DrugId, advice.UserOrgId)
+
+				//查询改药品信息
+				medical, _ := service.GetBaseDrugMedical(advice.DrugId)
+				//判断单位是否相等
+				if medical.MaxUnit == advice.PrescribingNumberUnit {
+					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
+					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+					//转化为最小单位
+					total = list.Count * medical.MinNumber
+					prescribing_number_total = count * medical.MinNumber
+				}
+				fmt.Println("单位1", medical.MinUnit)
+				fmt.Println("d单位23", advice.PrescribingNumberUnit)
+				fmt.Println("hhhhhhh", list.Count)
+				if medical.MinUnit == advice.PrescribingNumberUnit {
+					prescribingNumber_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
+					count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+					total = list.Count*medical.MinNumber + list.StockMinNumber
+					fmt.Println("23232322323322323233223", total)
+					prescribing_number_total = count
+					fmt.Println("7777777777777777", prescribing_number_total)
+				}
+
+				fmt.Println("数量一", prescribing_number_total)
+				fmt.Println("数量二", total)
+
+				if (list.Count*medical.MinNumber + list.StockMinNumber) == 0 {
 					c.ServeSuccessJSON(map[string]interface{}{
-						"msg":    "1",
+						"msg":    "3",
 						"advice": advice,
 					})
 					return
 				}
-				if count > list.Count {
+				if prescribing_number_total > total {
 					c.ServeSuccessJSON(map[string]interface{}{
 						"msg":    "2",
 						"advice": advice,
 					})
 					return
 				}
-				service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
+				if prescribing_number_total <= total {
+					service.HisDrugsDelivery(adminUserInfo.CurrentOrgId, item.ExecutionStaff, item)
+					break
+					c.ServeSuccessJSON(map[string]interface{}{
+						"msg":    "1",
+						"advice": advice,
+					})
+					return
+				}
 			}
+			//	//查询该药品是否有库存
+			//	list, _ := service.GetDrugTotalCount(item.DrugId, item.UserOrgId)
+			//	prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
+			//	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
+			//	if list.Count == 0 {
+			//		c.ServeSuccessJSON(map[string]interface{}{
+			//			"msg":    "1",
+			//			"advice": advice,
+			//		})
+			//		return
+			//	}
+			//	if count > list.Count {
+			//		c.ServeSuccessJSON(map[string]interface{}{
+			//			"msg":    "2",
+			//			"advice": advice,
+			//		})
+			//		return
+			//	}
+			//	service.HisDrugsDelivery(item.UserOrgId, item.ExecutionStaff, item)
+			//}
 		}
 		c.ServeSuccessJSON(map[string]interface{}{
-			"msg":    "ok",
+			"msg":    "1",
 			"advice": advice,
 		})
 		return

controllers/stock_in_api_controller.go

 
 				dealer, _ := items["dealer"].(string)
 
+				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
+
 				var expiryDates int64
 				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
 					expiryDates = 0
 					RegisterAccount: register_account,
 					Remark:          remark,
 					Price:           price,
+					WarehouseInfoId: warehouse_info_id,
 				}
 				cancelStockInfos = append(cancelStockInfos, cancelStockInfo)
 
 			}
 		}
 	}
-	errs := service.CreateCancelStockInfo(cancelStockInfos)
-
-	if len(stockFLow) > 0 {
-		service.CreateStockFlow(stockFLow)
-	}
 
 	for _, item := range cancelStockInfos {
 
 			})
 			return
 		}
-	}
 
-	// 改变入库单的值
-	for _, item := range cancelStockInfos {
+		//查询该批次入库的值
+		infolist, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
 
-		//查询该耗材的入库记录
-		list, _ := service.GetWarehoureOrderInfoList(item.GoodId, item.OrgId)
-		//调用退库的方法
-		parseDateErr := service.UpdateCancelOut(list, item.Count)
-		fmt.Println("999999999999", parseDateErr)
-		if parseDateErr != nil {
-			utils.ErrorLog(parseDateErr.Error())
-			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+		if item.Count > infolist.WarehousingCount {
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg": "4",
+			})
 			return
 		}
-	}
 
-	if errs != nil {
-		utils.ErrorLog(errs.Error())
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
-		return
+		if item.Count <= infolist.WarehousingCount {
+
+			errs := service.CreateCancelStockInfo(cancelStockInfos)
+			if len(stockFLow) > 0 {
+				service.CreateStockFlow(stockFLow)
+			}
+			if errs != nil {
+				utils.ErrorLog(errs.Error())
+				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+				return
+			}
+
+			//更改入库数量
+			errs = service.UpdateWareInfoById(item.WarehouseInfoId, item.Count)
+
+			//查询该耗材的入库记录
+			//list, _ := service.GetWarehoureOrderInfoList(item.GoodId, item.OrgId)
+			////调用退库的方法
+			//parseDateErr := service.UpdateCancelOut(list, item.Count)
+			//fmt.Println("999999999999", parseDateErr)
+			break
+		}
 	}
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"msg": "3",
 	})
+	return
 
 }
 func (c *StockManagerApiController) GetCancelStockInfoList() {
 	fmt.Println("出库22322333223", cancelStockInfos)
 	fmt.Println("更新23232323232323233", upDateCancelStockInfos)
 	if len(cancelStockInfos) > 0 {
-		errs = service.CreateCancelStockInfo(cancelStockInfos)
 
-		service.CreateStockFlow(stockFlow)
-		// 改变入库单的值
 		for _, item := range cancelStockInfos {
-			//查询该耗材的入库记录
-			list, _ := service.GetWarehoureOrderInfoList(item.GoodId, item.OrgId)
-			//调用退库的方法
-			parseDateErr := service.UpdateCancelOut(list, item.Count)
-			if parseDateErr != nil {
-				utils.ErrorLog(errs.Error())
-				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+			//统计该耗材的出库数量
+			info, _ := service.GetWarehoureOrderInfoCount(item.GoodId, item.OrgId)
+			if item.Count > info.Count {
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "2",
+				})
 				return
 			}
+			//查询该批次入库的值
+			infolist, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
+
+			if item.Count > infolist.WarehousingCount {
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "4",
+				})
+				return
+			}
+
+			if item.Count <= infolist.WarehousingCount {
+
+				errs := service.CreateCancelStockInfo(cancelStockInfos)
+				if len(stockFlow) > 0 {
+					service.CreateStockFlow(stockFlow)
+				}
+				if errs != nil {
+					utils.ErrorLog(errs.Error())
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCancelStockFail)
+					return
+				}
+
+				//更改入库数量
+				errs = service.UpdateWareInfoById(item.WarehouseInfoId, item.Count)
+
+				break
+			}
 
-			c.ServeSuccessJSON(map[string]interface{}{
-				"msg": "编辑成功",
-			})
 		}
 	}
 
 	if len(upDateCancelStockInfos) > 0 {
 		for _, item := range upDateCancelStockInfos {
-			service.CreateStockFlow(stockFlow)
-			errs = service.UpDateCancelStockInfo(item)
-			list, _ := service.GetWarehoureOrderInfoList(item.GoodId, item.OrgId)
-			//调用退库的方法
-			parseDateErr := service.UpdateCancelOut(list, item.Count)
-			fmt.Println("999999999999", parseDateErr)
-			break
+
+			//获取该批次最后一套出库记录
+			info, _ := service.GetLastCancelInfo(item.WarehouseInfoId, item.GoodId)
+			fmt.Println("info232332322332233223", info.Count, item.Count)
+			//比较出库数量和最后一次出库数据大小
+			//退库(加)
+			if item.Count < info.Count {
+				var total = info.Count - item.Count
+				errs = service.UpDateCancelStockInfo(item)
+
+				service.CreateStockFlow(stockFlow)
+				parseDateErr := service.UpdateWareInfoById(item.WarehouseInfoId, total)
+				if parseDateErr != nil {
+					utils.ErrorLog(errs.Error())
+					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+					break
+				}
+			}
+			//(减)
+			if item.Count > info.Count {
+				errs = service.UpDateCancelStockInfo(item)
+				service.CreateStockFlow(stockFlow)
+				//查询该批次入库的值
+				infolist, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
+				if item.Count > infolist.WarehousingCount {
+					c.ServeSuccessJSON(map[string]interface{}{
+						"msg": "4",
+					})
+					return
+				}
+				if item.Count <= infolist.WarehousingCount {
+					var total_count = info.Count - item.Count
+					parseDateErr := service.UpdateWareInfoById(item.WarehouseInfoId, total_count)
+					if parseDateErr != nil {
+						utils.ErrorLog(errs.Error())
+						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+						return
+					}
+				}
+			}
 		}
 		if errs != nil {
 			utils.ErrorLog(errs.Error())
 		}
 
 		c.ServeSuccessJSON(map[string]interface{}{
-			"msg": "编辑成功",
+			"msg": "3",
 		})
 	}
 
 	}
 
 	c.ServeSuccessJSON(map[string]interface{}{
-		"msg": "编辑成功",
+		"msg": "3",
 	})
 
 }

models/stock_models.go

 	Number          string      `gorm:"column:number" json:"number" form:"number"`
 	RegisterAccount string      `gorm:"column:register_account" json:"register_account" form:"register_account"`
 	Remark          string      `gorm:"column:remark" json:"remark" form:"remark"`
+	WarehouseInfoId int64       `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
 	GoodInfo        GoodInfo    `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
 }
 

service/stock_service.go

 	if len(cancelStockInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(cancelStockInfo) > 0 {
-			thisSQL := "INSERT INTO xt_cancel_stock_info (good_id, cancel_stock_id, good_type_id, count, price,total,ctime,status,org_id,order_number,type,dealer,manufacturer,number,register_account,remark,product_date,expiry_date) VALUES "
+			thisSQL := "INSERT INTO xt_cancel_stock_info (good_id, cancel_stock_id, good_type_id, count, price,total,ctime,status,org_id,order_number,type,dealer,manufacturer,number,register_account,remark,product_date,expiry_date,warehouse_info_id) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range cancelStockInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.GoodId)
 				insertData = append(insertData, info.CancelStockId)
 				insertData = append(insertData, info.GoodTypeId)
 				insertData = append(insertData, info.Remark)
 				insertData = append(insertData, info.ProductDate)
 				insertData = append(insertData, info.ExpiryDate)
+				insertData = append(insertData, info.WarehouseInfoId)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 	if id > 0 {
 		db = db.Where("id = ?", id)
 	}
-	err := db.Select("drug_id,warehousing_count").Find(&info).Error
+	err := db.Select("drug_id,warehousing_count,stock_max_number,stock_min_number").Find(&info).Error
 
 	return info, err
 }
 
 func UpdateDrugWarehouseInfo(info *models.XtDrugWarehouseInfo, id int64) error {
 
-	err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_max_number": info.StockMaxNumber}).Error
+	//err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_max_number": info.StockMaxNumber}).Error
+	//return err
+	err = writeDb.Model(&models.XtDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", info.StockMaxNumber)).Error
 	return err
 }
 
 func UpdateDrugWarehouseInfoOne(info *models.XtDrugWarehouseInfo, id int64) error {
 
-	err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_min_number": info.StockMaxNumber}).Error
+	//err := XTWriteDB().Model(&info).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_min_number": info.StockMaxNumber}).Error
+	//return err
+
+	err = writeDb.Model(&models.XtDrugWarehouseInfo{}).Where("id = ? and status = 1", id).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", info.StockMinNumber)).Error
 	return err
 }
 
 	err := writeDb.Model(&models.XtDrugWarehouseInfo{}).Where("drug_id = ?  and org_id = ? and status = 1", drugid, orgid).UpdateColumn("stock_min_number", gorm.Expr("stock_min_number + ?", count)).Error
 	return err
 }
+
+func GetWarehouseInfoById(id int64) (models.WarehousingInfo, error) {
+
+	info := models.WarehousingInfo{}
+	err := XTReadDB().Model(&info).Where("id = ? and status = 1", id).Find(&info).Error
+	return info, err
+}
+
+func UpdateWareInfoById(id int64, count int64) error {
+
+	err = XTWriteDB().Model(&models.WarehousingInfo{}).Where("id = ?", id).UpdateColumn("stock_count", gorm.Expr("stock_count + ?", count)).Error
+	return err
+}
+
+func GetLastCancelInfo(id int64, goodid int64) (models.CancelStockInfo, error) {
+	info := models.CancelStockInfo{}
+	err := XTReadDB().Model(&info).Where("warehouse_info_id  = ? and good_id = ? and status = 1", id, goodid).Find(&info).Error
+	return info, err
+}