耗材参数

conf/app.conf

 
 
 
+
+
+
 aes_key = "xuetou-201807319"
 
 wxtoken = gh_ac6cd0cdde3d

controllers/drug_stock_api_contorller.go

 						BatchNumber:      batch_number,
 						MaxUnit:          max_unit,
 						MinUnit:          min_unit,
+						StockMaxNumber:   warehousing_count,
 					}
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 						Dealer:           dealer,
 						RetailPrice:      last_price,
 						RetailTotalPrice: retail_price_total,
-						StockMaxNumber:   warehousing_count,
 						MaxUnit:          max_unit,
 						MinUnit:          min_unit,
 						BatchNumber:      batch_number,
 
 					drugflow := &models.DrugFlow{
 						WarehousingOrder: warehousing.WarehousingOrder,
-						WarehousingId:    warehousing.ID,
+						WarehousingId:    id,
 						DrugId:           drug_id,
 						Number:           number,
 						ProductDate:      productDates,
 				Total: minNumber,
 			}
 			service.UpdateBaseDrug(&lib, item.DrugId)
+			warehouseInfo, _ := service.FindeLastWarehouseInfo(item.ID)
+			fmt.Println("hhhhh23hh32h232332323223", warehouseInfo)
+			var total int64
+			//比较大小(加)
+			if item.WarehousingCount > warehouseInfo.WarehousingCount {
+				total = item.WarehousingCount - warehouseInfo.WarehousingCount
+			}
+			item.StockMaxNumber = warehouseInfo.StockMaxNumber + total
+			if item.WarehousingCount < warehouseInfo.WarehousingCount {
+				total = warehouseInfo.WarehousingCount - item.WarehousingCount
+			}
+			item.StockMaxNumber = warehouseInfo.StockMaxNumber - total
+			if item.WarehousingCount == warehouseInfo.StockMaxNumber {
+
+				item.StockMaxNumber = item.WarehousingCount
+			}
 			errs = service.UpDateDrugWarehousingInfo(item)
-			service.CreateDrugFlow(drugFlow)
+
+		}
+	}
+
+	if len(drugFlow) > 0 {
+		for _, item := range drugFlow {
+			flow := models.DrugFlow{
+				Count: item.Count,
+			}
+			parseDateErr := service.UpdateDrugFlow(flow, item.DrugId, item.WarehousingId)
+			fmt.Println(parseDateErr)
 		}
 	}
 
 				remark := items["remark"].(string)
 				max_unit := items["max_unit"].(string)
 				dealer := int64(items["dealer"].(float64))
-				fmt.Println("dealer2222222222222222222", dealer)
+
 				manufacturer := int64(items["manufacturer"].(float64))
-				fmt.Println("manufacturer22222222222222", manufacturer)
+
 				number := items["number"].(string)
 				batch_number := items["batch_number"].(string)
+
+				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
 				var productDates int64
 				var expiryDates int64
 				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
 					Number:                  number,
 					BatchNumber:             batch_number,
 					IsSys:                   0,
+					WarehouseInfoId:         warehouse_info_id,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 	//调用出库逻辑
 	for _, item := range warehousingOutInfo {
 		//获取药品库存
-		info, _ := service.GetDrugTotalCount(item.DrugId, item.OrgId)
+		info, _ := service.GetDrugTotalCountOne(item.DrugId, item.OrgId, item.WarehouseInfoId)
 		//查询改药品信息
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
+		total_count = info.StockMaxNumber*medical.MinNumber + info.StockMinNumber
+		//for _, it := range info{
+		//  if medical.MaxUnit == it.MaxUnit{
+		//    it.Count = it.StockMaxNumber * medical.MinNumber
+		//  }
+		//  if medical.MinUnit == it.MinUnit{
+		//    it.Count = it.StockMinNumber
+		//  }
+		//  total_count += it.Count
+		//}
+		fmt.Println("总库存23232323232232332232332223", total_count)
 		//判断单位是否相等
 		if medical.MaxUnit == item.CountUnit {
 			//转化为最小单位
-			total_count = info.Count * medical.MinNumber
 			prescribing_number_total = item.Count * medical.MinNumber
 		}
 		if medical.MinUnit == item.CountUnit {
-			total_count = info.Count
 			prescribing_number_total = item.Count
 		}
 
 				batch_number := items["batch_number"].(string)
 				number := items["number"].(string)
 				max_unit := items["count_unit"].(string)
-
+				warehouse_info_id := int64(items["warehouse_info_id"].(float64))
 				var productDates int64
 				var expiryDates int64
 				if items["expiry_date"] == nil || reflect.TypeOf(items["expiry_date"]).String() != "string" {
 					}
 
 				}
-				fmt.Println("生产日期22222222222222222222222222", expiryDates)
-				fmt.Println("生产日期22222222222222222222222222", productDates)
+
 				if id == 0 {
 					warehouseOutInfo := &models.DrugWarehouseOutInfo{
 						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 						ProductDate:             productDates,
 						ExpiryDate:              expiryDates,
 						CountUnit:               count_unit,
+						WarehouseInfoId:         warehouse_info_id,
 					}
 					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 						Creator:                 adminUserInfo.AdminUser.Id,
 						IsSys:                   0,
 						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
-						WarehouseOutId:          warehouseOut.ID,
+						WarehouseOutId:          id,
 					}
 
 					drugFlow = append(drugFlow, drugflow)
 						ProductDate:             productDates,
 						ExpiryDate:              expiryDates,
 						CountUnit:               count_unit,
+						WarehouseInfoId:         warehouse_info_id,
 					}
 					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
 
 	//扣减库存逻辑
 	for _, item := range cancelStockInfos {
 		var total_number int64
+		var out_number int64
+		var can_number int64
 		medical, _ := service.GetBaseDrugMedical(item.DrugId)
 		//将当前退库数转为最小单位
 		if item.MaxUnit == medical.MaxUnit {
 		total_count = infoWareInfo.StockMaxNumber*medical.MinNumber + infoWareInfo.StockMinNumber
 		fmt.Println("当前批次总库存", total_count)
 
+		//查询该批次的出库数量
+		outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
+		//查询该批次总的退库数量
+
+		canInfo, _ := service.GetCancelDrugStockOutInfo(item.BatchNumberId, item.DrugId)
+		for _, item := range canInfo {
+			if item.MaxUnit == medical.MaxUnit {
+				item.Count = item.Count * medical.MinNumber
+			}
+			if item.MaxUnit == medical.MinUnit {
+				item.Count = item.Count
+			}
+		}
+		for _, item := range canInfo {
+			can_number += item.Count
+		}
+
+		for _, item := range outInfo {
+			if item.CountUnit == medical.MaxUnit {
+				item.Count = item.Count * medical.MinNumber
+			}
+			if item.CountUnit == medical.MinUnit {
+				item.Count = item.Count
+			}
+		}
+		for _, item := range outInfo {
+			out_number += item.Count
+		}
+		fmt.Println("出库数量23232232323222332", out_number)
+
 		//判断退库数量是否大于总入库数量
-		if total_number > total_count {
+		if total_number > out_number {
+			service.UpdateDrugCancel(item.CancelStockId)
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg": "4",
+			})
+			return
+		}
+
+		//判断总退库数量是否大于出库数量
+		fmt.Println("hhhhhhhhhhh", can_number+total_number)
+		if can_number+total_number > out_number {
+			service.UpdateDrugCancel(item.CancelStockId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg": "2",
 			})
 			return
 		}
+
 		//正常退库
