XT_New/service/warhouse_service.go

package service

import (
	"XT_New/models"
	"XT_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)

			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("c出库数量", advice.PrescribingNumber)
	fmt.Println("单位1", advice.PrescribingNumberUnit)
	fmt.Println("单位2", drup.MaxUnit)
	var drug_price float64
	if advice.PrescribingNumberUnit == drup.MaxUnit {
		deliver_number = count * drup.MinNumber

	} else {
		deliver_number = count

	}

	if advice.PrescribingNumberUnit == drup.MaxUnit {
		drug_price = drup.RetailPrice
	}

	if advice.PrescribingNumberUnit == drup.MinUnit {
		drug_price = drup.MinPrice
	}

	if advice.PrescribingNumberUnit != drup.MaxUnit || advice.PrescribingNumberUnit != drup.MinUnit {
		drug_price = drup.RetailPrice
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)

	if err != nil {

		return err
	}

	// 将该批次的剩余库存数量转换为拆零数量
	fmt.Println("hhh2322333232333232322332323232323232", warehouse.StockMaxNumber, drup.MinNumber, warehouse.StockMinNumber)
	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	fmt.Println("剩余库存🇨🇳2222222222222222222", 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:                   drug_price,
			CountUnit:               drup.MinUnit,
			RetailPrice:             drug_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number, //出最小单位
			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:                   deliver_number, //按最小单位计算,
			Price:                   drug_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		fmt.Println(errOne)
		//查询是否存在数据

		//_, errcodes := GetDrugWarehouseOutInfoIsExit(advice.DrugId, advice.PatientId, advice.RecordDate)
		//if errcodes == gorm.ErrRecordNotFound {
		//	errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		//	if errOne != nil {
		//		return errOne
		//	}
		//} else if errcodes == nil {
		//  //service.GetLastDrugWarehouseOutInfoByPatientId(advice.DrugId, advice.PatientId, advice.RecordDate)
		//	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("2332233232232323232323", advice.PrescribingNumberUnit, drup.MaxUnit)
		//if advice.PrescribingNumberUnit == drup.MaxUnit {
		//	maxNumber = deliver_number / drup.MinNumber
		//	minNumber = deliver_number % drup.MinNumber
		//
		//} else {
		//	minNumber = deliver_number
		//}
		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber
		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}
		fmt.Println("maxNumber0000000000000", maxNumber)
		fmt.Println("minNumber999999999999999", minNumber)
		if warehouse.StockMaxNumber < maxNumber {

			return errors.New("库存数量不足")
		}

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		fmt.Println("扣减库存2322223232332233223232323233233223", warehouse.StockMaxNumber)

		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:                   drug_price,
			CountUnit:               drup.MinUnit,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number,
			WarehouseInfoId:         warehouse.ID,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		fmt.Println("hh23232323232323232233232", warehouse.ID)

		info := models.XtDrugWarehouseInfo{
			ID:                warehouse.ID,
			WarehousingId:     warehouse.WarehousingId,
			DrugId:            warehouse.DrugId,
			Number:            warehouse.Number,
			ProductDate:       warehouse.ProductDate,
			ExpiryDate:        warehouse.ExpiryDate,
			WarehousingCount:  warehouse.WarehousingCount,
			Price:             warehouse.Price,
			TotalPrice:        warehouse.TotalPrice,
			Dealer:            warehouse.Dealer,
			Manufacturer:      warehouse.Manufacturer,
			Remark:            warehouse.Remark,
			Ctime:             warehouse.Ctime,
			Mtime:             warehouse.Mtime,
			Status:            1,
			OrgId:             warehouse.OrgId,
			IsReturn:          warehouse.IsReturn,
			WarehousingOrder:  warehouse.WarehousingOrder,
			Type:              warehouse.Type,
			RetailPrice:       warehouse.RetailPrice,
			RetailTotalPrice:  warehouse.RetailPrice,
			StockMaxNumber:    0,
			StockMinNumber:    0,
			BatchNumber:       warehouse.BatchNumber,
			MaxUnit:           warehouse.MaxUnit,
			WarehousingInfoId: warehouse.WarehousingInfoId,
		}
		//扣减库存
		errThree := UpDateDrugWarehouseInfoByStock(&info)
		//fmt.Println("w我的事件23232332hh23323232233322332323232233232332323232323232",errThree)

		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:                   drug_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		fmt.Println("deliver_number4444444444444", deliver_number)
		fmt.Println("剩余库存hhh2332323232233223232323", stock_number)
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		fmt.Println("下哥批次要出的库存数控数量23333322222222222232323233322332", prescribingNumber_two_temp)
		overPlusNumber := float64(prescribingNumber_two_temp)

		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
		advice.PrescribingNumberUnit = advice.PrescribingNumberUnit

		NewDrugDeliverInfo(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
	}

	var min_price float64

	if advice.PrescribingNumberUnit == drup.MaxUnit {
		min_price = drup.RetailPrice
	}
	if advice.PrescribingNumberUnit == drup.MinUnit {
		min_price = drup.MinPrice
	}

	if advice.PrescribingNumberUnit != drup.MaxUnit && advice.PrescribingNumberUnit != drup.MinUnit {
		min_price = drup.RetailPrice
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)
	fmt.Println("warehouse233223232323", warehouse.ID)
	//查找药品信息
	//baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
	if err != nil {

		return err
	}

	// 将该批次的剩余库存数量转换为拆零数量

	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber

	fmt.Println("剩余库存", stock_number)
	fmt.Println("出库数量233322323", 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:                   min_price,
			CountUnit:               drup.MinUnit,
			RetailPrice:             min_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   deliver_number,
		}

		drugflow := models.DrugFlow{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			Count:                   deliver_number,
			Price:                   min_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		fmt.Println("单位1111111", advice.PrescribingNumberUnit)
		fmt.Println("单位232323233223", drup.MinUnit)
		fmt.Println("出库数量", deliver_number)
		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber
		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}
		fmt.Println("剩余库存233233232323323232")

		if drup.MaxUnit != drup.MinUnit {
			if warehouse.StockMaxNumber < maxNumber {
				return errors.New("库存数量不足")
			}
		}

		fmt.Println("库存数量2332232323", stock_number)
		fmt.Println("c出库数量", maxNumber)
		fmt.Println("c出库数量", minNumber)

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		fmt.Println("剩余库存", warehouse.StockMaxNumber)

		fmt.Println("ha1", warehouse.StockMinNumber)
		fmt.Println("ha2", minNumber)
		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 drup.MaxUnit != drup.MinUnit {
			if warehouse.StockMaxNumber < 0 {
				return errors.New("库存数量不足")
			}
		}

		//扣减库存232332332332
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		fmt.Println("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh")
		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:                   min_price,
			RetailPrice:             min_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   stock_number,
			CountUnit:               drup.MinUnit,
		}

		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:                   min_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据

		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:                   stock_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		info := models.XtDrugWarehouseInfo{
			ID:                warehouse.ID,
			WarehousingId:     warehouse.WarehousingId,
			DrugId:            warehouse.DrugId,
			Number:            warehouse.Number,
			ProductDate:       warehouse.ProductDate,
			ExpiryDate:        warehouse.ExpiryDate,
			WarehousingCount:  warehouse.WarehousingCount,
			Price:             warehouse.Price,
			TotalPrice:        warehouse.TotalPrice,
			Dealer:            warehouse.Dealer,
			Manufacturer:      warehouse.Manufacturer,
			Remark:            warehouse.Remark,
			Ctime:             warehouse.Ctime,
			Mtime:             warehouse.Mtime,
			Status:            1,
			OrgId:             warehouse.OrgId,
			IsReturn:          warehouse.IsReturn,
			WarehousingOrder:  warehouse.WarehousingOrder,
			Type:              warehouse.Type,
			RetailPrice:       warehouse.RetailPrice,
			RetailTotalPrice:  warehouse.RetailPrice,
			StockMaxNumber:    0,
			StockMinNumber:    0,
			BatchNumber:       warehouse.BatchNumber,
			MaxUnit:           warehouse.MaxUnit,
			WarehousingInfoId: warehouse.WarehousingInfoId,
		}
		errThree := UpDateDrugWarehouseInfoByStock(&info)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		fmt.Println("剩余出库数量4444444444444444", prescribingNumber_two_temp)

		overPlusNumber := float64(prescribingNumber_two_temp)

		advice.PrescribingNumber = float64(prescribingNumber_two_temp)

		advice.PrescribingNumberUnit = advice.PrescribingNumberUnit

		NewHisDrugDeliverInfo(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:                  warehouse.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              advice.ExpiryDate,
			ProductDate:             advice.ProductDate,
			Number:                  advice.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   deliver_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   advice.Price,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
		}

		warehouseOutInfo.Count = prescribingNumber
		warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		fmt.Println("hh233223323223232323233223232323233223232323", warehouseout.ID, warehouseout.WarehouseOutOrderNumber)
		//list, _ := GetLastWarehouseOut(drup.OrgId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   deliver_number,
			Price:                   advice.Price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               advice.OrgId,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  advice.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          2,
			IsEdit:                  1,
			Creator:                 0,
			IsSys:                   0,
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		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:                  warehouse.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   deliver_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   advice.Price,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
		}
		warehouseOutInfo.Count = prescribingNumber

		warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//list, _ := GetLastWarehouseOut(drup.OrgId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   deliver_number,
			Price:                   advice.Price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               advice.OrgId,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  advice.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          2,
			IsEdit:                  1,
			Creator:                 0,
			IsSys:                   0,
		}
		CreateDrugFlowOne(drugflow)
		// 出库完成后，要将该批次库存清零
		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) {

	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(warehouse.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 := UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
				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(warehouse.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)
				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
				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)
				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			}

		} 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)
				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			}
		}

		// 出库完成后，要将该批次库存清零
		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 GetWarehouseById(id int64) (models.WarehouseOut, error) {
	out := models.WarehouseOut{}
	err := XTReadDB().Where("id=? and status = 1", id).Find(&out).Error
	return out, 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)

	if err != nil {

		return err
	}

	stock_number = warehouse.StockCount
	fmt.Println("库存数量", stock_number)
	fmt.Println("出库数量", deliver_number)

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {

		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:                  warehouse.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:                  warehouse.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

		fmt.Println("数据1111111111111", warehouse.StockCount)
		fmt.Println("s数据233232323232323232233232", maxNumber)
		if warehouse.StockCount < maxNumber {
			return errors.New("库存数量不足")
		}

		warehouse.StockCount = warehouse.StockCount - maxNumber
		warehouse.Mtime = time.Now().Unix()

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		fmt.Println("几年里2323323232323232323232")
		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:                  warehouse.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:                  warehouse.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

		ConsumablesDeliveryOne(orgID, record_time, goods, warehouseOut, count, creator)

	}
	return nil
}

