package service import ( "XT_New/models" "XT_New/models/service" "XT_New/utils" "errors" "fmt" _ "fmt" "github.com/jinzhu/gorm" "math" "strconv" "strings" "time" ) // 药品出库 func DrugsDelivery(orgID int64, advice *models.DoctorAdvice) (err error) { // 1.判断药品是否来自专用字典的药品库 // 2.判断当天当前机构有没有创建出库单，没有则创建 // 3.创建出库流程 // 3.1 实现先进先出逻辑 由于药品执行后，不可以修改和删除，所以不考虑出库后的退库和修改出库数量等 isHasWay := false record_time := int64(0) if advice.Way == 1 { isHasWay = true record_time = advice.RecordDate } fmt.Println("isHasway99999999999999999999999999999999", isHasWay) if isHasWay { //判断当天当前机构有没有创建出库单，没有则创建 out, err := FindDrugStockOutByIsSys(orgID, 1, record_time) if err == gorm.ErrRecordNotFound { timeStr := time.Now().Format("2006-01-02") timeArr := strings.Split(timeStr, "-") total, _ := FindAllDrugWarehouseOut(orgID) total = total + 1 warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" number, _ := strconv.ParseInt(warehousing_out_order, 10, 64) number = number + total warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10) // creater := adminUserInfo.AdminUser.Id warehouseOut := models.DrugWarehouseOut{ WarehouseOutOrderNumber: warehousing_out_order, OperationTime: time.Now().Unix(), OrgId: orgID, Creater: 0, Ctime: time.Now().Unix(), Status: 1, WarehouseOutTime: record_time, Dealer: 0, Manufacturer: 0, Type: 1, IsSys: 1, } err := AddSigleDrugWarehouseOut(&warehouseOut) if err != nil { utils.TraceLog("创建出库单失败 err = %v", err) return err } else { out = warehouseOut } } // 出库流程 // 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位） drup, _ := FindBaseDrugLibRecord(orgID, advice.DrugId) if drup.ID > 0 { prescribingNumber := advice.PrescribingNumber DrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice) } else { return errors.New("药品信息不存在") } } return } // 药品出库 递归方式 func DrugDeliverInfo(orgID int64, prescribingNumber float64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DoctorAdvice) (err error) { // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64) count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64) fmt.Println("单位1", advice.PrescribingNumber) fmt.Println("单位2", drup.MaxUnit) if advice.PrescribingNumberUnit == drup.MaxUnit { deliver_number = count * drup.MinNumber } else { deliver_number = count } // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 //开启事物 warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber fmt.Println("stock_number999999999999", stock_number) fmt.Println("deliver_number88888888888", deliver_number) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, } warehouseOutInfo.Count = deliver_number warehouseOutInfo.CountUnit = drup.MinUnit 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: deliver_number, CountUnit: drup.MinUnit, } errTwo := AddSigleDrugAutoReduceRecordInfo(details) if errTwo != nil { return errTwo } } // 出库完成后，要减去对应批次的库存数量 // 判断处方里药品单位是拆零单位还是包装单位, 如果是拆零单位，则根据规格，将拆零数量转为包装数量 var maxNumber int64 = 0 var minNumber int64 = 0 if advice.PrescribingNumberUnit == drup.MinUnit { maxNumber = count / drup.MinNumber minNumber = count % drup.MinNumber } else { maxNumber = count } if warehouse.StockMaxNumber < maxNumber { return errors.New("库存数量不足") } warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber warehouse.Mtime = time.Now().Unix() if warehouse.StockMinNumber < minNumber { warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1 warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber } else { warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber } if warehouse.StockMaxNumber < 0 { return errors.New("库存数量不足") } errThree := UpDateDrugWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } return nil } else { // 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, } warehouseOutInfo.Count = stock_number warehouseOutInfo.CountUnit = drup.MinUnit 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: stock_number, CountUnit: drup.MinUnit, } 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 } // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 prescribingNumber_two_temp := deliver_number - stock_number overPlusNumber := float64(prescribingNumber_two_temp) advice.PrescribingNumber = float64(prescribingNumber_two_temp) advice.PrescribingNumberUnit = drup.MinUnit DrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice) } return } // 药品出库 func HisDrugsDelivery(orgID int64, advice *models.HisDoctorAdviceInfo) (err error) { // 1.判断药品是否来自专用字典的药品库 // 2.判断当天当前机构有没有创建出库单，没有则创建 // 3.创建出库流程 // 3.1 实现先进先出逻辑 由于药品执行后，不可以修改和删除，所以不考虑出库后的退库和修改出库数量等 isHasWay := false record_time := int64(0) isHasWay = true record_time = advice.RecordDate if isHasWay { //判断当天当前机构有没有创建出库单，没有则创建 out, err := FindDrugStockOutByIsSys(orgID, 1, record_time) if err == gorm.ErrRecordNotFound { timeStr := time.Now().Format("2006-01-02") timeArr := strings.Split(timeStr, "-") total, _ := FindAllDrugWarehouseOut(orgID) total = total + 1 warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" number, _ := strconv.ParseInt(warehousing_out_order, 10, 64) number = number + total warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10) // creater := adminUserInfo.AdminUser.Id warehouseOut := models.DrugWarehouseOut{ WarehouseOutOrderNumber: warehousing_out_order, OperationTime: time.Now().Unix(), OrgId: orgID, Creater: 0, Ctime: time.Now().Unix(), Status: 1, WarehouseOutTime: record_time, Dealer: 0, Manufacturer: 0, Type: 1, IsSys: 1, } err := AddSigleDrugWarehouseOut(&warehouseOut) if err != nil { utils.TraceLog("创建出库单失败 err = %v", err) return err } else { out = warehouseOut } } // 出库流程 // 1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位） drup, _ := FindBaseDrugLibRecord(orgID, advice.DrugId) if drup.ID > 0 { prescribingNumber := advice.PrescribingNumber HisDrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice) } else { return errors.New("药品信息不存在") } } return } // 药品出库 递归方式 func HisDrugDeliverInfo(orgID int64, prescribingNumber float64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.HisDoctorAdviceInfo) (err error) { // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64) count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64) fmt.Println("单位99999999999999999999999999", advice.PrescribingNumberUnit) fmt.Println("drup777777777777766666666", drup.MaxUnit) if advice.PrescribingNumberUnit == drup.MaxUnit { deliver_number = count * drup.MinNumber } else { deliver_number = count } // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 //开启事物 warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, } warehouseOutInfo.Count = deliver_number warehouseOutInfo.CountUnit = drup.MinUnit 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: deliver_number, CountUnit: drup.MinUnit, } errTwo := AddSigleDrugAutoReduceRecordInfo(details) if errTwo != nil { return errTwo } } // 出库完成后，要减去对应批次的库存数量 // 判断处方里药品单位是拆零单位还是包装单位, 如果是拆零单位，则根据规格，将拆零数量转为包装数量 var maxNumber int64 = 0 var minNumber int64 = 0 if advice.PrescribingNumberUnit == drup.MinUnit { maxNumber = count / drup.MinNumber minNumber = count % drup.MinNumber } else { maxNumber = count } if warehouse.StockMaxNumber < maxNumber { return errors.New("库存数量不足") } warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber warehouse.Mtime = time.Now().Unix() if warehouse.StockMinNumber < minNumber { warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1 warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber } else { warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber } if warehouse.StockMaxNumber < 0 { return errors.New("库存数量不足") } errThree := UpDateDrugWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } return nil } else { // 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, } warehouseOutInfo.Count = stock_number warehouseOutInfo.CountUnit = drup.MinUnit 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: stock_number, CountUnit: drup.MinUnit, } 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 } // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 prescribingNumber_two_temp := deliver_number - stock_number overPlusNumber := float64(prescribingNumber_two_temp) advice.PrescribingNumber = float64(prescribingNumber_two_temp) advice.PrescribingNumberUnit = drup.MinUnit HisDrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice) } return } // 药品出库 递归方式 func AutoDrugDeliverInfo(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) { // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 fmt.Println("单位1", advice.CountUnit) fmt.Println("单位2", drup.MaxUnit) if advice.CountUnit == drup.MaxUnit { deliver_number = prescribingNumber * drup.MinNumber } else { deliver_number = prescribingNumber } // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 //开启事物 warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber fmt.Println("88i8uu7777777777777777777777777777", stock_number) fmt.Println("77777544656666666666666666", deliver_number) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 0, SysRecordTime: advice.Ctime, DrugId: advice.DrugId, } warehouseOutInfo.Count = deliver_number warehouseOutInfo.CountUnit = advice.CountUnit errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } // 出库完成后，要减去对应批次的库存数量 // 判断处方里药品单位是拆零单位还是包装单位, 如果是拆零单位，则根据规格，将拆零数量转为包装数量 var maxNumber int64 = 0 var minNumber int64 = 0 if advice.CountUnit == drup.MinUnit { maxNumber = prescribingNumber / drup.MinNumber minNumber = prescribingNumber % drup.MinNumber } else { maxNumber = prescribingNumber } if warehouse.StockMaxNumber < maxNumber { return errors.New("库存数量不足") } warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber warehouse.Mtime = time.Now().Unix() if warehouse.StockMinNumber < minNumber { warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1 warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber } else { warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber } if warehouse.StockMaxNumber < 0 { return errors.New("库存数量不足") } errThree := UpDateDrugWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } return nil } else { // 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 0, SysRecordTime: advice.Ctime, DrugId: advice.DrugId, } warehouseOutInfo.Count = stock_number warehouseOutInfo.CountUnit = advice.CountUnit errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } // 出库完成后，要将该批次库存清零 warehouse.StockMaxNumber = 0 warehouse.StockMinNumber = 0 warehouse.Mtime = time.Now().Unix() errThree := UpDateDrugWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 prescribingNumber_two_temp := deliver_number - stock_number advice.CountUnit = drup.MinUnit AutoDrugDeliverInfo(orgID, prescribingNumber_two_temp, warehouseout, drup, advice) } return } // 耗材出库 func ConsumablesDeliveryTotal(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods, goodOne []*models.NewDialysisBeforePrepareGoods) (err error) { //查询该患者当天已经出库的耗材信息 goods_yc, _ := FindConsumablesByDateTwo(orgID, patient_id, record_time) //for _, item := range goods_yc { // fmt.Println("已经出库的耗材新消息 -----------------------------------------", item.Count) //} //for _, item := range goods { // fmt.Println("新传进来来的耗材新消息0000000000000000000000000000000000000000000000000", item.Count) //} // //for _,item :=range goodOne{ // fmt.Println("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh",item.Count) //} // 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的 for i := len(goods_yc) - 1; i >= 0; i-- { goods_yc_temp := goods_yc[i] for j := len(goods) - 1; j >= 0; j-- { goods_temp := goods[j] // 已经出库和新请求出库都存在该耗材，则判断出库数量，分成是继续出库，还是删除出库 if goods_yc_temp.GoodTypeId == goods_temp.GoodTypeId && goods_yc_temp.GoodId == goods_temp.GoodId { // 已经出库和新请求出库的出库数量一致，则清除两个结构体里的数据（既不出库，也不删除出库） if goods_yc_temp.Count == goods_temp.Count { goods_yc = append(goods_yc[:i], goods_yc[i+1:]...) goods = append(goods[:j], goods[j+1:]...) break } //fmt.Println("998888888888888", goods_yc_temp.Count) //fmt.Println("7777777777777777", goods_temp.Count) // 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库 if goods_yc_temp.Count > goods_temp.Count { temp_count := goods_yc_temp.Count - goods_temp.Count goods_yc[i].Count = temp_count goods = append(goods[:j], goods[j+1:]...) break } //fmt.Println("555555555555", goods_yc_temp.Count) //fmt.Println("444444444444", goods_temp.Count) // 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库 if goods_yc_temp.Count < goods_temp.Count { temp_count := goods_temp.Count - goods_yc_temp.Count //fmt.Println("988888888888888", temp_count) goods[j].Count = temp_count goods_yc = append(goods_yc[:i], goods_yc[i+1:]...) //fmt.Println("888888888", goods_yc) break } } } } // goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据 // goods 这个数据就是需要出库的耗材的数据(新增的数据) fmt.Println("goods222222222222", goods) fmt.Println("goodsy999999999999", goods_yc) if len(goods) > 0 { out, err := FindStockOutByIsSys(orgID, 1, record_time) if err == gorm.ErrRecordNotFound { //没有记录，则创建出库单 timeStr := time.Now().Format("2006-01-02") timeArr := strings.Split(timeStr, "-") total, _ := FindAllWarehouseOut(orgID) total = total + 1 warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" number, _ := strconv.ParseInt(warehousing_out_order, 10, 64) number = number + total warehousing_out_order = "CKD" + strconv.FormatInt(number, 10) warehouseOut := models.WarehouseOut{ WarehouseOutOrderNumber: warehousing_out_order, OperationTime: time.Now().Unix(), OrgId: orgID, Creater: 0, Ctime: time.Now().Unix(), Status: 1, WarehouseOutTime: record_time, Dealer: 0, Manufacturer: 0, Type: 1, IsSys: 1, } err := AddSigleWarehouseOut(&warehouseOut) if err != nil { utils.TraceLog("创建出库单失败 err = %v", err) return err } else { out = warehouseOut } } for _, item := range goods { var newCount int64 = 0 for _, it := range goodOne { if item.GoodTypeId == it.GoodTypeId && item.GoodId == it.GoodId { newCount = it.Count } } prepare := models.DialysisBeforePrepare{ GoodTypeId: item.GoodTypeId, GoodId: item.GoodId, Count: item.Count, } fmt.Println("count0000000000000000000000000000000", newCount) ConsumablesDelivery(orgID, patient_id, record_time, &prepare, &out, newCount) } } if len(goods_yc) > 0 { for _, good_yc := range goods_yc { out, _ := FindStockOutByIsSys(orgID, 1, record_time) ConsumablesDeliveryDelete(orgID, patient_id, record_time, good_yc, &out) } } return nil } //耗材出库 func ConsumablesDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) { // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 var maxNumber int64 = 0 deliver_number = goods.Count fmt.Println("添加数量", deliver_number) // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId) fmt.Println("库存数量", warehouse.StockCount) if err != nil { return } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockCount // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { 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: 1, SysRecordTime: record_time, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, PatientId: patient_id, } warehouseOutInfo.Count = count stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID) warehouseOutInfo.Price = stockInInfo.Price //判断当前耗材是否有出库详情记录 _, errcode := GetStockInRecoredByGoodId(goods.GoodId, goods.GoodTypeId, record_time, patient_id, orgID) if errcode == gorm.ErrRecordNotFound { errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } else { details := models.BloodAutomaticReduceDetail{ WarehouseOutId: warehouseOutInfo.ID, WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber, PatientId: patient_id, Ctime: time.Now().Unix(), Mtime: time.Now().Unix(), Status: 1, RecordTime: record_time, OrgId: orgID, GoodId: goods.GoodId, GoodTypeId: goods.GoodTypeId, Count: count, } //查询当天耗材是否已经存在数据 _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) fmt.Println("errcode00000000000000000000000000000000000000", errcode) if errcode == gorm.ErrRecordNotFound { errTwo := CreateAutoReduceRecord(&details) if errTwo != nil { return errTwo } } else if errcode == nil { fmt.Println("sql999999999999999999999999999999999999999") DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) CreateAutoReduceRecord(&details) } } } 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: 1, SysRecordTime: record_time, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, PatientId: patient_id, } fmt.Println("count9999999999999999999999999999999999999", count) warehouseOutInfo.Count = count //更新入库详情表 UpdateAutoMaticReduceDetail(goods.GoodId, goods.GoodTypeId, record_time, patient_id, orgID, warehouseOutInfo) details := models.BloodAutomaticReduceDetail{ WarehouseOutId: warehouseOutInfo.ID, WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber, PatientId: patient_id, Ctime: time.Now().Unix(), Mtime: time.Now().Unix(), Status: 1, RecordTime: record_time, OrgId: orgID, GoodId: goods.GoodId, GoodTypeId: goods.GoodTypeId, Count: count, } //查询当天耗材是否已经存在数据 _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) if errcode == gorm.ErrRecordNotFound { errTwo := CreateAutoReduceRecord(&details) if errTwo != nil { return errTwo } } else if errcode == nil { DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) CreateAutoReduceRecord(&details) } } fmt.Println("newcount9999999999999999999999999999999", goods.NewCount) maxNumber = goods.Count if warehouse.StockCount < maxNumber { return errors.New("库存数量不足") } warehouse.StockCount = warehouse.StockCount - maxNumber fmt.Println("999999999999999", warehouse.StockCount) warehouse.Mtime = time.Now().Unix() if warehouse.StockCount < 0 { return errors.New("库存数量不足") } errThree := UpDateWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } return nil } else { // 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 // 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: 1, // SysRecordTime: record_time, // GoodTypeId: goods.GoodTypeId, // GoodId: goods.GoodId, // PatientId: patient_id, // } // warehouseOutInfo.Count = stock_number // stockInInfo, _ := service.FindLastStockInInfoRecord(goods.GoodId, orgID) // warehouseOutInfo.Price = stockInInfo.Price // cur_warehouse, errcode := GetStockInRecoredByGoodId(goods.GoodId, goods.GoodTypeId, record_time, patient_id, orgID) // if errcode == gorm.ErrRecordNotFound { // errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo) // if errOne != nil { // return errOne // } else { // details := &models.AutomaticReduceDetail{ // WarehouseOutId: warehouseOutInfo.ID, // WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber, // PatientId: patient_id, // Ctime: time.Now().Unix(), // Mtime: time.Now().Unix(), // Status: 1, // RecordTime: record_time, // OrgId: orgID, // GoodId: goods.GoodId, // GoodTypeId: goods.GoodTypeId, // Count: goods.Count, // } // errTwo := service.AddSigleAutoReduceRecordInfo(details) // if errTwo != nil { // return errTwo // } // } // // 出库完成后，要将该批次库存清零 // warehouse.StockCount = 0 // warehouse.Mtime = time.Now().Unix() // errThree := UpDateWarehouseInfoByStock(&warehouse) // if errThree != nil { // return errThree // } // // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 // goods.Count = deliver_number - stock_number // ConsumablesDelivery(orgID, patient_id, 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: 1, // SysRecordTime: record_time, // GoodTypeId: goods.GoodTypeId, // GoodId: goods.GoodId, // PatientId: patient_id, // } // warehouseOutInfo.Count = cur_warehouse.Count + StockCount // //更新入库详情表 // UpdateAutoMaticReduceDetail(goods.GoodId, goods.GoodTypeId, record_time, patient_id, orgID, warehouseOutInfo) // details := models.BloodAutomaticReduceDetail{ // WarehouseOutId: warehouseOutInfo.ID, // WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber, // PatientId: patient_id, // Ctime: time.Now().Unix(), // Mtime: time.Now().Unix(), // Status: 1, // RecordTime: record_time, // OrgId: orgID, // GoodId: goods.GoodId, // GoodTypeId: goods.GoodTypeId, // Count: count, // } // //查询当天耗材是否已经存在数据 // _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) // if errcode == gorm.ErrRecordNotFound { // errTwo := CreateAutoReduceRecord(&details) // if errTwo != nil { // return errTwo // } // } else if errcode == nil { // DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) // CreateAutoReduceRecord(&details) // } // } // 出库完成后，要将该批次库存清零 warehouse.StockCount = 0 warehouse.Mtime = time.Now().Unix() errThree := UpDateWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 goods.Count = deliver_number - stock_number ConsumablesDelivery(orgID, patient_id, record_time, goods, warehouseOut, count) } return nil } //耗材出库删除 func ConsumablesDeliveryDelete(orgID int64, patient_id int64, record_time int64, good_yc *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut) (err error) { // 先根据相关信息查询当天该耗材的出库信息 warehouseOutInfos, err := FindStockOutInfoByStock(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time, patient_id) if err != nil { return err } var delete_count int64 = 0 for _, ware := range warehouseOutInfos { // 判断当前出库的数据和删除出库数量 if good_yc.Count <= ware.Count { delete_count = good_yc.Count } else { delete_count = ware.Count } // 在出库记录表里记录退库详情 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, //WarehouseInfoId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 2, SysRecordTime: record_time, GoodTypeId: good_yc.GoodTypeId, GoodId: good_yc.GoodId, PatientId: patient_id, } warehouseOutInfo.Count = ware.Count - delete_count stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID) warehouseOutInfo.Price = stockInInfo.Price errOne := UpdateAutoMaticReduceDetail(good_yc.GoodId, good_yc.GoodTypeId, record_time, patient_id, orgID, warehouseOutInfo) if errOne != nil { return errOne } else { details := &models.AutomaticReduceDetail{ WarehouseOutId: warehouseOutInfo.ID, WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber, PatientId: patient_id, Ctime: time.Now().Unix(), Mtime: time.Now().Unix(), Status: 1, RecordTime: record_time, OrgId: orgID, GoodId: good_yc.GoodId, GoodTypeId: good_yc.GoodTypeId, Count: warehouseOutInfo.Count, Type: 2, } //查询是否当天已经存在数据 _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) if errcode == gorm.ErrRecordNotFound { errTwo := AddSigleAutoReduceRecordInfo(details) if errTwo != nil { return errTwo } } else if errcode == nil { DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) AddSigleAutoReduceRecordInfo(details) } } // 删除出库完成后，要增加对应批次的库存数量 errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count) if errThree != nil { return errThree } // 增加了对应的库存后，看看还有多少需要退库的 good_yc.Count = good_yc.Count - delete_count if good_yc.Count == 0 { return nil } } if good_yc.Count == 0 { return nil } else { return errors.New("退库和出库数据不匹配") } } func GetAutoReduceRecordInfoByPatientId(orgid int64, patient_id int64, recordTime int64) (autoReduce []*models.AutomaticReduceDetail, err error) { err = XTReadDB().Model(&autoReduce).Where("org_id = ? and patient_id = ? and record_time = ? and status = 1", orgid, patient_id, recordTime).Find(&autoReduce).Error return autoReduce, err } func DeleteDialysisBefor(orgid int64, patient_id int64, record_date int64, goodid int64, goodtypeid int64) error { prepare := models.DialysisBeforePrepare{} err := XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and status = 1 and good_id = ? and good_type_id = ?", orgid, patient_id, record_date, goodid, goodtypeid).Updates(map[string]interface{}{"status": 0, "count": 0, "mtime": time.Now().Unix()}).Error return err } func DeleteDialysisBeforThree(orgid int64, patient_id int64, record_date int64) error { prepare := models.DialysisBeforePrepare{} err := XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and status = 1", orgid, patient_id, record_date).Updates(map[string]interface{}{"status": 0, "count": 0, "mtime": time.Now().Unix()}).Error return err } func ConsumablesDeliveryTotalOne(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods, goodOne []*models.NewDialysisBeforePrepareGoods) (err error) { //查询该患者当天已经出库的耗材信息 goods_yc, _ := FindConsumablesByDateTwo(orgID, patient_id, record_time) for _, item := range goods_yc { fmt.Println("item0000000000000", item.Count) } for _, item := range goods { fmt.Println("item1111111111111", item.Count) } // 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的 for i := len(goods_yc) - 1; i >= 0; i-- { goods_yc_temp := goods_yc[i] for j := len(goods) - 1; j >= 0; j-- { goods_temp := goods[j] // 已经出库和新请求出库都存在该耗材，则判断出库数量，分成是继续出库，还是删除出库 if goods_yc_temp.GoodTypeId == goods_temp.GoodTypeId && goods_yc_temp.GoodId == goods_temp.GoodId { // 已经出库和新请求出库的出库数量一致，则清除两个结构体里的数据（既不出库，也不删除出库） if goods_yc_temp.Count == goods_temp.Count { goods_yc = append(goods_yc[:i], goods_yc[i+1:]...) goods = append(goods[:j], goods[j+1:]...) } fmt.Println("998888888888888", goods_yc_temp.Count) fmt.Println("7777777777777777", goods_temp.Count) // 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库 if goods_yc_temp.Count > goods_temp.Count { fmt.Println("进来了是吗") temp_count := goods_yc_temp.Count - goods_temp.Count goods_yc[i].Count = temp_count goods = append(goods[:j], goods[j+1:]...) break } fmt.Println("555555555555", goods_yc_temp.Count) fmt.Println("444444444444", goods_temp.Count) // 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库 if goods_yc_temp.Count < goods_temp.Count { temp_count := goods_temp.Count - goods_yc_temp.Count fmt.Println("988888888888888", temp_count) goods[j].Count = temp_count goods_yc = append(goods_yc[:i], goods_yc[i+1:]...) fmt.Println("888888888", goods_yc) } } } } // goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据 // goods 这个数据就是需要出库的耗材的数据 fmt.Println("goods222222222222", goods) fmt.Println("goodsy999999999999", goods_yc) if len(goods) > 0 { out, err := FindStockOutByIsSys(orgID, 1, record_time) if err == gorm.ErrRecordNotFound { //没有记录，则创建出库单 timeStr := time.Now().Format("2006-01-02") timeArr := strings.Split(timeStr, "-") total, _ := FindAllWarehouseOut(orgID) total = total + 1 warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" number, _ := strconv.ParseInt(warehousing_out_order, 10, 64) number = number + total warehousing_out_order = "CKD" + strconv.FormatInt(number, 10) warehouseOut := models.WarehouseOut{ WarehouseOutOrderNumber: warehousing_out_order, OperationTime: time.Now().Unix(), OrgId: orgID, Creater: 0, Ctime: time.Now().Unix(), Status: 1, WarehouseOutTime: record_time, Dealer: 0, Manufacturer: 0, Type: 1, IsSys: 1, } err := AddSigleWarehouseOut(&warehouseOut) if err != nil { utils.TraceLog("创建出库单失败 err = %v", err) return err } else { out = warehouseOut } } for _, item := range goods { for _, it := range goodOne { if item.GoodTypeId == it.GoodTypeId && it.GoodId == it.GoodId { it.NewCount = item.Count } } } for _, item := range goodOne { //prepare := models.DialysisBeforePrepare{ // GoodTypeId: item.GoodTypeId, // GoodId: item.GoodId, // Count: item.Count, // NewCount: item.NewCount, //} info := models.WarehouseOutInfo{ GoodTypeId: item.GoodTypeId, GoodId: item.GoodId, Count: item.Count, } ConsumablesDeliveryOne(orgID, record_time, &info, &out, item.Count) } } if len(goods_yc) > 0 { for _, good_yc := range goods_yc { out, _ := FindStockOutByIsSys(orgID, 1, record_time) ConsumablesDeliveryDeleteOne(orgID, record_time, good_yc, &out) } } return nil } //耗材出库 func ConsumablesDeliveryOne(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64) (err error) { // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 var maxNumber int64 = 0 deliver_number = goods.Count fmt.Println("添加数量", deliver_number) // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockCount // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { 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 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 } maxNumber = goods.Count if warehouse.StockCount < maxNumber { return errors.New("库存数量不足") } warehouse.StockCount = warehouse.StockCount - maxNumber warehouse.Mtime = time.Now().Unix() if warehouse.StockCount < 0 { return errors.New("库存数量不足") } errThree := UpDateWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } return nil } else { // 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 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 = 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 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) } } return nil } //耗材出库删除 func ConsumablesDeliveryDeleteOne(orgID int64, record_time int64, good_yc *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut) (err error) { // 先根据相关信息查询当天该耗材的出库信息 warehouseOutInfos, err := FindStockOutInfoByStockOne(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time) if err != nil { return err } var delete_count int64 = 0 for _, ware := range warehouseOutInfos { // 判断当前出库的数据和删除出库数量 if good_yc.Count <= ware.Count { delete_count = good_yc.Count } else { delete_count = ware.Count } // 在出库记录表里记录退库详情 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, //WarehouseInfoId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: "", OrgId: orgID, Type: 1, Manufacturer: 0, Dealer: 0, IsSys: 0, SysRecordTime: record_time, GoodTypeId: good_yc.GoodTypeId, GoodId: good_yc.GoodId, } warehouseOutInfo.Count = delete_count stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID) warehouseOutInfo.Price = stockInInfo.Price errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } // 删除出库完成后，要增加对应批次的库存数量 errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count) if errThree != nil { return errThree } // 增加了对应的库存后，看看还有多少需要退库的 good_yc.Count = good_yc.Count - delete_count if good_yc.Count == 0 { return nil } } if good_yc.Count == 0 { return nil } else { return errors.New("退库和出库数据不匹配") } }