耗材参数

controllers/stock_in_api_controller.go

 
 				manufacturer := int64(items["manufacturer"].(float64))
 				dealer := int64(items["dealer"].(float64))
+
+				license_number, _ := items["license_number"].(string)
 				warehouseInfo := &models.WarehousingInfo{
 					WarehousingOrder: warehousing.WarehousingOrder,
 					WarehousingId:    warehousing.ID,
 					Manufacturer:     manufacturer,
 					StockCount:       warehousing_count,
 					Dealer:           dealer,
+					LicenseNumber:    license_number,
 				}
 				warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 			goodids = append(goodids, item.ID)
 			//入库详情但里面查询
 		}
-		info, _ := service.GetWarehoureOrderInfoByGoodId(goodids, startTime, endTime, adminUserInfo.CurrentOrgId)
-		for _, it := range info {
-			ids = append(ids, it.WarehousingId)
+		if len(goodids) > 0 {
+			info, _ := service.GetWarehoureOrderInfoByGoodId(goodids, startTime, endTime, adminUserInfo.CurrentOrgId)
+			for _, it := range info {
+				ids = append(ids, it.WarehousingId)
+			}
 		}
 	}
 
 	}
 }
 func (c *StockManagerApiController) GetWarehouseInfoList() {
-	//id, _ := c.GetInt64("id", 0)
 
 	id := c.GetString("id")
-
 	idArray := strings.Split(id, ",")
 	warehousing, err := service.FindWarehousingByIdOne(idArray)
 
 
 				manufacturer := int64(items["manufacturer"].(float64))
 				dealer := int64(items["dealer"].(float64))
-
+				license_number, _ := items["license_number"].(string)
 				if items["id"] == nil || reflect.TypeOf(items["id"]).String() != "float64" {
 					utils.ErrorLog("id")
 					c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 						Manufacturer:     manufacturer,
 						Dealer:           dealer,
 						StockCount:       warehousing_count,
+						LicenseNumber:    license_number,
 					}
 					warehousingInfo = append(warehousingInfo, warehouseInfo)
 
 						Manufacturer:     manufacturer,
 						Dealer:           dealer,
 						StockCount:       warehousing_count,
+						LicenseNumber:    license_number,
 					}
 					upDateWarehousingInfo = append(upDateWarehousingInfo, warehouseInfo)
 				}
 	operation_time := time.Now().Unix()
 	creater := adminUserInfo.AdminUser.Id
 
+	_, errcode := service.FindStockOutByIsSys(adminUserInfo.CurrentOrgId, 0, operation_time)
 	warehouseOut := models.WarehouseOut{
 		WarehouseOutOrderNumber: warehousing_out_order,
 		OperationTime:           operation_time,
 		WarehouseOutTime:        warehousingOutDate.Unix(),
 		Type:                    types,
 	}
-	service.AddSigleWarehouseOut(&warehouseOut)
+	if errcode == gorm.ErrRecordNotFound {
+		service.AddSigleWarehouseOut(&warehouseOut)
+	}
+
 	dataBody := make(map[string]interface{}, 0)
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &dataBody)
 	if err != nil {
 
 				manufacturer := int64(items["manufacturer"].(float64))
 
+				dealer := int64(items["dealer"].(float64))
 				number := items["number"].(string)
-				fmt.Println("number22222222222222", number)
+
+				expiry_date := items["expiry_date"].(string)
+
+				timeLayout := "2006-01-02"
+				loc, _ := time.LoadLocation("Local")
+				var expiryDate int64
+				if len(expiry_date) > 0 {
+					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
+					if err != nil {
+						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+						return
+					}
+					expiryDate = theTime.Unix()
+				}
+
+				product_date := items["product_date"].(string)
+
+				var productDate int64
+				if len(product_date) > 0 {
+					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
+					if err != nil {
+						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+						return
+					}
+					productDate = theTime.Unix()
+				}
+
 				warehouseOutInfo := &models.WarehouseOutInfo{
 					WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 					WarehouseOutId:          warehouseOut.ID,
 					Type:                    types,
 					Manufacturer:            manufacturer,
 					Number:                  number,
+					ExpiryDate:              expiryDate,
+					ProductDate:             productDate,
+					Dealer:                  dealer,
 				}
 				warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 		}
 	}
 