//退库逻辑
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
	fmt.Println("hh233232232323323232322323233", stock_number, deliver_number)

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	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
		}
		return
	} 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
		}
		fmt.Println("我的时间h232323332323223232323322332322323323223233223232323232332232332232323", errThree)
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		goods.Count = deliver_number - stock_number
		fmt.Println("hh23323232232332232323233232323223223", goods.Count)
		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 NewDrugDeliverInfo(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)

	var drug_price float64

	//按最小单位数据计算
	deliver_number = count

	if advice.PrescribingNumberUnit == drup.MaxUnit {
		drug_price = drup.RetailPrice
	}

	if advice.PrescribingNumberUnit == drup.MinUnit {
		drug_price = drup.MinPrice
	}

	if advice.PrescribingNumberUnit != drup.MaxUnit || advice.PrescribingNumberUnit != drup.MinUnit {
		drug_price = drup.RetailPrice
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)

	if err != nil {

		return err
	}

	// 将该批次的剩余库存数量转换为拆零数量
	fmt.Println("hhh2322333232333232322332323232323232", warehouse.StockMaxNumber, drup.MinNumber, warehouse.StockMinNumber)
	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	fmt.Println("剩余库存🇨🇳2222222222222222222", 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:                  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:                   drug_price,
			CountUnit:               drup.MinUnit,
			RetailPrice:             drug_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number, //出最小单位
			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:                   deliver_number, //按最小单位计算,
			Price:                   drug_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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("2332233232232323232323", advice.PrescribingNumberUnit, drup.MaxUnit)

		//将拆零数量转为 最大包装单位  和 最小单位
		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber
		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}
		fmt.Println("maxNumber0000000000000", maxNumber)
		fmt.Println("minNumber999999999999999", minNumber)
		if warehouse.StockMaxNumber < maxNumber {

			return errors.New("库存数量不足")
		}

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		fmt.Println("扣减库存2322223232332233223232323233233223", warehouse.StockMaxNumber)

		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:                   drug_price,
			CountUnit:               drup.MinUnit,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number,
			WarehouseInfoId:         warehouse.ID,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		// 出库完成后，要将该批次库存清零
		//warehouse.StockMaxNumber = 0
		//warehouse.StockMinNumber = 0
		//warehouse.Mtime = time.Now().Unix()
		fmt.Println("hh23232323232323232233232", warehouse.ID)

		info := models.XtDrugWarehouseInfo{
			ID:                warehouse.ID,
			WarehousingId:     warehouse.WarehousingId,
			DrugId:            warehouse.DrugId,
			Number:            warehouse.Number,
			ProductDate:       warehouse.ProductDate,
			ExpiryDate:        warehouse.ExpiryDate,
			WarehousingCount:  warehouse.WarehousingCount,
			Price:             warehouse.Price,
			TotalPrice:        warehouse.TotalPrice,
			Dealer:            warehouse.Dealer,
			Manufacturer:      warehouse.Manufacturer,
			Remark:            warehouse.Remark,
			Ctime:             warehouse.Ctime,
			Mtime:             warehouse.Mtime,
			Status:            1,
			OrgId:             warehouse.OrgId,
			IsReturn:          warehouse.IsReturn,
			WarehousingOrder:  warehouse.WarehousingOrder,
			Type:              warehouse.Type,
			RetailPrice:       warehouse.RetailPrice,
			RetailTotalPrice:  warehouse.RetailPrice,
			StockMaxNumber:    0,
			StockMinNumber:    0,
			BatchNumber:       warehouse.BatchNumber,
			MaxUnit:           warehouse.MaxUnit,
			WarehousingInfoId: warehouse.WarehousingInfoId,
		}
		//扣减库存
		errThree := UpDateDrugWarehouseInfoByStock(&info)

		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:                   deliver_number,
			Price:                   drug_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		fmt.Println("deliver_number4444444444444", deliver_number)
		fmt.Println("剩余库存hhh2332323232233223232323", stock_number)
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		fmt.Println("下哥批次要出的库存数控数量23333322222222222232323233322332", prescribingNumber_two_temp)
		overPlusNumber := float64(prescribingNumber_two_temp)

		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
		advice.PrescribingNumberUnit = advice.PrescribingNumberUnit

		NewDrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice)
	}

	return
}

