package service import ( "Xcx_New/models" "Xcx_New/utils" "errors" "fmt" _ "fmt" "github.com/jinzhu/gorm" "math" "strconv" "strings" "time" ) // 药品出库 func DrugsDelivery(orgID int64, creater 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 } 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: creater, 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) //查找药品信息 baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, Number: warehouse.Number, BatchNumber: warehouse.BatchNumber, Price: baseInfo.RetailPrice, CountUnit: advice.PrescribingNumberUnit, RetailPrice: baseInfo.RetailPrice, ProductDate: warehouse.ProductDate, ExpiryDate: warehouse.ExpiryDate, PatientId: advice.PatientId, Count: count, WarehouseInfoId: warehouse.ID, } fmt.Println("单据号2232322323232323232323232323232323", warehouseout.WarehouseOutOrderNumber) drugflow := models.DrugFlow{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, DrugId: advice.DrugId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: count, 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) //查询是否存在数据 _, 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: warehouseout.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 } // 出库完成后，要减去对应批次的库存数量 // 判断处方里药品单位是拆零单位还是包装单位, 如果是拆零单位，则根据规格，将拆零数量转为包装数量 var maxNumber int64 = 0 var minNumber int64 = 0 fmt.Println("单位1111111111", advice.PrescribingNumberUnit) fmt.Println("单位222222222222222", drup.MaxUnit) if advice.PrescribingNumberUnit == drup.MaxUnit { maxNumber = count / drup.MinNumber minNumber = count % drup.MinNumber } else { minNumber = count } fmt.Println("maxNumber0000000000000", maxNumber) fmt.Println("minNumber999999999999999", minNumber) 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: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, Number: warehouse.Number, BatchNumber: warehouse.BatchNumber, Price: baseInfo.RetailPrice, CountUnit: advice.PrescribingNumberUnit, ProductDate: warehouse.ProductDate, ExpiryDate: warehouse.ExpiryDate, PatientId: advice.PatientId, Count: count, WarehouseInfoId: warehouse.ID, } //查询是否存在数据 _, 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) advice.PrescribingNumber = float64(prescribingNumber_two_temp) advice.PrescribingNumberUnit = advice.PrescribingNumberUnit DrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice) } return } // 药品出库 func HisDrugsDelivery(orgID int64, creater 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: creater, 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) if advice.PrescribingNumberUnit == drup.MaxUnit { deliver_number = count * drup.MinNumber } else { deliver_number = count } // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 //开启事物 warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId) //查找药品信息 baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber fmt.Println("拆零数量2222222222222222222", stock_number) fmt.Println("出库数量55555555555555555555", deliver_number) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, Number: warehouse.Number, BatchNumber: warehouse.BatchNumber, Price: baseInfo.RetailPrice, CountUnit: baseInfo.MaxUnit, RetailPrice: baseInfo.RetailPrice, ProductDate: warehouse.ProductDate, ExpiryDate: warehouse.ExpiryDate, PatientId: advice.PatientId, WarehouseInfoId: warehouse.ID, } warehouseOutInfo.Count = count warehouseOutInfo.CountUnit = advice.PrescribingNumberUnit drugflow := models.DrugFlow{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, DrugId: advice.DrugId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: count, 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) //查询是否存在数据 _, 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: warehouseout.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 } // 出库完成后，要减去对应批次的库存数量 // 判断处方里药品单位是拆零单位还是包装单位, 如果是拆零单位，则根据规格，将拆零数量转为包装数量 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: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: advice.RecordDate, DrugId: advice.DrugId, Number: warehouse.Number, BatchNumber: warehouse.BatchNumber, Price: baseInfo.RetailPrice, RetailPrice: baseInfo.RetailPrice, ProductDate: warehouse.ProductDate, ExpiryDate: warehouse.ExpiryDate, PatientId: advice.PatientId, WarehouseInfoId: warehouse.ID, } warehouseOutInfo.Count = count warehouseOutInfo.CountUnit = advice.PrescribingNumberUnit 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) //查询是否存在数据 _, 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: warehouseout.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 } // 出库完成后，要将该批次库存清零 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 = advice.PrescribingNumberUnit 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 // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.DrugWarehouseOutInfo{ WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber, WarehouseOutId: warehouseout.ID, Status: 1, Ctime: time.Now().Unix(), Remark: advice.Remark, OrgId: orgID, Type: 1, Manufacturer: advice.Manufacturer, Dealer: advice.Dealer, IsSys: 0, SysRecordTime: advice.Ctime, DrugId: advice.DrugId, ExpiryDate: advice.ExpiryDate, ProductDate: advice.ProductDate, Number: advice.Number, BatchNumber: advice.BatchNumber, Count: advice.Count, RetailPrice: advice.RetailPrice, Price: advice.Price, WarehouseInfoId: advice.WarehouseInfoId, } warehouseOutInfo.Count = prescribingNumber 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: advice.Remark, OrgId: orgID, Type: 1, Manufacturer: advice.Manufacturer, Dealer: advice.Dealer, IsSys: 0, SysRecordTime: advice.Ctime, DrugId: advice.DrugId, ExpiryDate: advice.ExpiryDate, ProductDate: advice.ProductDate, Number: advice.Number, BatchNumber: advice.BatchNumber, Count: advice.Count, RetailPrice: advice.RetailPrice, Price: advice.Price, } warehouseOutInfo.Count = prescribingNumber 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, creator int64) (err error) { //查询该患者当天已经出库的耗材信息 goods_yc, _ := FindConsumablesByDateTwo(orgID, patient_id, record_time) // 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的 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 } // 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库 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 } // 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库 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: creator, 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, } 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) { fmt.Println("count23232323232323232323232323", count) fmt.Println("hhhh2h3h3h2h23h32hh23h32h23", goods.Count) // 判断处方里药品单位是拆零单位还是包装单位, 如果是包装单位，则根据规格，将包装数量转为拆零数量 var deliver_number int64 = 0 var stock_number int64 = 0 var maxNumber int64 = 0 deliver_number = goods.Count // 根据先进先出原则，查询最先入库的批次，进行出库 // 如果没有对应的库存，则报错 warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId) if err != nil { return errors.New("库存数量不足") } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockCount //获取耗材信息 info, _ := GetGoodInformationByGoodId(goods.GoodId) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: record_time, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, PatientId: patient_id, Number: warehouse.Number, LicenseNumber: warehouse.LicenseNumber, Price: info.PackingPrice, ExpiryDate: warehouse.ExpiryDate, ProductDate: warehouse.ProductDate, } warehouseOutInfo.Count = count _, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time) if errcodes == gorm.ErrRecordNotFound { errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } } else if errcodes == nil { UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, patient_id, record_time) } 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 } //插入库存流水表 flow := models.VmStockFlow{ WarehouseOutId: warehouseOut.ID, WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: deliver_number, 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, } //查询流水是否存在 exsit, errflow := GetStockFlowIsExsit(warehouseOut.ID, patient_id, record_time, goods.GoodId) fmt.Println("什么数据233232323", errflow) if errflow == gorm.ErrRecordNotFound { errThre := CreateStockFlowOne(flow) if errThre != nil { return errThre } } 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), } errFour := UpdatedStockFlow(flow) if errFour != nil { return errFour } } } else if errcode == nil { flow := models.VmStockFlow{ WarehouseOutId: warehouseOut.ID, WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: deliver_number, 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, } //查询流水是否存在 exsit, errflow := GetStockFlowIsExsit(warehouseOut.ID, patient_id, record_time, goods.GoodId) if errflow == gorm.ErrRecordNotFound { CreateStockFlowOne(flow) DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId) CreateAutoReduceRecord(&details) } 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 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 { fmt.Println("不进来22323232323232323232233223323223322323") // 当刚批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: warehouse.Remark, OrgId: orgID, Type: 1, Manufacturer: warehouse.Manufacturer, Dealer: warehouse.Dealer, IsSys: 1, SysRecordTime: record_time, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, PatientId: patient_id, Number: warehouse.Number, LicenseNumber: warehouse.LicenseNumber, Price: info.PackingPrice, ExpiryDate: warehouse.ExpiryDate, ProductDate: warehouse.ProductDate, } warehouseOutInfo.Count = stock_number _, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, goods.PatientId, record_time) fmt.Println("hhhhh2h323233223232323", errcodes) if errcodes == gorm.ErrRecordNotFound { errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } //插入库存流水表 flow := models.VmStockFlow{ WarehouseOutId: warehouseOut.ID, WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: stock_number, 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, } //查询流水是否存在 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 = stock_number UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, goods.PatientId, record_time) //插入库存流水表 flow := models.VmStockFlow{ WarehouseOutId: warehouseOut.ID, WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: warehouse.Number, ProductDate: warehouse.ProductDate, ExpireDate: warehouse.ExpiryDate, Count: stock_number, 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, } //查询流水是否存在 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) } } // 出库完成后，要将该批次库存清零 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 ConsumablesDeliveryOne(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64, creator 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("err222222222222222222222", warehouse.StockCount) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockCount fmt.Println("3434343434343434", stock_number) fmt.Println("8888888888888888888", deliver_number) // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { fmt.Println("g2332232332323232232323322332", goods.Price) warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: goods.Remark, OrgId: orgID, Type: 1, 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, LicenseNumber: goods.LicenseNumber, } warehouseOutInfo.Count = goods.Count errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } stockFlow := models.VmStockFlow{ WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: goods.Number, LicenseNumber: goods.LicenseNumber, Count: goods.Count, UserOrgId: goods.OrgId, PatientId: goods.PatientId, SystemTime: record_time, ConsumableType: 2, IsSys: goods.IsSys, WarehousingOrder: "", WarehouseOutId: warehouseOut.ID, WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, IsEdit: 1, CancelStockId: 0, CancelOrderNumber: "", Manufacturer: goods.Manufacturer, Dealer: goods.Dealer, Creator: creator, UpdateCreator: 0, Status: 1, Ctime: time.Now().Unix(), Mtime: 0, Price: goods.Price, WarehousingDetailId: 0, WarehouseOutDetailId: warehouseOutInfo.ID, CancelOutDetailId: 0, ProductDate: goods.ProductDate, ExpireDate: goods.ExpiryDate, } //创建出库明细 CreateStockFlowOne(stockFlow) 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 } } else { // 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: goods.Remark, OrgId: orgID, Type: 1, 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, LicenseNumber: goods.LicenseNumber, } warehouseOutInfo.Count = stock_number info, errcodes := GetStockInRecoredByGoodIdOne(goods.GoodId, goods.GoodTypeId, goods.SysRecordTime, goods.OrgId) if errcodes == gorm.ErrRecordNotFound { errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } } else { warehouseOutInfo.Count = info.Count + stock_number UpdateAutoMaticReduceDetailOne(goods.GoodId, goods.GoodTypeId, goods.SysRecordTime, goods.OrgId, warehouseOutInfo) } stockFlow := models.VmStockFlow{ WarehousingId: warehouse.ID, GoodId: goods.GoodId, Number: goods.Number, LicenseNumber: goods.LicenseNumber, Count: goods.Count, UserOrgId: goods.OrgId, PatientId: 0, SystemTime: record_time, ConsumableType: 2, IsSys: 0, WarehousingOrder: "", WarehouseOutId: warehouseOut.ID, WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, IsEdit: 1, CancelStockId: 0, CancelOrderNumber: "", Manufacturer: goods.Manufacturer, Dealer: goods.Dealer, Creator: creator, UpdateCreator: 0, Status: 1, Ctime: time.Now().Unix(), Mtime: 0, Price: goods.Price, WarehousingDetailId: 0, WarehouseOutDetailId: warehouseOutInfo.ID, CancelOutDetailId: 0, ProductDate: goods.ProductDate, ExpireDate: goods.ExpiryDate, } //创建出库明细 CreateStockFlowOne(stockFlow) // 出库完成后，要将该批次库存清零 warehouse.StockCount = 0 warehouse.Mtime = time.Now().Unix() errThree := UpDateWarehouseInfoByStock(&warehouse) if errThree != nil { return errThree } // 清零完该库存后，还有剩余出库未出完，进行对应的递归操作 goods.Count = deliver_number - stock_number fmt.Println("goods3333333333333333333333", goods.Count) ConsumablesDeliveryOne(orgID, record_time, goods, warehouseOut, count, creator) } 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("退库和出库数据不匹配") } } //退库逻辑 func ConsumablesDeliveryTwo(orgID int64, goods *models.WarehouseOutInfo, 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 := FindFirstWarehousingInfoByGoodId(goods.GoodId, goods.ID) if err != nil { return err } // 将该批次的剩余库存数量转换为拆零数量 stock_number = warehouse.StockCount // 当库存数量大于或等于出库数量的话，则正常出库该批次 if stock_number >= deliver_number { warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber, WarehouseOutId: goods.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: goods.Remark, OrgId: orgID, Type: 1, Manufacturer: goods.Manufacturer, Dealer: goods.Dealer, IsSys: 0, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, ExpiryDate: goods.ExpiryDate, ProductDate: goods.ProductDate, Number: goods.Number, Price: goods.Price, LicenseNumber: goods.LicenseNumber, ConsumableType: 2, } warehouseOutInfo.Count = goods.Count errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) if errOne != nil { return errOne } 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 } } else { // 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber, WarehouseOutId: goods.ID, WarehouseInfotId: warehouse.ID, Status: 1, Ctime: time.Now().Unix(), Remark: goods.Remark, OrgId: orgID, Type: 1, Manufacturer: goods.Manufacturer, Dealer: goods.Dealer, IsSys: 0, GoodTypeId: goods.GoodTypeId, GoodId: goods.GoodId, ExpiryDate: goods.ExpiryDate, ProductDate: goods.ProductDate, Number: goods.Number, Price: goods.Price, LicenseNumber: goods.LicenseNumber, ConsumableType: 2, } warehouseOutInfo.Count = stock_number errOne := 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 ConsumablesDeliveryTwo(orgID, goods, count) } return nil } func DeleteWarehouseInfo(id int64) error { err := XTWriteDB().Model(models.WarehousingInfo{}).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"stock_count": 0}).Error return err } // ////当前数据比上一次出库数据少 //func ConsumablesDeliveryTotalSeven(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods,creater int64,count int64) (err error) { // // fmt.Println("w我的中国馆公共区发电房阿道夫安抚安抚安抚安抚安抚安抚阿道夫阿道夫阿凡达阿道夫a",count) // //查询该患者当天已经出库的耗材信息 // goods_yc, _ := FindConsumablesByDateThree(orgID, patient_id, record_time) // // 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的 // 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 // } // // 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库 // 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 // } // // 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库 // 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("goodsy999999999999", goods_yc) // // // // //退库 // if len(goods_yc) > 0 { // for _, good_yc := range goods_yc { // out, _ := FindStockOutByIsSys(orgID, 1, record_time) // ConsumablesDeliveryDeleteFour(orgID, record_time, good_yc, &out,patient_id,creater,count) // } // } // // return nil //} ////耗材出库删除 //func ConsumablesDeliveryDeleteFour(orgID int64, record_time int64, good_yc *models.BloodAutomaticReduceDetail, warehouseOut *models.WarehouseOut,patient_id int64,creater int64,count int64) (err error) { // // fmt.Println("count2323223884584854854854u5454785487547845785478758487545475475487,count",count) // // 先根据相关信息查询当天该耗材的出库信息 // warehouseOutInfos, err := FindStockOutInfoByStockTwo(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time,good_yc.PatientId) // fmt.Println("errr232323232323232323232323232",err) // if err != nil { // return err // } // // var delete_count int64 = 0 // // delete_count = warehouseOutInfos.Count - count // // fmt.Println("delete_count2323232",delete_count) // // 在出库记录表里记录退库详情 // warehouseOutInfo := &models.WarehouseOutInfo{ // WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, // WarehouseOutId: warehouseOut.ID, // Status: 1, // Ctime: time.Now().Unix(), // OrgId: orgID, // Type: 1, // IsSys: 1, // SysRecordTime: record_time, // GoodTypeId: good_yc.GoodTypeId, // GoodId: good_yc.GoodId, // PatientId:good_yc.PatientId, // ConsumableType:2, // // } // warehouseOutInfo.Count = count // // stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID) // warehouseOutInfo.Price = stockInInfo.Price // warehouseOutInfo.Dealer = stockInInfo.Dealer // warehouseOutInfo.Manufacturer = stockInInfo.Manufacturer // warehouseOutInfo.ExpiryDate = stockInInfo.ExpiryDate // warehouseOutInfo.ProductDate = stockInInfo.ProductDate // warehouseOutInfo.Number = stockInInfo.Number // warehouseOutInfo.LicenseNumber = stockInInfo.LicenseNumber // warehouseOutInfo.WarehouseInfotId = stockInInfo.ID // //查找当天是否存在出库记录 // // _, errcod := GetWarehouseOutInfoIsExistOne(good_yc.GoodId, good_yc.PatientId, record_time) // fmt.Println("errcode2323223255556652324242424242424242424242424242242",errcod) // if errcod == gorm.ErrRecordNotFound{ // errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) // //插入详情明细表 // stockFlow := models.VmStockFlow{ // WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, // WarehouseOutId: warehouseOut.ID, // GoodId: good_yc.GoodId, // Number: stockInInfo.Number, // ProductDate: stockInInfo.ProductDate, // ExpireDate: stockInInfo.ExpiryDate, // Count: 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: 2, // WarehousingDetailId:0, // IsSys:1, // UpdateCreator:creater, // } // //创建流水表 // err := CreateStockFlowOne(stockFlow) // fmt.Println("h2h3h2323342i24i242i4u2i4242u42424",err) // if errOne != nil { // return errOne // } // }else if errcod == nil{ // UpdatedWarehouseOutInfo(warehouseOutInfo,good_yc.GoodId,good_yc.PatientId,record_time) // //插入详情明细表 // stockFlow := models.VmStockFlow{ // WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, // WarehouseOutId: warehouseOut.ID, // GoodId: good_yc.GoodId, // Number: stockInInfo.Number, // ProductDate: stockInInfo.ProductDate, // ExpireDate: stockInInfo.ExpiryDate, // Count: 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: 2, // WarehousingDetailId:0, // IsSys:1, // UpdateCreator:creater, // } // //创建流水表 // CreateStockFlowOne(stockFlow) // } // // // // //更改自动出库的表格 // 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: good_yc.GoodId, // GoodTypeId: good_yc.GoodTypeId, // Count: count, // } // //查询当天耗材是否已经存在数据 // _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) // // if errcode == gorm.ErrRecordNotFound { // errTwo := CreateAutoReduceRecord(&details) // if errTwo != nil { // return errTwo // } // } else if errcode == nil { // DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) // CreateAutoReduceRecord(&details) // } // // 删除出库完成后，要增加对应批次的库存数量 // fmt.Println("deletecount2323232323232323232323232323",delete_count) // errThree := UpDateWarehouseInfoByStockDelete(warehouseOutInfos.WarehouseInfotId, delete_count) // // if errThree != nil { // return errThree // } // // // if good_yc.Count == 0 { // return nil // } else { // return errors.New("退库和出库数据不匹配") // } //} //耗材出库删除 func ConsumablesDeliveryDeleteFive(orgID int64, record_time int64, good_yc *models.BloodAutomaticReduceDetail, warehouseOut *models.WarehouseOut, patient_id int64, creater int64, count int64) (err error) { fmt.Println("count23232323232323232323232323223223", count) // 先根据相关信息查询当天该耗材的出库信息 warehouseOutInfos, err := FindStockOutInfoByStockTwo(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time, good_yc.PatientId) fmt.Println("errr232323232323232323232323232", err) if err != nil { return err } var delete_count int64 = 0 delete_count = count - warehouseOutInfos.Count // 判断当前出库的数据和删除出库数量 // 在出库记录表里记录退库详情 warehouseOutInfo := &models.WarehouseOutInfo{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, Status: 1, Ctime: time.Now().Unix(), OrgId: orgID, Type: 1, IsSys: 1, SysRecordTime: record_time, GoodTypeId: good_yc.GoodTypeId, GoodId: good_yc.GoodId, PatientId: good_yc.PatientId, ConsumableType: 2, } warehouseOutInfo.Count = count stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID) warehouseOutInfo.Price = stockInInfo.Price warehouseOutInfo.Dealer = stockInInfo.Dealer warehouseOutInfo.Manufacturer = stockInInfo.Manufacturer warehouseOutInfo.ExpiryDate = stockInInfo.ExpiryDate warehouseOutInfo.ProductDate = stockInInfo.ProductDate warehouseOutInfo.Number = stockInInfo.Number warehouseOutInfo.LicenseNumber = stockInInfo.LicenseNumber warehouseOutInfo.WarehouseInfotId = stockInInfo.ID //查找当天是否存在出库记录 _, errcod := GetWarehouseOutInfoIsExistOne(good_yc.GoodId, good_yc.PatientId, record_time) fmt.Println("errcode2323223255556652324242424242424242424242424242242", errcod) if errcod == gorm.ErrRecordNotFound { errOne := AddSigleWarehouseOutInfo(warehouseOutInfo) //插入详情明细表 stockFlow := models.VmStockFlow{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, GoodId: good_yc.GoodId, Number: stockInInfo.Number, ProductDate: stockInInfo.ProductDate, ExpireDate: stockInInfo.ExpiryDate, Count: 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, } //创建流水表 err := CreateStockFlowOne(stockFlow) fmt.Println("h2h3h2323342i24i242i4u2i4242u42424", err) if errOne != nil { return errOne } } else if errcod == nil { UpdatedWarehouseOutInfo(warehouseOutInfo, good_yc.GoodId, good_yc.PatientId, record_time) //插入详情明细表 stockFlow := models.VmStockFlow{ WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber, WarehouseOutId: warehouseOut.ID, GoodId: good_yc.GoodId, Number: stockInInfo.Number, ProductDate: stockInInfo.ProductDate, ExpireDate: stockInInfo.ExpiryDate, Count: 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, } //创建流水表 err := CreateStockFlowOne(stockFlow) fmt.Println("h2h3h2323342i24i242i4u2i4242u42424", err) } //更改自动出库的表格 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: good_yc.GoodId, GoodTypeId: good_yc.GoodTypeId, Count: count, } //查询当天耗材是否已经存在数据 _, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) if errcode == gorm.ErrRecordNotFound { errTwo := CreateAutoReduceRecord(&details) if errTwo != nil { return errTwo } } else if errcode == nil { DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId) CreateAutoReduceRecord(&details) } // 删除出库完成后，要增加对应批次的库存数量 errThree := UpDateWarehouseInfoByStockDeleteOne(warehouseOutInfos.WarehouseInfotId, delete_count) fmt.Println("sql2323234343434343434343434343434343434343343434") if errThree != nil { return errThree } if good_yc.Count == 0 { return nil } else { return errors.New("退库和出库数据不匹配") } }