-	//查询库存
+	//出库逻辑
 	for _, item := range warehousingOutInfo {
-		parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count)
-		fmt.Println(parseDateErr)
-	}
+		//查询库存
+		warehouse, err := service.FindFirstWarehousingInfoByStockTwo(item.GoodId, item.GoodTypeId)
+		fmt.Println("库存数量组吗", warehouse.Count)
+		if err != nil {
+			goodObj, _ := service.GetGoodInformationByGoodId(item.GoodId)
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":                "1",
+				"good_name":          goodObj.GoodName,
+				"specification_name": goodObj.SpecificationName,
+			})
+			return
+		} else {
+			parseDateErr := service.ConsumablesDeliveryOne(adminUserInfo.CurrentOrgId, warehousingOutDate.Unix(), item, &warehouseOut, item.Count)
+			fmt.Println(parseDateErr)
+			if parseDateErr != nil {
+				utils.ErrorLog(parseDateErr.Error())
+				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
+				return
+			}
+
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":                "2",
+				"good_name":          "",
+				"specification_name": "",
+			})
+		}
 
-	errs := service.CreateWarehousingOutInfo(warehousingOutInfo)
-	info, _ := service.FindLastWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
-	if errs != nil {
-		utils.ErrorLog(errs.Error())
-		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateStockInFail)
-		return
 	}
 
-	c.ServeSuccessJSON(map[string]interface{}{
-		"msg":                   "出库成功",
-		"info":                  info,
-		"warehousing_out_order": warehousing_out_order,
-	})
+	//errs := service.CreateWarehousingOutInfo(warehousingOutInfo)
+	//info, _ := service.FindLastWarehousingOutInfo(warehouseOut.WarehouseOutOrderNumber)
 
 }
 func (c *StockManagerApiController) GetWarehouseOutList() {
 	}
 
 	adminUserInfo := c.GetAdminUserInfo()
-	warehouseOutList, total, err := service.FindAllWarehouseOutList(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords)
+	var ids []int64
+	var goodids []int64
+	if len(keywords) > 0 {
+		//查询商品名称
+		list, _ := service.GetGoodInforByGoodName(keywords, adminUserInfo.CurrentOrgId)
+		for _, item := range list {
+			goodids = append(goodids, item.ID)
+		}
+
+		if len(goodids) > 0 {
+			//出库详情但里面查询
+			info, _ := service.GetWarehoureOrderOutByGoodId(goodids, startTime, endTime, adminUserInfo.CurrentOrgId)
+			for _, it := range info {
+				ids = append(ids, it.WarehouseOutId)
+			}
+		}
+
+	}
+	warehouseOutList, total, err := service.FindAllWarehouseOutListOne(adminUserInfo.CurrentOrgId, page, limit, startTime, endTime, types, keywords, ids)
 	fmt.Println(err)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 
 				manufacturer := int64(items["manufacturer"].(float64))
 
+				dealer := int64(items["dealer"].(float64))
+
 				number := items["number"].(string)
+
+				timeLayout := "2006-01-02"
+				loc, _ := time.LoadLocation("Local")
+				expiry_date := items["expiry_date"].(string)
+				var expiryDate int64
+				if len(expiry_date) > 0 {
+					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
+					if err != nil {
+						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+						return
+					}
+					expiryDate = theTime.Unix()
+				}
+
+				product_date := items["product_date"].(string)
+
+				var productDate int64
+				if len(product_date) > 0 {
+					theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", expiry_date+" 00:00:00", loc)
+					if err != nil {
+						c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+						return
+					}
+					productDate = theTime.Unix()
+				}
+
 				if id == 0 {
 					warehouseOutInfo := &models.WarehouseOutInfo{
 						WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
 						IsSys:                   0,
 						SysRecordTime:           0,
 						Number:                  number,
+						ExpiryDate:              expiryDate,
+						ProductDate:             productDate,
+						Dealer:                  dealer,
+						Manufacturer:            manufacturer,
 					}
 					warehousingOutInfo = append(warehousingOutInfo, warehouseOutInfo)
 
 						IsSys:                   is_sys,
 						SysRecordTime:           sys_record_time,
 						Number:                  number,
+						ExpiryDate:              expiryDate,
+						ProductDate:             productDate,
+						Dealer:                  dealer,
 					}
 					upDateWarehouseOutInfos = append(upDateWarehouseOutInfos, warehouseOutInfo)
 				}

models/stock_models.go

 	WarehousingOrder string      `gorm:"column:warehousing_order" json:"warehousing_order"`
 	GoodInfo         GoodInfo    `gorm:"ForeignKey:ID;AssociationForeignKey:GoodId" `
 	Type             int64       `gorm:"column:type" json:"type"`