// 药品出库 递归方式
func NewHisDrugDeliverInfo(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)

	deliver_number = count

	var min_price float64

	if advice.PrescribingNumberUnit == drup.MaxUnit {
		min_price = drup.RetailPrice
	}
	if advice.PrescribingNumberUnit == drup.MinUnit {
		min_price = drup.MinPrice
	}

	if advice.PrescribingNumberUnit != drup.MaxUnit && advice.PrescribingNumberUnit != drup.MinUnit {
		min_price = drup.RetailPrice
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物

	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:                   min_price,
			CountUnit:               drup.MinUnit,
			RetailPrice:             min_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   deliver_number,
		}

		drugflow := models.DrugFlow{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			Count:                   deliver_number,
			Price:                   min_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量

		var maxNumber int64 = 0
		var minNumber int64 = 0

		//把拆零单位转为最大单位  和 最小单位
		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber
		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}
		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)
		fmt.Println("我你233232323232323332323232232332322323233232232323")
		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:                   min_price,
			RetailPrice:             min_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}

		drugflow := models.DrugFlow{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			Count:                   deliver_number,
			Price:                   min_price,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               orgID,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          3,
			IsEdit:                  1,
			Creator:                 advice.ExecutionStaff,
			IsSys:                   1,
			PatientId:               advice.PatientId,
		}

		CreateDrugFlowOne(drugflow)
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		//查询是否存在数据
		//_, 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:                   deliver_number,
			CountUnit:               drup.MinUnit,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		info := models.XtDrugWarehouseInfo{
			ID:                warehouse.ID,
			WarehousingId:     warehouse.WarehousingId,
			DrugId:            warehouse.DrugId,
			Number:            warehouse.Number,
			ProductDate:       warehouse.ProductDate,
			ExpiryDate:        warehouse.ExpiryDate,
			WarehousingCount:  warehouse.WarehousingCount,
			Price:             warehouse.Price,
			TotalPrice:        warehouse.TotalPrice,
			Dealer:            warehouse.Dealer,
			Manufacturer:      warehouse.Manufacturer,
			Remark:            warehouse.Remark,
			Ctime:             warehouse.Ctime,
			Mtime:             warehouse.Mtime,
			Status:            1,
			OrgId:             warehouse.OrgId,
			IsReturn:          warehouse.IsReturn,
			WarehousingOrder:  warehouse.WarehousingOrder,
			Type:              warehouse.Type,
			RetailPrice:       warehouse.RetailPrice,
			RetailTotalPrice:  warehouse.RetailPrice,
			StockMaxNumber:    0,
			StockMinNumber:    0,
			BatchNumber:       warehouse.BatchNumber,
			MaxUnit:           warehouse.MaxUnit,
			WarehousingInfoId: warehouse.WarehousingInfoId,
		}
		errThree := UpDateDrugWarehouseInfoByStock(&info)
		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

		NewHisDrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice)
	}

	return
}