-		if total_number <= total_count {
+		if total_number <= out_number {
 			//创建退库详情
 			errs := service.CreateDrugCancelStockInfo(cancelStockInfos)
 			//创建库存明细
 			infoWareInfo, _ := service.GetDrugWarehouseInfo(item.BatchNumberId)
 			fmt.Println("hhh2h3h2hh3233", item.MaxUnit, medical.MaxUnit)
 			var total_count int64
+			var cancel_count int64
+			var out_count int64
 			total_count = infoWareInfo.StockMaxNumber*medical.MinNumber + infoWareInfo.StockMinNumber
 			//转化为最小单位
 			var total_number int64
 			if item.MaxUnit == medical.MinUnit {
 				total_number = item.Count
 			}
-			//if item.MaxUnit == medical.MaxUnit {
-			//	total_count = infoWareInfo.WarehousingCount
-			//}
-			////转化为最小库存
-			//if item.MaxUnit == medical.MinUnit {
-			//	total_count = infoWareInfo.WarehousingCount * medical.MinNumber
-			//}
+
+			//统计该批次的总出库数
+			outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
+			for _, item := range outInfo {
+				if item.CountUnit == medical.MaxUnit {
+					item.Count = item.Count * medical.MinNumber
+				}
+				if item.CountUnit == medical.MinUnit {
+					item.Count = item.Count
+				}
+			}
+
+			for _, item := range outInfo {
+				out_count += item.Count
+			}
+			fmt.Println("out_count232233332232323223", out_count)
+
+			//判断退库数量是否大于出库数量
+			cancelInfo, _ := service.GetCancelDrugStockOutInfo(item.BatchNumberId, item.DrugId)
+			for _, item := range cancelInfo {
+				if item.MaxUnit == medical.MaxUnit {
+					item.Count = item.Count * medical.MinNumber
+				}
+				if item.MaxUnit == medical.MinUnit {
+					item.Count = item.Count
+				}
+			}
+
+			for _, item := range cancelInfo {
+				cancel_count += item.Count
+			}
+			fmt.Println("cancel_count", cancel_count)
+			fmt.Println("hhhhhh23h2h332322323232", total_number+cancel_count)
+			if total_number+cancel_count > out_count {
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "4",
+				})
+				return
+			}
+
 			//判断退库数量是否大于总入库数量
 			if total_number > total_count {
 				c.ServeSuccessJSON(map[string]interface{}{
 
 	if len(upDateCancelStockInfos) > 0 {
 		var total int64
+		var out_count int64
 		for _, item := range upDateCancelStockInfos {
 			errs = service.UpDateDrugCancelStockInfo(item)
 			//查询该批次最后一条退库记录
 			info, _ := service.GetLastCancelStockInfo(id)
 			//查询该药品的信息
 			medical, _ := service.GetBaseDrugMedical(item.DrugId)
+			//统计该批次的总出库数
+			outInfo, _ := service.GetDrugWarehouseOutInfo(item.BatchNumberId, item.DrugId)
+			for _, item := range outInfo {
+				if item.CountUnit == medical.MaxUnit {
+					item.Count = item.Count * medical.MinNumber
+				}
+				if item.CountUnit == medical.MinUnit {
+					item.Count = item.Count
+				}
+			}
+
+			for _, item := range outInfo {
+				out_count += item.Count
+			}
+
+			fmt.Println("out_count232233332232323223", out_count)
 
 			if item.MaxUnit == medical.MaxUnit {
 				item.Count = item.Count * medical.MinNumber

controllers/gobal_config_api_controller.go

 	adminUserInfo := c.GetAdminUserInfo()
 
 	//查询入库数量
-	list, total, err := service.GetDrugStockList(page, limit, keyword, drug_type, startTime, endTime, adminUserInfo.CurrentOrgId)
+	//list, total, err := service.GetDrugStockList(page, limit, keyword, drug_type, startTime, endTime, adminUserInfo.CurrentOrgId)
+
+	list, total, err := service.GetAllBaseDurgListCount(page, limit, keyword, drug_type, startTime, endTime, adminUserInfo.CurrentOrgId)
+	fmt.Println("total232323232323232232323", total)
 	manufacturerList, _ := service.GetAllManufacturerList(adminUserInfo.CurrentOrgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	list, err := service.GetDrugCountList(startTime, endTime, orgId)
 	countList, err := service.GetMinCountList(startTime, endTime, orgId)
-	outCountList, _ := service.GetOutDrugCountList(startTime, endTime, orgId)
-	auCountList, err := service.GetAutoDrugCountList(startTime, endTime, orgId)
+	//outCountList, _ := service.GetOutDrugCountList(startTime, endTime, orgId)
+	//auCountList, err := service.GetAutoDrugCountList(startTime, endTime, orgId)
 	info, _ := service.GetDrugWarehouOrderInfo(startTime, endTime, orgId)
 	cancelCountList, _ := service.GetCancelDrugCountList(startTime, endTime, orgId)
+	//service.GetAllCountList(startTime,endTime,orgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 	}
 	c.ServeSuccessJSON(map[string]interface{}{
-		"countList":       list,
-		"outCountList":    outCountList,
-		"auCountList":     auCountList,
+		"countList": list,
+		//"outCountList":    outCountList,
+		//"auCountList":     auCountList,
 		"minCount":        countList,
 		"info":            info,
 		"cancelCountList": cancelCountList,
 func (c *GobalConfigApiController) GetSingleOrderDetail() {
 
 	id, _ := c.GetInt64("id")
+	start_time, _ := c.GetInt64("start_time")
 	orgId := c.GetAdminUserInfo().CurrentOrgId
 	list, err := service.GetSingleOrderDetail(id, orgId)
 	outList, err := service.GetAllSingleDrugDetail(id, orgId)
 	dealerList, err := service.GetAllDealerList(orgId)
 	manufacturerList, err := service.GetAllManufacturerList(orgId)
+	drugFlowList, _ := service.GetDrugStockFlowDetail(start_time, orgId)
 	if err != nil {
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateConfig)
 		return
 		"dealerList":       dealerList,
 		"manufacturerList": manufacturerList,
 		"outList":          outList,
+		"drugFlowList":     drugFlowList,
 	})
 }
 

controllers/mobile_api_controllers/dialysis_api_controller.go

 					if err != nil {
 						goodObj, _ := service.GetGoodInformationByGoodId(it.GoodId)
 						c.ServeSuccessJSON(map[string]interface{}{
-							"message":            "1",
+							"message":            "2",
 							"good_name":          goodObj.GoodName,
 							"specification_name": goodObj.SpecificationName,
 						})
 			UpdateCreator:           creater,
 			PatientId:               patient_id,
 		}
-		//创建流水表
-		err := service.CreateStockFlowOne(stockFlow)
-		fmt.Println("h2h3h2323342i24i242i4u2i4242u42424", err)
+		exsit, errflow := service.GetStockFlowIsExsit(warehouseOutInfos.WarehouseInfotId, patient_id, record_time, good_yc.GoodId)
+		if errflow == gorm.ErrRecordNotFound {
+			//创建流水表
+			err := service.CreateStockFlowOne(stockFlow)
+			fmt.Println("h2h3h2323342i24i242i4u2i4242u42424", err)
+		} else if errflow == nil {
+			//插入详情明细表
+			stockFlow := models.VmStockFlow{
+				ID:                      exsit.ID,
+				WarehousingId:           warehouseOutInfos.WarehouseInfotId,
+				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+				WarehouseOutId:          warehouseOut.ID,
+				GoodId:                  good_yc.GoodId,
+				Number:                  warehouseOutInfos.Number,
+				ProductDate:             stockInInfo.ProductDate,
+				ExpireDate:              stockInInfo.ExpiryDate,
+				Count:                   exsit.Count - delete_count,
+				Price:                   stockInInfo.Price,
+				Status:                  1,
+				Ctime:                   time.Now().Unix(),
+				UserOrgId:               good_yc.OrgId,
+				Manufacturer:            stockInInfo.Manufacturer,
+				Dealer:                  stockInInfo.Dealer,
+				LicenseNumber:           stockInInfo.LicenseNumber,
+				IsEdit:                  2,
+				Creator:                 creater,
+				SystemTime:              record_time,
+				ConsumableType:          3,
+				WarehousingDetailId:     0,
+				IsSys:                   1,
+				UpdateCreator:           creater,
+				PatientId:               patient_id,
+			}
+
+			service.UpdatedStockFlow(stockFlow)
+		}
+
 		if errOne != nil {
 			return errOne
 		}
 		service.UpdatedWarehouseOutInfo(warehouseOutInfo, good_yc.GoodId, good_yc.PatientId, record_time)
 		//插入详情明细表
 		stockFlow := models.VmStockFlow{
+			WarehousingId:           warehouseOutInfos.WarehouseInfotId,
 			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 			WarehouseOutId:          warehouseOut.ID,
 			GoodId:                  good_yc.GoodId,
 			IsSys:                   1,
 			UpdateCreator:           creater,
 			PatientId:               patient_id,
+			ReturnCount:             delete_count,
 		}
-		//创建流水表
-		service.CreateStockFlowOne(stockFlow)
+		exsit, errflows := service.GetStockFlowIsExsit(warehouseOutInfos.WarehouseInfotId, patient_id, record_time, good_yc.GoodId)
+		if errflows == gorm.ErrRecordNotFound {
+			//创建流水表
+			service.CreateStockFlowOne(stockFlow)
+		} else if errflows == nil {
+			stockFlow := models.VmStockFlow{
+				WarehousingId:           warehouseOutInfos.WarehouseInfotId,
+				ID:                      exsit.ID,
+				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+				WarehouseOutId:          warehouseOut.ID,
+				GoodId:                  good_yc.GoodId,
+				Number:                  warehouseOutInfos.Number,
+				ProductDate:             stockInInfo.ProductDate,
+				ExpireDate:              stockInInfo.ExpiryDate,
+				Count:                   exsit.Count - delete_count,
+				Price:                   stockInInfo.Price,
+				Status:                  1,
+				Ctime:                   time.Now().Unix(),
+				UserOrgId:               good_yc.OrgId,
+				Manufacturer:            stockInInfo.Manufacturer,
+				Dealer:                  stockInInfo.Dealer,
+				LicenseNumber:           stockInInfo.LicenseNumber,
+				IsEdit:                  2,
+				Creator:                 creater,
+				SystemTime:              record_time,
+				ConsumableType:          3,
+				WarehousingDetailId:     0,
+				IsSys:                   1,
+				UpdateCreator:           creater,
+				PatientId:               patient_id,
+				ReturnCount:             delete_count,
+			}
+			service.UpdatedStockFlow(stockFlow)
+		}
+
 	}
 
 	//更改自动出库的表格

controllers/stock_in_api_controller.go

 					stockFlow = append(stockFlow, flow)
 
 				} else {
+					fmt.Println("id23233232323232323232323223", id)
 					warehouseInfo := &models.WarehousingInfo{
 						ID:               id,
 						WarehousingOrder: warehouse.WarehousingOrder,
 						Type:             types,
 						Manufacturer:     manufacturer,
 						Dealer:           dealer,
-						StockCount:       warehousing_count,
 						LicenseNumber:    license_number,
 					}
 					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
 
 					flow := &models.VmStockFlow{
 						WarehousingOrder:    warehousing.WarehousingOrder,
-						WarehousingId:       warehousing.ID,
+						WarehousingId:       id,
 						GoodId:              good_id,
 						Number:              number,
 						ProductDate:         productDates,
 	if len(upDateWarehousingInfo) > 0 {
 
 		for _, item := range upDateWarehousingInfo {
+
 			var total int64
 			var all_total int64
 			//获取该批次该型号的库存
-			info, _ := service.GetLastWarehousingById(item.WarehousingId, item.GoodId)
-
+			info, _ := service.GetLastWarehousingByIdOne(item.ID, item.GoodId)
+			fmt.Println("oooooooooo", info.WarehousingCount)
 			//判断 该批次的入库数量
 			total = item.WarehousingCount - info.WarehousingCount
-
+			fmt.Println("total232323322332232332", total)
 			all_total = info.StockCount + total
 
 			item.StockCount = all_total
+			fmt.Println("hhhhhhhhhhhhh", item.StockCount)
+
 			errs = service.UpDateWarehousingInfo(item)
+		}
+	}
 
-			service.CreateStockFlow(stockFlow)
+	if len(stockFlow) > 0 {
+		for _, item := range stockFlow {
+			flow := models.VmStockFlow{
+				Count: item.Count,
+			}
+			parseDateErr := service.UpdateStockFlow(flow, item.GoodId, item.WarehousingId)
+			fmt.Println(parseDateErr)
 		}
 	}
 
 		//统计该耗材的出库数量
 		info, _ := service.GetWarehoureOrderInfoCount(item.GoodId, item.OrgId)
 		if item.Count > info.Count {
+			service.UpdateCancelInfo(item.CancelStockId)
 			c.ServeSuccessJSON(map[string]interface{}{
 				"msg": "2",
 			})
 				return
 			}
 
+			//查询该批次的剩余库存
+			wareouseinfo, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
+			if (wareouseinfo.StockCount + item.Count) > wareouseinfo.WarehousingCount {
+				c.ServeSuccessJSON(map[string]interface{}{
+					"msg": "5",
+				})
+				return
+			}
 			//更改入库数量
 			errs = service.UpdateWareInfoById(item.WarehouseInfoId, item.Count)
 
 				errs = service.UpDateCancelStockInfo(item)
 
 				service.CreateStockFlow(stockFlow)
+				warehouseinfo, _ := service.GetWarehouseInfoById(item.WarehouseInfoId)
+				if (warehouseinfo.StockCount + total) > warehouseinfo.StockCount {
+					c.ServeSuccessJSON(map[string]interface{}{
+						"msg": "5",
+					})
+					return
+				}
 				parseDateErr := service.UpdateWareInfoById(item.WarehouseInfoId, total)
 				if parseDateErr != nil {
 					utils.ErrorLog(errs.Error())
 				}
 				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())
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
 
-	list, total, _ := service.GetAllStockList(page, limit, startTime, endTime, types, keywords, orgId)
+	list, total, _ := service.GetAllGoodInfoStockList(page, limit, startTime, endTime, types, keywords, orgId)
+	fmt.Println("耗材总计23323232232323232323", total)
 	manufacturerList, _ := service.GetAllManufacturerList(orgId)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"list":             list,
 	//手动出库
 	info, _ := service.GetWarehouseOutInfoById(id, good_id)
 
-	stockFlowList, err := service.GetStockFlowBatchNumber(id, good_id)
+	stockFlowList, err := service.GetStockFlowBatchNumberOne(id, good_id)
 	if err == nil {
 		this.ServeSuccessJSON(map[string]interface{}{
 			"list":          userDetails,

models/drug_stock.go

 	Count          int64  `gorm:"column:count" json:"count" form:"count"`
 	MaxUnit        string `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
 	MinUnit        string `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	CountUnit      string `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
 	StockMinNumber int64  `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
 	StockMaxNumber int64  `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
 }

models/good_models.go

 	DefaultCountUnit            string               `gorm:"column:default_count_unit" json:"default_count_unit" form:"default_count_unit"`
 	MinUnit                     string               `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
 	Total                       float64              `gorm:"column:total" json:"total" form:"total"`
-	StWarehousingInfo           []*StWarehousingInfo `gorm:"ForeignKey:good_id;AssociationForeignKey:ID" json:"xt_warehouse_info"`
+	StWarehousingInfo           []*StWarehousingInfo `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"xt_warehouse_info"`
+	CancelStockInfo             []*CancelStockInfo   `gorm:"ForeignKey:GoodId;AssociationForeignKey:ID" json:"cancel_stock_info"`
 }
 
 func (GoodInfo) TableName() string {

models/self_drug_models.go

 	Status                  int64  `gorm:"column:status" json:"status" form:"status"`
 	RecordTime              int64  `gorm:"column:record_time" json:"record_time" form:"record_time"`
 	OrgId                   int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
-	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"`
+	DrugId                  int64  `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
 	Count                   int64  `gorm:"column:count" json:"count" form:"count"`
+	CountUnit               string `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
 }
 
 func (XtDrugAutomaticReduceDetail) TableName() string {

models/stock_models.go

 	CancelOutDetailId       int64   `gorm:"column:cancel_out_detail_id" json:"cancel_out_detail_id" form:"cancel_out_detail_id"`
 	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"`
 }
 
 func (VmStockFlow) TableName() string {
 func (CancelStockInfo) TableName() string {
 	return "xt_cancel_stock_info"
 }
+
+type VmBaseDrug struct {
+	ID                          int64                     `gorm:"column:id" json:"id" form:"id"`
+	DrugName                    string                    `gorm:"column:drug_name" json:"drug_name" form:"drug_name"`
+	Pinyin                      string                    `gorm:"column:pinyin" json:"pinyin" form:"pinyin"`
+	Wubi                        string                    `gorm:"column:wubi" json:"wubi" form:"wubi"`
+	DrugAlias                   string                    `gorm:"column:drug_alias" json:"drug_alias" form:"drug_alias"`
+	DrugAliasPinyin             string                    `gorm:"column:drug_alias_pinyin" json:"drug_alias_pinyin" form:"drug_alias_pinyin"`
+	DrugAliasWubi               string                    `gorm:"column:drug_alias_wubi" json:"drug_alias_wubi" form:"drug_alias_wubi"`
+	DrugCategory                int64                     `gorm:"column:drug_category" json:"drug_category" form:"drug_category"`
+	DrugSpec                    string                    `gorm:"column:drug_spec" json:"drug_spec" form:"drug_spec"`
+	DrugType                    int64                     `gorm:"column:drug_type" json:"drug_type" form:"drug_type"`
+	DrugStockLimit              string                    `gorm:"column:drug_stock_limit" json:"drug_stock_limit" form:"drug_stock_limit"`
+	DrugOriginPlace             string                    `gorm:"column:drug_origin_place" json:"drug_origin_place" form:"drug_origin_place"`
+	DrugDosageForm              int64                     `gorm:"column:drug_dosage_form" json:"drug_dosage_form" form:"drug_dosage_form"`
+	MedicalInsuranceLevel       int64                     `gorm:"column:medical_insurance_level" json:"medical_insurance_level" form:"medical_insurance_level"`
+	MaxUnit                     string                    `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinNumber                   int64                     `gorm:"column:min_number" json:"min_number" form:"min_number"`
+	MinUnit                     string                    `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	Dose                        float64                   `gorm:"column:dose" json:"dose" form:"dose"`
+	DoseUnit                    string                    `gorm:"column:dose_unit" json:"dose_unit" form:"dose_unit"`
+	UnitMatrixing               string                    `gorm:"column:unit_matrixing" json:"unit_matrixing" form:"unit_matrixing"`
+	RetailPrice                 float64                   `gorm:"column:retail_price" json:"retail_price" form:"retail_price"`
+	MinPrice                    float64                   `gorm:"column:min_price" json:"min_price" form:"min_price"`
+	LastPrice                   float64                   `gorm:"column:last_price" json:"last_price" form:"last_price"`
+	DrugControl                 int64                     `gorm:"column:drug_control" json:"drug_control" form:"drug_control"`
+	Number                      string                    `gorm:"column:number" json:"number" form:"number"`
+	DrugClassify                string                    `gorm:"column:drug_classify" json:"drug_classify" form:"drug_classify"`
+	DrugDose                    float64                   `gorm:"column:drug_dose" json:"drug_dose" form:"drug_dose"`
+	DrugDoseUnit                int64                     `gorm:"column:drug_dose_unit" json:"drug_dose_unit" form:"drug_dose_unit"`
+	MedicalInsuranceNumber      string                    `gorm:"column:medical_insurance_number" json:"medical_insurance_number" form:"medical_insurance_number"`
+	Manufacturer                int64                     `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	PharmacologyCategory        int64                     `gorm:"column:pharmacology_category" json:"pharmacology_category" form:"pharmacology_category"`
+	StatisticsCategory          int64                     `gorm:"column:statistics_category" json:"statistics_category" form:"statistics_category"`
+	Code                        string                    `gorm:"column:code" json:"code" form:"code"`
+	IsSpecialDiseases           int64                     `gorm:"column:is_special_diseases" json:"is_special_diseases" form:"is_special_diseases"`
+	IsRecord                    int64                     `gorm:"column:is_record" json:"is_record" form:"is_record"`
+	Agent                       string                    `gorm:"column:agent" json:"agent" form:"agent"`
+	DrugStatus                  string                    `gorm:"column:drug_status" json:"drug_status" form:"drug_status"`
+	LimitRemark                 string                    `gorm:"column:limit_remark" json:"limit_remark" form:"limit_remark"`
+	DeliveryWay                 string                    `gorm:"column:delivery_way" json:"delivery_way" form:"delivery_way"`
+	ExecutionFrequency          string                    `gorm:"column:execution_frequency" json:"execution_frequency" form:"execution_frequency"`
+	SingleDose                  float64                   `gorm:"column:single_dose" json:"single_dose" form:"single_dose"`
+	PrescribingNumber           float64                   `gorm:"column:prescribing_number" json:"prescribing_number" form:"prescribing_number"`
+	Label                       int64                     `gorm:"column:label" json:"label" form:"label"`
+	Sort                        int64                     `gorm:"column:sort" json:"sort" form:"sort"`
+	IsUseDoctorAdvice           int64                     `gorm:"column:is_use_doctor_advice" json:"is_use_doctor_advice" form:"is_use_doctor_advice"`
+	IsDefault                   int64                     `gorm:"column:is_default" json:"is_default" form:"is_default"`
+	IsChargePredict             int64                     `gorm:"column:is_charge_predict" json:"is_charge_predict" form:"is_charge_predict"`
+	IsStatisticsWork            int64                     `gorm:"column:is_statistics_work" json:"is_statistics_work" form:"is_statistics_work"`
+	IsChargeUse                 int64                     `gorm:"column:is_charge_use" json:"is_charge_use" form:"is_charge_use"`
+	Status                      int64                     `gorm:"column:status" json:"status" form:"status"`
+	Ctime                       int64                     `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime                       int64                     `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	OrgId                       int64                     `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	DrugCode                    string                    `gorm:"column:drug_code" json:"drug_code" form:"drug_code"`
+	Dealer                      int64                     `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	PrescriptionMark            int64                     `gorm:"column:prescription_mark" json:"prescription_mark" form:"prescription_mark"`
+	RecordDate                  int64                     `gorm:"column:record_date" json:"record_date" form:"record_date"`
+	DrugRemark                  string                    `gorm:"column:drug_remark" json:"drug_remark" form:"drug_remark"`
+	SocialSecurityDirectoryCode string                    `gorm:"column:social_security_directory_code" json:"social_security_directory_code" form:"social_security_directory_code"`
+	DoseCode                    string                    `gorm:"column:dose_code" json:"dose_code" form:"dose_code"`
+	IsMark                      int64                     `gorm:"column:is_mark" json:"is_mark" form:"is_mark"`
+	HospApprFlag                int64                     `gorm:"column:hosp_appr_flag" json:"hosp_appr_flag" form:"hosp_appr_flag"`
+	LmtUsedFlag                 int64                     `gorm:"column:lmt_used_flag" json:"lmt_used_flag" form:"lmt_used_flag"`
+	DrugDay                     string                    `gorm:"column:drug_day" json:"drug_day" form:"drug_day"`
+	Total                       float64                   `gorm:"column:total" json:"total" form:"total"`
+	PrescribingNumberUnit       string                    `gorm:"column:prescribing_number_unit" json:"prescribing_number_unit" form:"prescribing_number_unit"`
+	DrugWarehouseInfo           []*VsDrugWarehouseInfo    `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_info"`
+	DrugCancelStockInfo         []*VsDrugCancelStockInfo  `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_cancel_stock_info"`
+	DrugWarehouseOutInfo        []*VsDrugWarehouseOutInfo `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug_warehouse_out"`
+}
+
+func (VmBaseDrug) TableName() string {
+	return "xt_base_drug"
+}
+
+type VsDrugWarehouseInfo struct {
+	ID               int64   `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId    int64   `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	DrugId           int64   `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	Number           string  `gorm:"column:number" json:"number" form:"number"`
+	ProductDate      int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpiryDate       int64   `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
+	WarehousingCount int64   `gorm:"column:warehousing_count" json:"warehousing_count" form:"warehousing_count"`
+	WarehouseingUnit string  `gorm:"column:warehouseing_unit" json:"warehouseing_unit" form:"warehouseing_unit"`
+	MaxUnit          string  `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	MinUnit          string  `gorm:"column:min_unit" json:"min_unit" form:"min_unit"`
+	StockMaxNumber   int64   `gorm:"column:stock_max_number" json:"stock_max_number" form:"stock_max_number"`
+	StockMinNumber   int64   `gorm:"column:stock_min_number" json:"stock_min_number" form:"stock_min_number"`
+	Price            float64 `gorm:"column:price" json:"price" form:"price"`
+	TotalPrice       float64 `gorm:"column:total_price" json:"total_price" form:"total_price"`
+	Dealer           int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Manufacturer     int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	Remark           string  `gorm:"column:remark" json:"remark" form:"remark"`
+	Ctime            int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime            int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Status           int64   `gorm:"column:status" json:"status" form:"status"`
+	OrgId            int64   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	IsReturn         int64   `gorm:"column:is_return" json:"is_return" form:"is_return"`
+	WarehousingOrder string  `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
+	Type             int64   `gorm:"column:type" json:"type" form:"type"`
+	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"`
+}
+
+func (VsDrugWarehouseInfo) TableName() string {
+	return "xt_drug_warehouse_info"
+}
+
+type VsDrugCancelStockInfo struct {
+	ID               int64       `gorm:"column:id" json:"id" form:"id"`
+	DrugId           int64       `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	CancelStockId    int64       `gorm:"column:cancel_stock_id" json:"cancel_stock_id" form:"cancel_stock_id"`
+	Count            int64       `gorm:"column:count" json:"count" form:"count"`
+	Price            float64     `gorm:"column:price" json:"price" form:"price"`
+	Total            float64     `gorm:"column:total" json:"total" form:"total"`
+	ProductDate      int64       `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpiryDate       int64       `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
+	Ctime            int64       `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime            int64       `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Status           int64       `gorm:"column:status" json:"status" form:"status"`
+	OrgId            int64       `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	OrderNumber      string      `gorm:"column:order_number" json:"order_number" form:"order_number"`
+	Type             int64       `gorm:"column:type" json:"type" form:"type"`
+	Dealer           string      `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Manufacturer     string      `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	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"`
+	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"`
+	BatchNumber      string      `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
+	MaxUnit          string      `gorm:"column:max_unit" json:"max_unit" form:"max_unit"`
+	BaseDrugLib      BaseDrugLib `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" `
+}
+
+func (VsDrugCancelStockInfo) TableName() string {
+	return "xt_drug_cancel_stock_info"
+}
+
+type VsDrugWarehouseOutInfo struct {
+	ID                      int64   `gorm:"column:id" json:"id" form:"id"`
+	WarehouseOutId          int64   `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	DrugId                  int64   `gorm:"column:drug_id" json:"drug_id" form:"drug_id"`
+	WarehousingOutTarget    int64   `gorm:"column:warehousing_out_target" json:"warehousing_out_target" form:"warehousing_out_target"`
+	Count                   int64   `gorm:"column:count" json:"count" form:"count"`
+	Price                   float64 `gorm:"column:price" json:"price" form:"price"`
+	TotalPrice              float64 `gorm:"column:total_price" json:"total_price" form:"total_price"`
+	ProductDate             int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpiryDate              int64   `gorm:"column:expiry_date" json:"expiry_date" form:"expiry_date"`
+	Mtime                   int64   `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Ctime                   int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Status                  int64   `gorm:"column:status" json:"status" form:"status"`
+	OrgId                   int64   `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	Remark                  string  `gorm:"column:remark" json:"remark" form:"remark"`
+	IsCancel                int64   `gorm:"column:is_cancel" json:"is_cancel" form:"is_cancel"`
+	WarehouseOutOrderNumber string  `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	Type                    int64   `gorm:"column:type" json:"type" form:"type"`
+	Dealer                  int64   `gorm:"column:dealer" json:"dealer" form:"dealer"`
+	Manufacturer            int64   `gorm:"column:manufacturer" json:"manufacturer" form:"manufacturer"`
+	IsSys                   int64   `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
+	SysRecordTime           int64   `gorm:"column:sys_record_time" json:"sys_record_time" form:"sys_record_time"`
+	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"`
+	CountUnit               string  `gorm:"column:count_unit" json:"count_unit" form:"count_unit"`
+}
+
+func (VsDrugWarehouseOutInfo) TableName() string {
+	return "xt_drug_warehouse_out_info"
+}
+
+type VmStockFlowOne struct {
+	ID                      int64   `gorm:"column:id" json:"id" form:"id"`
+	WarehousingId           int64   `gorm:"column:warehousing_id" json:"warehousing_id" form:"warehousing_id"`
+	GoodId                  int64   `gorm:"column:good_id" json:"good_id" form:"good_id"`
+	Number                  string  `gorm:"column:number" json:"number" form:"number"`
+	Count                   int64   `gorm:"column:count" json:"count" form:"count"`
+	PatientId               int64   `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	SystemTime              int64   `gorm:"column:system_time" json:"system_time" form:"system_time"`
+	IsSys                   int64   `gorm:"column:is_sys" json:"is_sys" form:"is_sys"`
+	WarehousingOrder        string  `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
+	WarehouseOutId          int64   `gorm:"column:warehouse_out_id" json:"warehouse_out_id" form:"warehouse_out_id"`
+	WarehouseOutOrderNumber string  `gorm:"column:warehouse_out_order_number" json:"warehouse_out_order_number" form:"warehouse_out_order_number"`
+	Price                   float64 `gorm:"column:price" json:"price" form:"price"`
+	ProductDate             int64   `gorm:"column:product_date" json:"product_date" form:"product_date"`
+	ExpireDate              int64   `gorm:"column:expire_date" json:"expire_date" form:"expire_date"`
+	PackingUnit             string  `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	Ctime                   int64   `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Name                    string  `gorm:"column:name" json:"name" form:"name"`
+}

service/gobal_config_service.go

 func GetDrugStockList(page int64, limit int64, keyword string, drugcategory int64, startime int64, endtime int64, orgid int64) (list []*models.StDrugWarehouseInfo, total int64, err error) {
 	offset := (page - 1) * limit
 	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
-
 	likeKey := "%" + keyword + "%"
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	return list, total, err
 }
 
+func GetAllBaseDurgListCount(page int64, limit int64, keyword string, drugcategory int64, startime int64, endtime int64, orgid int64) (drug []*models.VmBaseDrug, total int64, err error) {
+
+	offset := (page - 1) * limit
+	db := XTReadDB().Table("xt_base_drug").Where("status = 1")
+	likeKey := "%" + keyword + "%"
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+	if drugcategory > 0 {
+		db = db.Where("drug_type = ?", drugcategory)
+	}
+
+	if len(keyword) > 0 {
+		db = db.Where("drug_name like ?", likeKey)
+	}
+
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("ctime desc").Preload("DrugWarehouseInfo", "status=1 and org_id = ? and ctime >=? and ctime<=?", orgid, startime, endtime).Preload("DrugCancelStockInfo", "status=1 and org_id = ? and ctime >=? and ctime<=?", orgid, startime, endtime).Preload("DrugWarehouseOutInfo", "status=1 and org_id = ? and ctime >=? and ctime<=?", orgid, startime, endtime).Find(&drug).Error
+	return drug, total, err
+}
+
 func GetDrugStockFlow(drugid int64, startime int64, endtime int64, page int64, limit int64, orgid int64) (list []*models.StDrugWarehouseInfo, total int64, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("sum(x.count) as count,x.drug_id").Group("x.drug_id").Scan(&info).Error
+	err = db.Select("x.count,x.drug_id,x.count_unit").Find(&info).Error
 	return info, err
 }
 
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("sum(x.count) as count,x.drug_id").Group("x.drug_id").Scan(&info).Error
+	err = db.Select("x.count,x.drug_id,x.count_unit").Find(&info).Error
 	return info, err
 
 }
 	return info, err
 }
 
+func GetAllCountList(startime int64, endtime int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+
+	if startime > 0 {
+		db = db.Where("x.ctime >=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("x.ctime<=?", endtime)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Find(&info).Error
+	return info, err
+}
+
 func GetSingleOrderDetail(id int64, orgid int64) (info []*models.VmDrugWarehouseOutInfo, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
 	return info, err
 }
 
+func GetDrugStockFlowDetail(id int64, orgid int64) (drugflow []*models.XtDrugAutomaticReduceDetail, err error) {
+
+	err = XTReadDB().Where("record_time = ? and org_id = ? and status = 1", id, orgid).Find(&drugflow).Error
+	return drugflow, err
+}
+
 func GetAllSingleDrugDetail(id int64, orgid int64) (outInfo []*models.VmDrugWarehouseOutInfo, err error) {
 
 	db := XTReadDB().Table("xt_drug_warehouse_out_info as x").Where("x.status = 1")
 
 func GetDrugFlowBatch(ware_out_id int64, drug_id int64, orgid int64) (flow []*models.DrugFlow, err error) {
 
-	err = XTReadDB().Where("warehouse_out_id = ? and drug_id = ? and user_org_id = ? and status = 1", ware_out_id, drug_id, orgid).Group("number").Find(&flow).Error
+	err = XTReadDB().Where("warehouse_out_id = ? and drug_id = ? and user_org_id = ? and status = 1", ware_out_id, drug_id, orgid).Find(&flow).Error
 	return flow, err
 }

service/mobile_dialysis_service.go

 
 	err := readDb.
 		Model(&models.DoctorAdvice{}).
-		Where("patient_id = ? and user_org_id = ? and status = 1 and record_date = ? and advice_type = 2", patientID, orgID, recordDate).
+		Where("patient_id = ? and user_org_id = ? and status = 1 and record_date = ? and (advice_type = 2 || advice_type = 3)", patientID, orgID, recordDate).
 		Select("id, user_org_id, patient_id, advice_type, advice_date, record_date, start_time, advice_name,advice_desc, reminder_date, drug_spec, drug_spec_unit, single_dose, single_dose_unit, prescribing_number, prescribing_number_unit, delivery_way, execution_frequency, advice_doctor, status, created_time,updated_time, advice_affirm, remark, stop_time, stop_reason, stop_doctor, stop_state, parent_id, execution_time, execution_staff, execution_state, checker, check_state, check_time, groupno,way,drug_id,drug_name_id, IF(parent_id > 0, parent_id, id) as advice_order").
 		Order("start_time asc, groupno desc, advice_order desc, id asc").
 		Scan(&records).Error

service/stock_service.go

 	err := XTWriteDB().Model(&lib).Where("id = ?", id).Updates(map[string]interface{}{"total": lib.Total}).Error
 	return err
 }
+func FindeLastWarehouseInfo(id int64) (models.DrugWarehouseInfo, error) {
+	info := models.DrugWarehouseInfo{}
+	err := XTReadDB().Model(&info).Where("id=? and status = 1", id).Find(&info).Error
+	return info, err
+}
 
 func CreateDrugFlow(drugflow []*models.DrugFlow) (err error) {
 	if len(drugflow) > 0 {
 	Number                  string  `gorm:"column:number" json:"number" form:"number"`
 	BatchNumber             string  `gorm:"column:batch_number" json:"batch_number" form:"batch_number"`
 	Drug                    *Drug   `gorm:"ForeignKey:DrugId;AssociationForeignKey:ID" json:"drug"`
+	WarehouseInfoId         int64   `gorm:"column:warehouse_info_id" json:"warehouse_info_id" form:"warehouse_info_id"`
 }
 
 func (DrugWarehouseOutInfo) TableName() string {
 	return info, err
 }
 
+func GetLastWarehousingByIdOne(warehousing_id int64, orgid int64) (models.WarehousingInfo, error) {
+
+	info := models.WarehousingInfo{}
+	err = XTReadDB().Model(&info).Where("id = ? and good_id = ? and status = 1", warehousing_id, orgid).Find(&info).Error
+	return info, err
+}
+
 func UpDateWarehousingInfo(info *models.WarehousingInfo) (err error) {
 	err = writeDb.Save(&info).Error
 	return err
 	return info, total, err
 }
 
+func GetAllGoodInfoStockList(page int64, limit int64, startime int64, endtime int64, good_type int64, keyword string, orgid int64) (info []*models.GoodInfo, total int64, err error) {
+
+	offset := (page - 1) * limit
+	db := XTReadDB().Table("xt_good_information as x").Where("x.status= 1")
+
+	likeKey := "%" + keyword + "%"
+	if len(likeKey) > 0 {
+		db = db.Where("x.good_name like ?", likeKey)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	if good_type > 0 {
+		db = db.Where("x.good_type_id = ?", good_type)
+	}
+
+	err = db.Count(&total).Offset(offset).Limit(limit).Order("x.ctime desc").Preload("StWarehousingInfo", "status= 1 and org_id =? and ctime>=? and ctime<=?", orgid, startime, endtime).Preload("CancelStockInfo", "status= 1 and org_id =? and ctime>=? and ctime<=?", orgid, startime, endtime).Find(&info).Error
+	return info, total, err
+}
+
 func GetStockListById(good_id int64, orgid int64, limit int64, page int64, startime int64, endtime int64) (info []*models.VmWarehousingInfo, total int64, err error) {
 
 	offset := (page - 1) * limit
 	return info, err
 }
 
+func GetDrugTotalCountSwx(id int64, orgid int64) (info models.VmDrugWarehouseInfo, err error) {
+
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	if id > 0 {
+		db = db.Where("x.id = ?", id)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Select("x.drug_id,sum(x.stock_max_number) as count,sum(x.stock_min_number) as stock_min_number,x.max_unit,x.min_unit").Find(&info).Error
+	return info, err
+}
+
+func GetDrugTotalCountOne(drugid int64, orgid int64, id int64) (models.VmDrugWarehouseInfo, error) {
+	info := models.VmDrugWarehouseInfo{}
+	db := XTReadDB().Table("xt_drug_warehouse_info as x").Where("x.status = 1")
+	if id == 0 {
+		db = db.Where("id = ?", id)
+	}
+	if drugid > 0 {
+		db = db.Where("x.drug_id = ?", drugid)
+	}
+	if orgid > 0 {
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	err = db.Select("x.drug_id,x.stock_max_number,x.stock_min_number,x.max_unit,x.min_unit").Find(&info).Error
+	return info, err
+}
+
 func GetDrugByGoodId(drugid int64) (models.BaseDrugLib, error) {
 
 	lib := models.BaseDrugLib{}
 	return info, err
 }
 
+func UpdateCancelInfo(id int64) (models.CancelStock, error) {
+	stock := models.CancelStock{}
+	err := XTWriteDB().Model(&stock).Where("id=? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
+	return stock, err
+}
+
 func GetStockBatchNumber(id int64, orgid int64) (info []*models.WarehousingInfo, err error) {
 
 	err = XTReadDB().Model(&info).Where("good_id = ? and org_id = ? and status = 1 and number <> ''", id, orgid).Group("number").Find(&info).Error
 	return stock, err
 }
 
+func GetStockFlowBatchNumberOne(id int64, goodid int64) (stock []*models.VmStockFlowOne, err error) {
+
+	db := XTReadDB().Table("xt_stock_flow as x").Where("x.status = 1")
+	table := XTReadDB().Table("xt_patients as t").Where("t.status = 1")
+	fmt.Println(table)
+	tableone := XTReadDB().Table("xt_good_information as o").Where("o.status = 1")
+	fmt.Println(tableone)
+	if id > 0 {
+		db = db.Where("x.warehouse_out_id = ?", id)
+	}
+	if goodid > 0 {
+		db = db.Where("x.good_id = ?", goodid)
+	}
+
+	err = db.Select("x.id,x.warehousing_id,x.good_id,x.number,x.count,x.patient_id,x.system_time,x.is_sys,x.warehousing_order,x.warehouse_out_id,x.warehouse_out_order_number,x.price,x.product_date,x.expire_date,x.ctime,o.packing_unit,t.name").Joins("left join xt_patients as t on t.id = x.patient_id").Joins("left join xt_good_information as o on o.id = x.good_id").Scan(&stock).Error
+	//err = XTReadDB().Model(&stock).Where("warehouse_out_id = ? and good_id = ? and status = 1", id, goodid).Find(&stock).Error
+	return stock, err
+}
+
 func GetDrugBatchNumber(drug_id int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {
 
 	err = XTReadDB().Model(&info).Where("drug_id = ? and org_id = ? and status = 1 and batch_number <>''", drug_id, orgid).Find(&info).Error
 	return err
 }
 
+func UpdatedStockFlow(flow models.VmStockFlow) error {
+	err := XTWriteDB().Save(&flow).Error
+	return err
+}
+
+func GetStockFlowIsExsit(warehousing_id int64, patient_id int64, record_time int64, good_id int64) (*models.VmStockFlow, error) {
+
+	flow := models.VmStockFlow{}
+	var err error
+	err = XTReadDB().Model(&flow).Where("warehousing_id = ? and patient_id = ? and system_time = ? and good_id = ? and status = 1", warehousing_id, patient_id, record_time, good_id).Find(&flow).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &flow, nil
+}
+
 func GetWarehouseOutInfoIsExist(id int64) (*models.WarehouseOutInfo, error) {
 
 	info := models.WarehouseOutInfo{}
 	err := XTReadDB().Model(&info).Where("warehouse_info_id  = ? and good_id = ? and status = 1", id, goodid).Find(&info).Error
 	return info, err
 }
+
+func UpdateStockFlow(flow models.VmStockFlow, goodid int64, warehousing_id int64) error {
+
+	err := XTWriteDB().Model(&flow).Where("good_id = ? and warehousing_id= ? and status = 1", goodid, warehousing_id).Updates(map[string]interface{}{"count": flow.Count}).Error
+	return err
+}
+
+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
+	return err
+}
+
+func UpdateDrugCancel(id int64) (models.DrugCancelStock, error) {
+
+	stock := models.DrugCancelStock{}
+
+	err := XTWriteDB().Model(&stock).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
+	return stock, err
+}
+
+func GetDrugWarehouseOutInfo(warehouse_info_id int64, drug_id int64) (info []*models.DrugWarehouseOutInfo, err error) {
+
+	db := XTReadDB().Model(&info)
+	if warehouse_info_id > 0 {
+		db = db.Where("warehouse_info_id = ?", warehouse_info_id)
+	}
+	if drug_id > 0 {
+		db = db.Where("drug_id = ? and status =1", drug_id)
+	}
+
+	err = db.Find(&info).Error
+	return info, err
+}
+
+func GetCancelDrugStockOutInfo(warehouse_info_id int64, drug_id int64) (info []*models.DrugCancelStockInfo, err error) {
+
+	err = XTReadDB().Model(&info).Where("batch_number_id =? and drug_id = ? and status = 1", warehouse_info_id, drug_id).Find(&info).Error
+	return info, err
+}

service/warhouse_service.go

 			ExpiryDate:              warehouse.ExpiryDate,
 			PatientId:               advice.PatientId,
 			Count:                   count,
+			WarehouseInfoId:         warehouse.ID,
 		}
 
 		fmt.Println("单据号2232322323232323232323232323232323", warehouseout.WarehouseOutOrderNumber)
 			UpdatedDrugWarehouseOutInfo(warehouseOutInfo, advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId)
 		}
 		details := &models.DrugAutomaticReduceDetail{
-			WarehouseOutId:          warehouseOutInfo.ID,
-			WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
+			WarehouseOutId:          warehouseout.ID,
+			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
 			PatientId:               advice.PatientId,
 			Ctime:                   time.Now().Unix(),
 			Mtime:                   time.Now().Unix(),
 			ExpiryDate:              warehouse.ExpiryDate,
 			PatientId:               advice.PatientId,
 			Count:                   count,
+			WarehouseInfoId:         warehouse.ID,
 		}
-
-		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
-		if errOne != nil {
-			return errOne
-		} else {
-			details := &models.DrugAutomaticReduceDetail{
-				WarehouseOutId:          warehouseOutInfo.ID,
-				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
-				PatientId:               advice.PatientId,
-				Ctime:                   time.Now().Unix(),
-				Mtime:                   time.Now().Unix(),
-				Status:                  1,
-				RecordTime:              advice.RecordDate,
-				OrgId:                   orgID,
-				DrugId:                  advice.DrugId,
-				Count:                   count,
-				CountUnit:               advice.PrescribingNumberUnit,
-			}
-			errTwo := AddSigleDrugAutoReduceRecordInfo(details)
-			if errTwo != nil {
-				return errTwo
+		//查询是否存在数据
+		_, errcodes := GetDrugWarehouseOutInfoIsExit(advice.DrugId, advice.PatientId, advice.RecordDate)
+		if errcodes == gorm.ErrRecordNotFound {
+			errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
+			if errOne != nil {
+				return errOne
 			}
+		} else if errcodes == nil {
+			UpdatedDrugWarehouseOutInfo(warehouseOutInfo, advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId)
 		}
+
+		details := &models.DrugAutomaticReduceDetail{
+			WarehouseOutId:          warehouseout.ID,
+			WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
+			PatientId:               advice.PatientId,
+			Ctime:                   time.Now().Unix(),
+			Mtime:                   time.Now().Unix(),
+			Status:                  1,
+			RecordTime:              advice.RecordDate,
+			OrgId:                   orgID,
+			DrugId:                  advice.DrugId,
+			Count:                   stock_number,
+			CountUnit:               advice.PrescribingNumberUnit,
+		}
+		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
+		if errTwo != nil {
+			return errTwo
+		}
+
 		// 出库完成后，要将该批次库存清零
 		warehouse.StockMaxNumber = 0
 		warehouse.StockMinNumber = 0
 		warehouse.Mtime = time.Now().Unix()
 		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
+
 		if errThree != nil {
 			return errThree
 		}
+
+		drugflow := models.DrugFlow{
+			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
+			WarehouseOutId:          warehouseout.ID,
+			DrugId:                  advice.DrugId,
+			Number:                  warehouse.Number,
+			ProductDate:             warehouse.ProductDate,
+			ExpireDate:              warehouse.ExpiryDate,
+			Count:                   stock_number,
+			Price:                   baseInfo.RetailPrice,
+			Status:                  1,
+			Ctime:                   time.Now().Unix(),
+			UserOrgId:               orgID,
+			Manufacturer:            warehouse.Manufacturer,
+			Dealer:                  warehouse.Dealer,
+			BatchNumber:             warehouse.BatchNumber,
+			MaxUnit:                 advice.PrescribingNumberUnit,
+			ConsumableType:          3,
+			IsEdit:                  1,
+			Creator:                 advice.ExecutionStaff,
+			IsSys:                   1,
+			PatientId:               advice.PatientId,
+		}
+
+		CreateDrugFlowOne(drugflow)
 		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
 		prescribingNumber_two_temp := deliver_number - stock_number
 		overPlusNumber := float64(prescribingNumber_two_temp)
 			ProductDate:             warehouse.ProductDate,
 			ExpiryDate:              warehouse.ExpiryDate,
 			PatientId:               advice.PatientId,
+			WarehouseInfoId:         warehouse.ID,
 		}
 
 		warehouseOutInfo.Count = count
 		}
 
 		details := &models.DrugAutomaticReduceDetail{
-			WarehouseOutId:          warehouseOutInfo.ID,
-			WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
+			WarehouseOutId:          warehouseout.ID,
+			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
 			PatientId:               advice.PatientId,
 			Ctime:                   time.Now().Unix(),
 			Mtime:                   time.Now().Unix(),
 			ProductDate:             warehouse.ProductDate,
 			ExpiryDate:              warehouse.ExpiryDate,
 			PatientId:               advice.PatientId,
+			WarehouseInfoId:         warehouse.ID,
 		}
 
 		warehouseOutInfo.Count = count
 			Number:                  warehouse.Number,
 			ProductDate:             warehouse.ProductDate,
 			ExpireDate:              warehouse.ExpiryDate,
-			Count:                   count,
+			Count:                   stock_number,
 			Price:                   baseInfo.RetailPrice,
 			Status:                  1,
 			Ctime:                   time.Now().Unix(),
 			UpdatedDrugWarehouseOutInfo(warehouseOutInfo, advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId)
 		}
 		details := &models.DrugAutomaticReduceDetail{
-			WarehouseOutId:          warehouseOutInfo.ID,
-			WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
+			WarehouseOutId:          warehouseout.ID,
+			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
 			PatientId:               advice.PatientId,
 			Ctime:                   time.Now().Unix(),
 			Mtime:                   time.Now().Unix(),
 			Count:                   advice.Count,
 			RetailPrice:             advice.RetailPrice,
 			Price:                   advice.Price,
+			WarehouseInfoId:         advice.WarehouseInfoId,
 		}
 
 		warehouseOutInfo.Count = prescribingNumber
 func ConsumablesDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) {
 
 	fmt.Println("count23232323232323232323232323", count)
+	fmt.Println("hhhh2h3h3h2h23h32hh23h32h23", goods.Count)
 	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
 	var deliver_number int64 = 0
 	var stock_number int64 = 0
 	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
 	if err != nil {
 
-		fmt.Println("进来232323232323234343434343434343434343", warehouse.StockCount)
-
 		return errors.New("库存数量不足")
 	}
 
 	info, _ := GetGoodInformationByGoodId(goods.GoodId)
 	// 当库存数量大于或等于出库数量的话，则正常出库该批次
 	if stock_number >= deliver_number {
+		fmt.Println("进来22323232323232323232233223323223322323")
 		warehouseOutInfo := &models.WarehouseOutInfo{
 			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 			WarehouseOutId:          warehouseOut.ID,
 				IsSys:                   1,
 				PatientId:               patient_id,
 			}
-			CreateStockFlowOne(flow)
+			//查询流水是否存在
+			exsit, errflow := GetStockFlowIsExsit(warehouseOut.ID, patient_id, record_time, goods.GoodId)
+			fmt.Println("8888232322332323222332323223322332233232323232322323233223232332", exsit.Count+goods.Count)
+
+			if errflow == gorm.ErrRecordNotFound {
+				CreateStockFlowOne(flow)
+			} else if errflow == nil {
+				flow := models.VmStockFlow{
+					ID:                      exsit.ID,
+					WarehouseOutId:          warehouseOut.ID,
+					WarehousingId:           warehouse.ID,
+					GoodId:                  goods.GoodId,
+					Number:                  warehouse.Number,
+					ProductDate:             warehouse.ProductDate,
+					ExpireDate:              warehouse.ExpiryDate,
+					Count:                   exsit.Count + goods.Count,
+					Price:                   info.PackingPrice,
+					Status:                  1,
+					Ctime:                   time.Now().Unix(),
+					UserOrgId:               orgID,
+					Manufacturer:            info.Manufacturer,
+					Dealer:                  info.Dealer,
+					LicenseNumber:           warehouse.LicenseNumber,
+					IsEdit:                  2,
+					Creator:                 warehouseOut.Creater,
+					SystemTime:              record_time,
+					ConsumableType:          3,
+					WarehouseOutDetailId:    warehouseOutInfo.ID,
+					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+					IsSys:                   1,
+					PatientId:               patient_id,
+					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+				}
+				UpdatedStockFlow(flow)
+			}
 			if errTwo != nil {
 				return errTwo
 			}
 		} else if errcode == nil {
-			DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
-			CreateAutoReduceRecord(&details)
-			//插入库存流水表
+
+			fmt.Println("wodeeeeeeeeeeewewewewewewewewweewewewewewweewewew")
 			flow := models.VmStockFlow{
 				WarehouseOutId:          warehouseOut.ID,
 				WarehousingId:           warehouse.ID,
 				IsSys:                   1,
 				PatientId:               patient_id,
 			}
-			CreateStockFlowOne(flow)
+			//查询流水是否存在
+			exsit, errflow := GetStockFlowIsExsit(warehouseOut.ID, patient_id, record_time, goods.GoodId)
+			fmt.Println("8888232322332323222332323223322332233232323232322323233223232332", exsit.Count+goods.Count)
+
+			if errflow == gorm.ErrRecordNotFound {
+				CreateStockFlowOne(flow)
+			} else if errflow == nil {
+				flow := models.VmStockFlow{
+					ID:                      exsit.ID,
+					WarehouseOutId:          warehouseOut.ID,
+					WarehousingId:           warehouse.ID,
+					GoodId:                  goods.GoodId,
+					Number:                  warehouse.Number,
+					ProductDate:             warehouse.ProductDate,
+					ExpireDate:              warehouse.ExpiryDate,
+					Count:                   exsit.Count + goods.Count,
+					Price:                   info.PackingPrice,
+					Status:                  1,
+					Ctime:                   time.Now().Unix(),
+					UserOrgId:               orgID,
+					Manufacturer:            info.Manufacturer,
+					Dealer:                  info.Dealer,
+					LicenseNumber:           warehouse.LicenseNumber,
+					IsEdit:                  2,
+					Creator:                 warehouseOut.Creater,
+					SystemTime:              record_time,
+					ConsumableType:          3,
+					WarehouseOutDetailId:    warehouseOutInfo.ID,
+					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+					IsSys:                   1,
+					PatientId:               patient_id,
+					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+				}
+				UpdatedStockFlow(flow)
+			}
+			DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
+			CreateAutoReduceRecord(&details)
+
 		}
 
 		maxNumber = goods.Count
 
 		return nil
 	} else {
-
+		fmt.Println("不进来22323232323232323232233223323223322323")
 		// 当刚批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
 		warehouseOutInfo := &models.WarehouseOutInfo{
 			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 		warehouseOutInfo.Count = stock_number
 
 		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, goods.PatientId, record_time)
-
+		fmt.Println("hhhhh2h323233223232323", errcodes)
 		if errcodes == gorm.ErrRecordNotFound {
 			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
 
 				ProductDate:             warehouse.ProductDate,
 				ExpireDate:              warehouse.ExpiryDate,
 				Count:                   stock_number,
-				Price:                   warehouse.Price,
+				Price:                   info.PackingPrice,
 				Status:                  1,
 				Ctime:                   time.Now().Unix(),
 				UserOrgId:               orgID,
 				IsSys:                   1,
 				PatientId:               patient_id,
 			}
-			CreateStockFlowOne(flow)
+			//查询流水是否存在
+			exsit, errflows := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
+
+			if errflows == gorm.ErrRecordNotFound {
+				CreateStockFlowOne(flow)
+			} else if errflows == nil {
+				flow := models.VmStockFlow{
+					ID:                      exsit.ID,
+					WarehouseOutId:          warehouseOut.ID,
+					WarehousingId:           warehouse.ID,
+					GoodId:                  goods.GoodId,
+					Number:                  warehouse.Number,
+					ProductDate:             warehouse.ProductDate,
+					ExpireDate:              warehouse.ExpiryDate,
+					Count:                   exsit.Count + goods.Count,
+					Price:                   info.PackingPrice,
+					Status:                  1,
+					Ctime:                   time.Now().Unix(),
+					UserOrgId:               orgID,
+					Manufacturer:            info.Manufacturer,
+					Dealer:                  info.Dealer,
+					LicenseNumber:           warehouse.LicenseNumber,
+					IsEdit:                  2,
+					Creator:                 warehouseOut.Creater,
+					SystemTime:              record_time,
+					ConsumableType:          3,
+					WarehouseOutDetailId:    warehouseOutInfo.ID,
+					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+					IsSys:                   1,
+					PatientId:               patient_id,
+					ReturnCount:             exsit.Count + (exsit.Count + deliver_number),
+				}
+				UpdatedStockFlow(flow)
+			}
+
 		} else if errcodes == nil {
+			fmt.Println("尽力3323232322323232323232323232323")
 			goods.Count = deliver_number - stock_number
-			//更新数量为  刚批次剩余数量  + 还有未出的数量
-			warehouseOutInfo.Count = goods.Count + stock_number
+			//更新数量为  该批次剩余数量  + 还有未出的数量
+			warehouseOutInfo.Count = stock_number
 			UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, goods.PatientId, record_time)
 			//插入库存流水表
 			flow := models.VmStockFlow{
 				Number:                  warehouse.Number,
 				ProductDate:             warehouse.ProductDate,
 				ExpireDate:              warehouse.ExpiryDate,
-				Count:                   goods.Count + stock_number,
-				Price:                   warehouse.Price,
+				Count:                   stock_number,
+				Price:                   info.PackingPrice,
 				Status:                  1,
 				Ctime:                   time.Now().Unix(),
 				UserOrgId:               orgID,
 				IsSys:                   1,
 				PatientId:               patient_id,
 			}
-			CreateStockFlowOne(flow)
+			//查询流水是否存在
+			exsit, errflows := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
+			if errflows == gorm.ErrRecordNotFound {
+				CreateStockFlowOne(flow)
+			} else if errflows == nil {
+				fmt.Println("尽力3323232322323232323232323232323", exsit.Count+goods.Count)
+				flow := models.VmStockFlow{
+					ID:                      exsit.ID,
+					WarehouseOutId:          warehouseOut.ID,
+					WarehousingId:           warehouse.ID,
+					GoodId:                  goods.GoodId,
+					Number:                  warehouse.Number,
+					ProductDate:             warehouse.ProductDate,
+					ExpireDate:              warehouse.ExpiryDate,
+					Count:                   exsit.Count + goods.Count,
+					Price:                   info.PackingPrice,
+					Status:                  1,
+					Ctime:                   time.Now().Unix(),
+					UserOrgId:               orgID,
+					Manufacturer:            info.Manufacturer,
+					Dealer:                  info.Dealer,
+					LicenseNumber:           warehouse.LicenseNumber,
+					IsEdit:                  2,
+					Creator:                 warehouseOut.Creater,
+					SystemTime:              record_time,
+					ConsumableType:          3,
+					WarehouseOutDetailId:    warehouseOutInfo.ID,
+					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
+					IsSys:                   1,
+					PatientId:               patient_id,
+				}
+				UpdatedStockFlow(flow)
+			}
 		}
 
 		// 出库完成后，要将该批次库存清零