+	LicenseNumber    string      `gorm:"column:license_number" json:"license_number" form:"license_number"`
 }
 
 func (WarehousingInfo) TableName() string {
 	SpecificationName string      `gorm:"column:specification_name" json:"specification_name" form:"specification_name"`
 	MinNumber         int64       `gorm:"column:min_number" json:"min_number" form:"min_number"`
 	PackingUnit       string      `gorm:"column:packing_unit" json:"packing_unit" form:"packing_unit"`
+	Count             int64       `gorm:json:"count"`
 }
 
 type WarehouseOut struct {

service/gobal_config_service.go

 		db = db.Where("x.ctime >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("c.time<=?", endtime)
+		db = db.Where("x.ctime<=?", endtime)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 		db = db.Where("x.ctime >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("c.time<=?", endtime)
+		db = db.Where("x.ctime<=?", endtime)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 		db = db.Where("x.ctime >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("c.time<=?", endtime)
+		db = db.Where("x.ctime<=?", endtime)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	return info, err
 }
 
-func GetAutoDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.VmDrugWarehouseInfo, err error) {
+func GetAutoDrugCountList(startime int64, endtime int64, orgid int64) (info []*models.DrugAutomaticReduceDetail, err error) {
 	db := XTReadDB().Table("xt_drug_automatic_reduce_detail as x").Where("x.status = 1")
 
 	if startime > 0 {
 		db = db.Where("x.record_time >=?", startime)
 	}
 	if endtime > 0 {
-		db = db.Where("c.record_time<=?", endtime)
+		db = db.Where("x.record_time<=?", endtime)
 	}
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)

service/stock_service.go

 	if len(warehousingInfo) > 0 {
 		utx := writeDb.Begin()
 		if len(warehousingInfo) > 0 {
-			thisSQL := "INSERT INTO xt_warehouse_info (warehousing_id, good_id, good_type_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,stock_count) VALUES "
+			thisSQL := "INSERT INTO xt_warehouse_info (warehousing_id, good_id, good_type_id, number, product_date,expiry_date,warehousing_count,price,total_price,dealer,manufacturer,remark,ctime,mtime,status,org_id,warehousing_order,type,stock_count,license_number) VALUES "
 			insertParams := make([]string, 0)
 			insertData := make([]interface{}, 0)
 			for _, info := range warehousingInfo {
-				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
+				insertParams = append(insertParams, "(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)")
 				insertData = append(insertData, info.WarehousingId)
 				insertData = append(insertData, info.GoodId)
 				insertData = append(insertData, info.GoodTypeId)
 				insertData = append(insertData, info.WarehousingOrder)
 				insertData = append(insertData, info.Type)
 				insertData = append(insertData, info.WarehousingCount)
-
+				insertData = append(insertData, info.LicenseNumber)
 			}
 			thisSQL += strings.Join(insertParams, ", ")
 			err = utx.Exec(thisSQL, insertData...).Error
 	return info, err
 }
 
+func FindFirstWarehousingInfoByStockTwo(good_id int64, good_type_id int64) (info models.VmWarehousingInfo, err error) {
+	db := XTReadDB().Table("xt_warehouse_info as x").Where("x.status = 1")
+	if good_id > 0 {
+		db = db.Where("x.good_id = ?", good_id)
+	}
+	if good_type_id > 0 {
+		db = db.Where("x.good_type_id = ?", good_type_id)
+	}
+	err = db.Select("sum(x.stock_count) as count").Scan(&info).Error
+	return info, err
+}
+
 //药品先进先出,找出最先入库的批次
 
 func FindLastDrugWarehousingInfoByID(drug_id int64) (info models.XtDrugWarehouseInfo, err error) {
 	return info, err
 }
 
+func GetWarehoureOrderOutByGoodId(good_id []int64, startime int64, endtime int64, orgid int64) (info []*models.WarehouseOutInfo, err error) {
+
+	db := XTReadDB().Model(&info).Where("status =1")
+	if len(good_id) > 0 {
+		db = db.Where("good_id in (?)", good_id)
+	}
+	if startime > 0 {
+		db = db.Where("ctime >=?", startime)
+	}
+	if endtime > 0 {
+		db = db.Where("ctime<=?", endtime)
+	}
+	if orgid > 0 {
+		db = db.Where("org_id = ?", orgid)
+	}
+	err = db.Find(&info).Error
+	return info, err
+}
+
 type VMDrugWarehouse struct {
 	ID               int64                `gorm:"column:id" json:"id" form:"id"`
 	WarehousingOrder string               `gorm:"column:warehousing_order" json:"warehousing_order" form:"warehousing_order"`
 
 }
 
+func FindAllWarehouseOutListOne(orgId int64, page int64, limit int64, startTime int64, endTime int64, types int64, keywords string, ids []int64) (list []*models.WarehouseOut, total int64, err error) {
+	db := readDb.Model(&models.WarehouseOut{})
+	db = db.Where("xt_warehouse_out.org_id = ? AND xt_warehouse_out.status = 1 AND xt_warehouse_out.type = ?", orgId, types)
+
+	if len(keywords) > 0 {
+		likeKey := "%" + keywords + "%"
+		db = db.Joins("join sgj_users.sgj_user_admin_role on sgj_user_admin_role.admin_user_id = xt_warehouse_out.creater")
+		db = db.Where("sgj_user_admin_role.user_name LIKE ? OR xt_warehouse_out.warehouse_out_order_number LIKE ? or xt_warehouse_out.id in(?)", likeKey, likeKey, ids).Group("xt_warehouse_out.id")
+	}
+
+	if startTime > 0 {
+		db = db.Where("xt_warehouse_out.ctime >=?", startTime)
+	}
+	if endTime > 0 {
+		db = db.Where("xt_warehouse_out.ctime<= ?", endTime)
+	}
+	db = db.Count(&total)
+	offset := (page - 1) * limit
+	err = db.Offset(offset).Limit(limit).Order("xt_warehouse_out.ctime desc").Find(&list).Error
+	return list, total, err
+
+}
+
 func FindAllDrugWarehouseOutList(orgId int64, page int64, limit int64, startTime int64, endTime int64, types int64, keywords string) (list []*models.DrugWarehouseOut, total int64, err error) {
 	db := readDb.Model(&models.DrugWarehouseOut{})
 	db = db.Where("xt_drug_warehouse_out.org_id = ? AND xt_drug_warehouse_out.status = 1 ", orgId)
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
+	err = db.Select("x.id,x.warehouse_out_id,x.good_id,sum(x.count) as count,x.price,x.total_price,x.product_date,x.expiry_date,x.ctime,x.org_id,x.warehouse_out_order_number,x.type,x.dealer,t.manufacturer,x.is_sys,x.sys_record_time,x.number,x.remark,t.good_name,t.good_type_id,t.specification_name,t.min_number,t.packing_unit,t.min_unit").Joins("left join xt_good_information as t on t.id=x.good_id").Group("x.good_id").Order("x.ctime desc").Scan(&out).Error
 	return out, err
 }
 

service/warhouse_service.go

 	// 根据先进先出原则，查询最先入库的批次，进行出库
 	// 如果没有对应的库存，则报错
 	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
-
+	fmt.Println("err222222222222222222222", warehouse.StockCount)
 	if err != nil {
+		fmt.Println("232323232323进来")
 		return err
 	}
 
 	// 将该批次的剩余库存数量转换为拆零数量
 	stock_number = warehouse.StockCount
-
+	fmt.Println("3434343434343434", stock_number)
+	fmt.Println("8888888888888888888", deliver_number)
 	// 当库存数量大于或等于出库数量的话，则正常出库该批次
 	if stock_number >= deliver_number {
 		warehouseOutInfo := &models.WarehouseOutInfo{
 			WarehouseInfotId:        warehouse.ID,
 			Status:                  1,
 			Ctime:                   time.Now().Unix(),
-			Remark:                  "",
+			Remark:                  goods.Remark,
 			OrgId:                   orgID,
 			Type:                    1,
-			Manufacturer:            0,
-			Dealer:                  0,
+			Manufacturer:            goods.Manufacturer,
+			Dealer:                  goods.Dealer,
 			IsSys:                   0,
 			SysRecordTime:           record_time,
 			GoodTypeId:              goods.GoodTypeId,
 			GoodId:                  goods.GoodId,
+			ExpiryDate:              goods.ExpiryDate,
+			ProductDate:             goods.ProductDate,
+			Number:                  goods.Number,
+			Price:                   goods.Price,
 		}
 		warehouseOutInfo.Count = goods.Count
 		stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID)
 		warehouseOutInfo.Price = stockInInfo.Price
 
-		//判断当前耗材是否有出库详情记录
-		_, errcode := GetStockInRecoredByGoodIdOne(goods.GoodId, goods.GoodTypeId, record_time, orgID)
-		if errcode == gorm.ErrRecordNotFound {
-			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
-			if errOne != nil {
-				return errOne
-			}
-		} else if errcode == nil {
-			warehouseOutInfo := &models.WarehouseOutInfo{
-				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
-				WarehouseOutId:          warehouseOut.ID,
-				WarehouseInfotId:        warehouse.ID,
-				Status:                  1,
-				Ctime:                   time.Now().Unix(),
-				Remark:                  "",
-				OrgId:                   orgID,
-				Type:                    1,
-				Manufacturer:            0,
-				Dealer:                  0,
-				IsSys:                   0,
-				SysRecordTime:           record_time,
-				GoodTypeId:              goods.GoodTypeId,
-				GoodId:                  goods.GoodId,
-			}
-			warehouseOutInfo.Count = goods.Count
-
+		errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
+		if errOne != nil {
+			return errOne
 		}
 
 		maxNumber = goods.Count
 
 		warehouse.StockCount = warehouse.StockCount - maxNumber
 		warehouse.Mtime = time.Now().Unix()
-
 		if warehouse.StockCount < 0 {
+			fmt.Println("进来33232323232232323233232", warehouse.StockCount)
 			return errors.New("库存数量不足")
 		}
-		errThree := UpDateWarehouseInfoByStock(&warehouse)
-		if errThree != nil {
-			return errThree
-		}
-
 		return nil
 	} else {
 		// 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
 			WarehouseInfotId:        warehouse.ID,
 			Status:                  1,
 			Ctime:                   time.Now().Unix(),
-			Remark:                  "",
+			Remark:                  goods.Remark,
 			OrgId:                   orgID,
 			Type:                    1,
-			Manufacturer:            0,
-			Dealer:                  0,
+			Manufacturer:            goods.Manufacturer,
+			Dealer:                  goods.Dealer,
 			IsSys:                   0,
 			SysRecordTime:           record_time,
 			GoodTypeId:              goods.GoodTypeId,
 			GoodId:                  goods.GoodId,
+			ExpiryDate:              goods.ExpiryDate,
+			ProductDate:             goods.ProductDate,
+			Number:                  goods.Number,
+			Price:                   goods.Price,
 		}
 		warehouseOutInfo.Count = stock_number
 		stockInInfo, _ := service.FindLastStockInInfoRecord(goods.GoodId, orgID)
 		warehouseOutInfo.Price = stockInInfo.Price
 
-		_, errcode := GetStockInRecoredByGoodIdOne(goods.GoodId, goods.GoodTypeId, record_time, orgID)
-		if errcode == gorm.ErrRecordNotFound {
-			errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
-
-			if errOne != nil {
-				return errOne
-			}
-			// 出库完成后，要将该批次库存清零
-			warehouse.StockCount = 0
-			warehouse.Mtime = time.Now().Unix()
-			errThree := UpDateWarehouseInfoByStock(&warehouse)
-			if errThree != nil {
-				return errThree
-			}
-			// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
-			goods.Count = deliver_number - stock_number
+		errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)
 
-			ConsumablesDeliveryOne(orgID, record_time, goods, warehouseOut, count)
-		} else if errcode == nil {
-
-			warehouseOutInfo := &models.WarehouseOutInfo{
-				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
-				WarehouseOutId:          warehouseOut.ID,
-				WarehouseInfotId:        warehouse.ID,
-				Status:                  1,
-				Ctime:                   time.Now().Unix(),
-				Remark:                  "",
-				OrgId:                   orgID,
-				Type:                    1,
-				Manufacturer:            0,
-				Dealer:                  0,
-				IsSys:                   0,
-				SysRecordTime:           record_time,
-				GoodTypeId:              goods.GoodTypeId,
-				GoodId:                  goods.GoodId,
-			}
-			warehouseOutInfo.Count = goods.Count
-			//更新入库详情表
-			UpdateAutoMaticReduceDetailOne(goods.GoodId, goods.GoodTypeId, record_time, orgID, warehouseOutInfo)
+		if errOne != nil {
+			return errOne
 		}
+		// 出库完成后，要将该批次库存清零
+		warehouse.StockCount = 0
+		warehouse.Mtime = time.Now().Unix()
+		errThree := UpDateWarehouseInfoByStock(&warehouse)
+		if errThree != nil {
+			return errThree
+		}
+		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
+		goods.Count = deliver_number - stock_number
+
+		ConsumablesDeliveryOne(orgID, record_time, goods, warehouseOut, count)
 
 	}
 	return nil