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)
			storeConfig, _ := GetAllStoreHouseConfig(orgID)
			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,
				StorehouseId:            storeConfig.DrugStorehouseOut,
				IsCheck:                 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)

	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
	}
	fmt.Println(drug_price)

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

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

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber

		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}
	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)

	if err != nil {

		return err
	}

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

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

	//查找药品信息
	//baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)

	// 当库存数量大于或等于出库数量的话，则正常出库该批次

	if stock_number >= deliver_number {

		var maxNumber int64 = 0
		var minNumber int64 = 0
		//var stock_max_number int64 = 0
		//stock_max_number = warehouse.StockMaxNumber

		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber

		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
		} else {
			if minNumber > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			}

			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
				if warehouse.StockMinNumber > 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				}

			}

		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			}

		}

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

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}

		//查询剩余库存
		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
		var sum_count int64
		for _, its := range stockInfo {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			sum_count += its.StockMaxNumber + its.StockMinNumber
		}

		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:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			RetailPrice:             warehouse.RetailPrice,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number, //出最小单位
			WarehouseInfoId:         warehouse.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
			OverCount:               sum_count,
		}

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		fmt.Println(errOne)
		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
		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:                   warehouse.RetailPrice,
			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,
			SystemTime:              advice.AdviceDate,
			WarehousingDetailId:     warehouse.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			LastPrice:               warehouse.Price,
			OverCount:               sum_count,
		}

		CreateDrugFlowOne(drugflow)

		//查询是否存在数据

		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,
			WarehouseInfoId:         warehouse.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

		var out_count int64
		//查询出库数据
		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
		for _, item := range infoCountList {
			out_count += item.Count
		}
		//出库数量相加
		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)

		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:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   stock_number,
			WarehouseInfoId:         warehouse.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
		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:               drup.MinUnit,
			WarehouseInfoId:         warehouse.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		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.RetailPrice,
			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,
			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			StorehouseId:      storeConfig.DrugStorehouseOut,
			IsCheck:           1,
		}
		//扣减库存
		errThree := UpDateDrugWarehouseInfoByStock(&info)

		if errThree != nil {
			return errThree
		}

		//查询剩余库存
		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
		var sum_count int64
		for _, its := range stockInfo {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			sum_count += its.StockMaxNumber + its.StockMinNumber
		}

		var out_count int64

		//查询出库数据
		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
		for _, item := range infoCountList {
			out_count += item.Count
		}

		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:                   warehouse.RetailPrice,
			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,
			WarehousingDetailId:     warehouse.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			LastPrice:               warehouse.Price,
			OverCount:               sum_count,
		}

		CreateDrugFlowOne(drugflow)
		//出库数量相加
		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)

		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		overPlusNumber := float64(prescribingNumber_two_temp)

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

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

	return
}

// 药品出库

func HisDrugsDelivery(orgID int64, 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)
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		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,
				StorehouseId:            houseConfig.DrugStorehouseOut,
				IsCheck:                 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)

			BloodHisDrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice)

			//查询该患者今日总的出库数量
			//advicelist, _ := GetAllSumDrugWarehouseOut(advice.PatientId, advice.UserOrgId, advice.AdviceDate)
			//var total_count int64
			//for _,item :=range advicelist {
			//  if(item.PrescribingNumberUnit == drup.MaxUnit && drup.MaxUnit!=drup.MinUnit){
			//      prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//      count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//      total_count += count * drup.MinNumber
			//  }
			//  if(item.PrescribingNumberUnit == drup.MinUnit && drup.MaxUnit!=drup.MinUnit ){
			//    prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//    count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//    total_count += count
			//  }
			//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)
			//			storeConfig, _ := GetAllStoreHouseConfig(orgID)
			//			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,
			//				StorehouseId:            storeConfig.DrugStorehouseOut,
			//				IsCheck:                 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)
			//
			//	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
			//	}
			//	fmt.Println(drug_price)
			//
			//	if advice.PrescribingNumberUnit == drup.MinUnit {
			//		drug_price = drup.MinPrice
			//	}
			//
			//	if advice.PrescribingNumberUnit != drup.MaxUnit || advice.PrescribingNumberUnit != drup.MinUnit {
			//		drug_price = drup.RetailPrice
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	// 将该批次的剩余库存数量转换为拆零数量
			//
			//	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
			//
			//	//查找药品信息
			//	//baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//
			//	if stock_number >= deliver_number {
			//
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		//var stock_max_number int64 = 0
			//		//stock_max_number = warehouse.StockMaxNumber
			//
			//		maxNumber = deliver_number / drup.MinNumber
			//		minNumber = deliver_number % drup.MinNumber
			//
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//			if minNumber > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
			//				if warehouse.StockMinNumber > 0 {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				}
			//
			//			}
			//
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//查询剩余库存
			//		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
			//		var sum_count int64
			//		for _, its := range stockInfo {
			//			if its.MaxUnit == drup.MaxUnit {
			//				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			//			}
			//			sum_count += its.StockMaxNumber + its.StockMinNumber
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			RetailPrice:             warehouse.RetailPrice,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			Count:                   deliver_number, //出最小单位
			//			WarehouseInfoId:         warehouse.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//			OverCount:               sum_count,
			//		}
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		fmt.Println(errOne)
			//		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			SystemTime:              advice.AdviceDate,
			//			WarehousingDetailId:     warehouse.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			//			LastPrice:               warehouse.Price,
			//			OverCount:               sum_count,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//
			//		//查询是否存在数据
			//
			//		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,
			//			WarehouseInfoId:         warehouse.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			//		if errTwo != nil {
			//			return errTwo
			//		}
			//
			//		var out_count int64
			//		//查询出库数据
			//		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
			//		for _, item := range infoCountList {
			//			out_count += item.Count
			//		}
			//		//出库数量相加
			//		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)
			//
			//		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:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			Count:                   stock_number,
			//			WarehouseInfoId:         warehouse.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
			//		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:               drup.MinUnit,
			//			WarehouseInfoId:         warehouse.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		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.RetailPrice,
			//			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,
			//			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			//			StorehouseId:      storeConfig.DrugStorehouseOut,
			//			IsCheck:           1,
			//		}
			//		//扣减库存
			//		errThree := UpDateDrugWarehouseInfoByStock(&info)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//查询剩余库存
			//		stockInfo, _ := GetDrugAllStockInfo(storeConfig.DrugStorehouseOut, orgID, advice.DrugId)
			//		var sum_count int64
			//		for _, its := range stockInfo {
			//			if its.MaxUnit == drup.MaxUnit {
			//				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			//			}
			//			sum_count += its.StockMaxNumber + its.StockMinNumber
			//		}
			//
			//		var out_count int64
			//
			//		//查询出库数据
			//		infoCountList, _ := FindDrugWarehouseOutInfoCount(advice.DrugId, advice.PatientId, advice.RecordDate, advice.UserOrgId, advice.ID)
			//		for _, item := range infoCountList {
			//			out_count += item.Count
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehousingDetailId:     warehouse.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			//			LastPrice:               warehouse.Price,
			//			OverCount:               sum_count,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		//出库数量相加
			//		AddDrugCount(advice.DrugId, orgID, storeConfig.DrugStorehouseOut, drugflow.Count)
			//
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		prescribingNumber_two_temp := deliver_number - stock_number
			//
			//		overPlusNumber := float64(prescribingNumber_two_temp)
			//
			//		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
			//		advice.PrescribingNumberUnit = drup.MinUnit
			//
			//		DrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice)
			//	}
			//
			//	return
			//}
			//
			//// 药品出库
			//
			//func HisDrugsDelivery(orgID int64, 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)
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		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,
			//				StorehouseId:            houseConfig.DrugStorehouseOut,
			//				IsCheck:                 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)
			//
			//			BloodHisDrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice)
			//
			//			//查询该患者今日总的出库数量
			//			//advicelist, _ := GetAllSumDrugWarehouseOut(advice.PatientId, advice.UserOrgId, advice.AdviceDate)
			//			//var total_count int64
			//			//for _,item :=range advicelist {
			//			//  if(item.PrescribingNumberUnit == drup.MaxUnit && drup.MaxUnit!=drup.MinUnit){
			//			//      prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//			//      count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//			//      total_count += count * drup.MinNumber
			//			//  }
			//			//  if(item.PrescribingNumberUnit == drup.MinUnit && drup.MaxUnit!=drup.MinUnit ){
			//			//    prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//			//    count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//			//    total_count += count
			//			//  }
			//			//
			//			//  if(item.PrescribingNumberUnit == drup.MaxUnit && drup.MaxUnit ==drup.MinUnit ){
			//			//    prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//			//    count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//			//    total_count += count
			//			//  }
			//			//  info := models.DrugWarehouseOutInfo{
			//			//    Count:     total_count,
			//			//    CountUnit: drup.MinUnit,
			//			//  }
			//			//
			//			//  fmt.Println("total_coutn 233232322323232323233222322wo",total_count)
			//			//  //更新出库单数据
			//			//  UpdateDrugWarehouseOutByPatientId(advice.PatientId,advice.AdviceDate,advice.UserOrgId,info)
			//			//}
			//
			//		} 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
			//	}
			//	fmt.Println(min_price)
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//
			//	//查询默认仓库
			//	storeConfig, _ := GetAllStoreHouseConfig(orgID)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//
			//	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:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   1,
			//			SysRecordTime:           advice.RecordDate,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Price:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			RetailPrice:             warehouse.RetailPrice,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			WarehouseInfoId:         warehouse.ID,
			//			Count:                   deliver_number,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//			LastPrice:               warehouse.Price,
			//		}
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			SystemTime:              advice.AdviceDate,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			//			LastPrice:               warehouse.Price,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//
			//		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,
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		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
			//
			//		fmt.Println("maxNumber2323233232323232323232", maxNumber)
			//		fmt.Println("minNumber2323233232323232323232", minNumber)
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//		fmt.Println("warehouse.StockMinNumber", warehouse.StockMinNumber)
			//		fmt.Println("minNumber", minNumber)
			//		fmt.Println("maxNumber", maxNumber)
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			if warehouse.MaxUnit != warehouse.MinUnit {
			//
			//				warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//			}
			//		} else {
			//
			//			if minNumber > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//			}
			//
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//			}
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//		//扣减库存
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//		drugInfoList, _ := FindDrugWarehouseInfoList(advice.DrugId, orgID)
			//		var drug_max_number int64
			//		var drug_min_number int64
			//		for _, item := range drugInfoList {
			//			drug_max_number += item.StockMaxNumber
			//			drug_min_number += item.StockMinNumber
			//		}
			//		drugFlushInfo := models.XtDrugWarehouseFlushInfo{
			//			DrugMaxNumber:           drug_max_number,
			//			UserOrgId:               orgID,
			//			WarehouseOutId:          warehouseout.ID,
			//			Type:                    1,
			//			SystemTime:              advice.RecordDate,
			//			PatientId:               advice.PatientId,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			BatchNumberId:           warehouse.ID,
			//			DrugId:                  advice.DrugId,
			//			Count:                   deliver_number,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			Creater:                 warehouseout.Creater,
			//			DrugMinNumber:           drug_min_number,
			//			Unit:                    drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			Status:                  1,
			//			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			//		}
			//		CreatedDrugFlushInfo(drugFlushInfo)
			//
			//		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:                   warehouse.RetailPrice,
			//			RetailPrice:             warehouse.RetailPrice,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			WarehouseInfoId:         warehouse.ID,
			//			Count:                   stock_number,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//
			//		if errOne != nil {
			//			return errOne
			//		}
			//		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			SystemTime:              advice.AdviceDate,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			//			LastPrice:               warehouse.Price,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//
			//		//查询是否存在数据
			//
			//		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,
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		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,
			//			MinUnit:           warehouse.MinUnit,
			//			WarehousingInfoId: warehouse.WarehousingInfoId,
			//			StorehouseId:      storeConfig.DrugStorehouseOut,
			//			IsCheck:           1,
			//		}
			//		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 = drup.MinUnit
			//
			//		HisDrugDeliverInfo(orgID, overPlusNumber, warehouseout, drup, advice)
			//	}
			//
			//	return
			//}
			//
			//// 药品出库 递归方式
			//func AutoDrugDeliverInfo(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {
			//
			//	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//	} else {
			//		deliver_number = prescribingNumber
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//
			//	storeConfig, _ := GetAllStoreHouseConfig(orgID)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//
			//	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:                  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:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			IsCheck:                 1,
			//		}
			//
			//		warehouseOutInfo.Count = prescribingNumber
			//		warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		if advice.CountUnit == drup.MinUnit {
			//			maxNumber = prescribingNumber / drup.MinNumber
			//			minNumber = prescribingNumber % drup.MinNumber
			//			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//				minNumber = maxNumber
			//			}
			//		} 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 == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			return errors.New("库存数量不足")
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//			}
			//			sum_count += it.StockMaxNumber + it.StockMinNumber
			//			sum_in_count += it.WarehousingCount
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//
			//		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:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           advice.Ctime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			RetailPrice:             advice.RetailPrice,
			//			Price:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = stock_number
			//
			//		//warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          warehouseout.ID,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   stock_number,
			//			Price:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//		}
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要将该批次库存清零
			//		//扣减库存
			//
			//		warehouse.StockMaxNumber = 0
			//		warehouse.StockMinNumber = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//				sum_count += it.StockMaxNumber + it.StockMinNumber
			//				sum_in_count += it.WarehousingCount
			//			}
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//		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
			//
			//					goods[j].Count = temp_count
			//					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
			//
			//					break
			//				}
			//			}
			//		}
			//	}
			//
			//	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
			//	// goods 这个数据就是需要出库的耗材的数据(新增的数据)
			//
			//	if len(goods) > 0 {
			//		out, err := FindStockOutByIsSys(orgID, 1, record_time)
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		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,
			//				StorehouseId:            houseConfig.StorehouseOutInfo,
			//				IsCheck:                 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
			//				}
			//			}
			//
			//			var cha_count int64
			//			var cha_count_two int64
			//			flowGood, _ := GetStockFlowIsBatchNumberTwo(patient_id, record_time, item.GoodId)
			//			var out_count int64
			//			for _, item := range flowGood {
			//				out_count += item.Count
			//			}
			//			cha_count = item.Count - out_count
			//			//fmt.Println("item.Count", item.Count)
			//			//fmt.Println("item.Count", out_count)
			//			//fmt.Println("cha_count2323223232323223", cha_count)
			//			cha_count_two = out_count - item.Count
			//
			//			prepare := models.DialysisBeforePrepare{
			//				GoodTypeId:   item.GoodTypeId,
			//				GoodId:       item.GoodId,
			//				Count:        cha_count,
			//				ProjectId:    item.ProjectId,
			//				StorehouseId: houseConfig.StorehouseOutInfo,
			//			}
			//
			//			ConsumablesGoodDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
			//			//数量增加
			//			if cha_count > 0 {
			//				//出库数量累加
			//				ModifyGoodSumCount(houseConfig.StorehouseOutInfo, cha_count, orgID, item.GoodId)
			//			}
			//			//数量减少
			//			if cha_count_two > 0 {
			//				ModifyAddGoodSumCount(houseConfig.StorehouseOutInfo, cha_count_two, orgID, item.GoodId)
			//				//退库数量增加
			//				UpdateSumAddCancelCount(orgID, item.GoodId, houseConfig.StorehouseOutInfo, cha_count_two)
			//
			//			}
			//			//更新剩余库存
			//			goodListSix, _ := GetSumGoodList(orgID, houseConfig.StorehouseOutInfo, item.GoodId)
			//			var flush_count int64
			//			for _, it := range goodListSix {
			//				flush_count += it.StockCount
			//			}
			//			UpdateSumGood(orgID, houseConfig.StorehouseOutInfo, item.GoodId, flush_count)
			//
			//		}
			//
			//	}
			//	fmt.Println("goods_yc2323323223323223232323232332wode", goods_yc)
			//	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, goods.StorehouseId)
			//	if err != nil {
			//		return errors.New("库存数量不足")
			//	}
			//
			//	stock_number = warehouse.StockCount
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		maxNumber = goods.Count
			//		//出库
			//		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
			//		}
			//		//查询剩余库存
			//		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
			//		var sum_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//		}
			//
			//		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:                   warehouse.PackingPrice,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			ProjectId:               goods.ProjectId,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = count
			//
			//		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
			//		if errcodes == gorm.ErrRecordNotFound {
			//			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
			//			if errOne != nil {
			//				return errOne
			//			}
			//		} else if errcodes == nil {
			//			UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
			//		}
			//
			//		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,
			//			ProjectId:               goods.ProjectId,
			//			StorehouseId:            goods.StorehouseId,
			//		}
			//		//查询当天耗材是否已经存在数据
			//		_, 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:                   warehouse.PackingPrice,
			//				Status:                  1,
			//				Ctime:                   time.Now().Unix(),
			//				UserOrgId:               orgID,
			//				Manufacturer:            warehouse.Manufacturer,
			//				Dealer:                  warehouse.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,
			//				ProjectId:               goods.ProjectId,
			//				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//				StorehouseId:            goods.StorehouseId,
			//				OverCount:               sum_count,
			//			}
			//
			//			//查询流水是否存在
			//			exsit, errflow := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)
			//
			//			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:                   warehouse.PackingPrice,
			//					Status:                  1,
			//					Ctime:                   time.Now().Unix(),
			//					UserOrgId:               orgID,
			//					Manufacturer:            warehouse.Manufacturer,
			//					Dealer:                  warehouse.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),
			//					ProjectId:               goods.ProjectId,
			//					StorehouseId:            goods.StorehouseId,
			//					OverCount:               sum_count,
			//				}
			//
			//				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:                   warehouse.PackingPrice,
			//				Status:                  1,
			//				Ctime:                   time.Now().Unix(),
			//				UserOrgId:               orgID,
			//				Manufacturer:            warehouse.Manufacturer,
			//				Dealer:                  warehouse.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,
			//				ProjectId:               goods.ProjectId,
			//				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//				StorehouseId:            goods.StorehouseId,
			//				OverCount:               sum_count,
			//			}
			//			//查询流水是否存在
			//			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:                   warehouse.PackingPrice,
			//					Status:                  1,
			//					Ctime:                   time.Now().Unix(),
			//					UserOrgId:               orgID,
			//					Manufacturer:            warehouse.Manufacturer,
			//					Dealer:                  warehouse.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),
			//					ProjectId:               goods.ProjectId,
			//					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//					StorehouseId:            goods.StorehouseId,
			//					OverCount:               sum_count,
			//				}
			//				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			//				DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
			//				CreateAutoReduceRecord(&details)
			//			}
			//
			//		}
			//
			//		return nil
			//	} else {
			//
			//		// 当刚批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
			//		warehouse.StockCount = 0
			//		warehouse.Mtime = time.Now().Unix()
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			return errThree
			//		}
			//		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
			//		var sum_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//		}
			//		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:                   warehouse.PackingPrice,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			ProjectId:               goods.ProjectId,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = stock_number
			//
			//		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, goods.PatientId, record_time, goods.ProjectId)
			//
			//		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:                   warehouse.PackingPrice,
			//				Status:                  1,
			//				Ctime:                   time.Now().Unix(),
			//				UserOrgId:               orgID,
			//				Manufacturer:            warehouse.Manufacturer,
			//				Dealer:                  warehouse.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,
			//				ProjectId:               goods.ProjectId,
			//				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//				StorehouseId:            goods.StorehouseId,
			//				OverCount:               sum_count,
			//			}
			//			//查询流水是否存在
			//			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:                   warehouse.PackingPrice,
			//					Status:                  1,
			//					Ctime:                   time.Now().Unix(),
			//					UserOrgId:               orgID,
			//					Manufacturer:            warehouse.Manufacturer,
			//					Dealer:                  warehouse.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),
			//					ProjectId:               goods.ProjectId,
			//					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//					StorehouseId:            goods.StorehouseId,
			//					OverCount:               sum_count,
			//				}
			//				errOne := UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			//				if errOne == nil {
			//
			//				}
			//			}
			//
			//		} else if errcodes == nil {
			//
			//			goods.Count = deliver_number - stock_number
			//			//更新数量为  该批次剩余数量  + 还有未出的数量
			//			warehouseOutInfo.Count = stock_number
			//			UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, goods.PatientId, record_time, goods.ProjectId)
			//			//插入库存流水表
			//			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:                   warehouse.PackingPrice,
			//				Status:                  1,
			//				Ctime:                   time.Now().Unix(),
			//				UserOrgId:               orgID,
			//				Manufacturer:            warehouse.Manufacturer,
			//				Dealer:                  warehouse.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,
			//				ProjectId:               goods.ProjectId,
			//				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//				StorehouseId:            goods.StorehouseId,
			//				OverCount:               sum_count,
			//			}
			//			//查询流水是否存在
			//			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:                   warehouse.PackingPrice,
			//					Status:                  1,
			//					Ctime:                   time.Now().Unix(),
			//					UserOrgId:               orgID,
			//					Manufacturer:            warehouse.Manufacturer,
			//					Dealer:                  warehouse.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,
			//					ProjectId:               goods.ProjectId,
			//					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//					StorehouseId:            goods.StorehouseId,
			//					OverCount:               sum_count,
			//				}
			//				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			//			}
			//		}
			//
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		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 {
			//		// 删除出库完成后，要增加对应批次的库存数量
			//		errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count, patient_id, record_time, good_yc.GoodId)
			//		if errThree != nil {
			//			return errThree
			//		}
			//		//查询剩余库存
			//		goodList, _ := GetAllGoodSumCount(good_yc.GoodId, orgID)
			//		var sum_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//		}
			//		// 判断当前出库的数据和删除出库数量
			//		if good_yc.Count <= ware.Count {
			//			delete_count = good_yc.Count
			//		} else {
			//			delete_count = ware.Count
			//		}
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		// 在出库记录表里记录退库详情
			//		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,
			//			StorehouseId:  houseConfig.StorehouseOutInfo,
			//			OverCount:     sum_count,
			//		}
			//		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,
			//				StorehouseId:            houseConfig.StorehouseOutInfo,
			//			}
			//			//查询是否当天已经存在数据
			//			_, 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)
			//			}
			//		}
			//
			//		//扣减数量相加
			//		ModifyAddGoodSumCount(houseConfig.StorehouseOutInfo, delete_count, good_yc.UserOrgId, good_yc.GoodId)
			//
			//		//退库数量相加
			//		UpdateSumAddCancelCount(good_yc.UserOrgId, good_yc.GoodId, houseConfig.StorehouseOutInfo, delete_count)
			//
			//		// 增加了对应的库存后，看看还有多少需要退库的
			//		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) {
			//
			//	////开事务
			//	//tx := XTWriteDB().Begin()
			//
			//	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, goods.StorehouseId)
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	stock_number = warehouse.StockCount
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			//			WarehouseOutId:          warehouseOut.ID,
			//			WarehouseInfotId:        warehouse.ID,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  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,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price,
			//			StockCount:              goods.StockCount,
			//		}
			//		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:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price,
			//			StockCount:              goods.StockCount,
			//		}
			//
			//		//创建出库流水
			//		CreateStockFlowOne(stockFlow)
			//
			//		maxNumber = goods.Count
			//
			//		if warehouse.StockCount < maxNumber {
			//			return errors.New("库存数量不足")
			//		}
			//
			//		warehouse.StockCount = warehouse.StockCount - maxNumber
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		//扣减库存
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		fmt.Println(errThree)
			//		//if errThree != nil {
			//		//	utils.ErrorLog("事务失败,原因为: %v", errThree.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//
			//		//查询该机构默认仓库
			//		storeConfig, _ := GetAllStoreHouseConfig(goods.OrgId)
			//		//查询剩余库存
			//		goodList, _ := GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, goods.GoodId, goods.OrgId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//			sum_in_count += item.WarehousingCount
			//		}
			//		UpdateGoodByGoodId(goods.GoodId, sum_count, sum_in_count, goods.OrgId)
			//		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:                   warehouse.PackingPrice,
			//			LicenseNumber:           goods.LicenseNumber,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price,
			//			StockCount:              goods.StockCount,
			//			IsCheck:                 1,
			//		}
			//		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:                   stock_number,
			//			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:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price,
			//			StockCount:              goods.StockCount,
			//		}
			//
			//		//创建出库明细
			//		CreateStockFlowOne(stockFlow)
			//		//查询该机构默认仓库
			//		storeConfig, _ := GetAllStoreHouseConfig(goods.OrgId)
			//		//查询剩余库存
			//		goodList, _ := GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, goods.GoodId, goods.OrgId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//			sum_in_count += item.WarehousingCount
			//		}
			//		UpdateGoodByGoodId(goods.GoodId, sum_count, sum_in_count, goods.OrgId)
			//		// 出库完成后，要将该批次库存清零
			//		warehouse.StockCount = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		fmt.Println(errThree)
			//		//if errThree != nil {
			//		//	utils.ErrorLog("事务失败,原因为: %v", errThree.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		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) {
			//
			//	////开事务
			//	//tx := XTWriteDB().Begin()
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//	var maxNumber int64 = 0
			//
			//	deliver_number = goods.Count
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	warehouse, err := FindFirstWarehousingInfoByGoodId(goods.GoodId, goods.ID, goods.StorehouseId)
			//
			//	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:                   warehouse.PackingPrice,
			//			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)
			//		fmt.Println(errThree)
			//		//if errThree != nil {
			//		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//
			//		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:                   warehouse.PackingPrice,
			//			LicenseNumber:           goods.LicenseNumber,
			//			ConsumableType:          2,
			//			IsCheck:                 1,
			//			StorehouseId:            goods.StorehouseId,
			//		}
			//		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 {
			//		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//
			//		fmt.Println(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 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
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//查询默认仓库
			//	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//
			//	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:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   1,
			//			SysRecordTime:           advice.RecordDate,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Price:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			RetailPrice:             drug_price,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			Count:                   deliver_number, //出最小单位
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//
			//		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:                   deliver_number,
			//			CountUnit:               drup.MinUnit,
			//			WarehouseInfoId:         warehouse.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			//		if errTwo != nil {
			//			return errTwo
			//		}
			//
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		//var stock_max_number int64 = 0
			//		//stock_max_number = warehouse.StockMaxNumber
			//
			//		maxNumber = deliver_number / drup.MinNumber
			//		minNumber = deliver_number % drup.MinNumber
			//
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//
			//			if minNumber > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 {
			//				if warehouse.StockMinNumber > 0 {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				}
			//
			//			}
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//
			//				//if warehouse.StockMinNumber == 0 {
			//				//  warehouse.StockMaxNumber = stock_max_number
			//				//}
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			Count:                   deliver_number,
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//
			//		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,
			//			WarehouseInfoId:         warehouse.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			//		if errTwo != nil {
			//			return errTwo
			//		}
			//
			//		// 出库完成后，要将该批次库存清零
			//		warehouse.StockMaxNumber = 0
			//		warehouse.StockMinNumber = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		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,
			//			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			//			StorehouseId:      storeConfig.DrugStorehouseOut,
			//			IsCheck:           1,
			//		}
			//		//扣减库存
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		prescribingNumber_two_temp := deliver_number - stock_number
			//
			//		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
			//	}
			//
			//	fmt.Println(min_price)
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	//查找药品信息
			//
			//	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:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   1,
			//			SysRecordTime:           advice.RecordDate,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Price:                   warehouse.RetailPrice,
			//			CountUnit:               drup.MinUnit,
			//			RetailPrice:             warehouse.RetailPrice,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			WarehouseInfoId:         warehouse.ID,
			//			Count:                   deliver_number,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			SystemTime:              advice.RecordDate,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//
			//		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:                   deliver_number,
			//			CountUnit:               drup.MinUnit,
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			//		if errTwo != nil {
			//			return errTwo
			//		}
			//
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		//var stock_max_number int64 = 0
			//		//stock_max_number = warehouse.StockMaxNumber
			//
			//		maxNumber = deliver_number / drup.MinNumber
			//		minNumber = deliver_number % drup.MinNumber
			//
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//
			//			if minNumber > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 {
			//				if warehouse.StockMinNumber > 0 {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				}
			//
			//			}
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//
			//				//if warehouse.StockMinNumber == 0 {
			//				//  warehouse.StockMaxNumber = stock_max_number
			//				//}
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			RetailPrice:             warehouse.RetailPrice,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			PatientId:               advice.PatientId,
			//			WarehouseInfoId:         warehouse.ID,
			//			Count:                   stock_number,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//			IsCheck:                 1,
			//		}
			//
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			SystemTime:              advice.RecordDate,
			//			WarehousingDetailId:     warehouse.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//
			//		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,
			//			WarehouseInfoId:         warehouse.ID,
			//			AdviceId:                advice.ID,
			//			StorehouseId:            storeConfig.DrugStorehouseOut,
			//		}
			//		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.RetailPrice,
			//			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,
			//			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			//			StorehouseId:      storeConfig.DrugStorehouseOut,
			//			IsCheck:           1,
			//		}
			//		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
			//}
			//
			//// 药品出库 递归方式
			//func HisAuToReduce(orgID int64, prescribingNumber float64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.HisDoctorAdviceInfo) (err error) {
			//
			//	//查询最后一次出库数据
			//	drugInfo, _ := GetDrugWarehouseOutInfoIsExit(advice.DrugId, advice.PatientId, advice.RecordDate)
			//
			//	prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64)
			//	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//	var count_number int64
			//	var device_number int64
			//	if advice.PrescribingNumberUnit == drup.MaxUnit {
			//		device_number = count * drup.MinNumber
			//	}
			//	if advice.PrescribingNumberUnit == drup.MinUnit {
			//		device_number = count
			//	}
			//
			//	if drugInfo.CountUnit == drup.MaxUnit {
			//		count_number = drugInfo.Count * drup.MinNumber
			//	}
			//	if drugInfo.CountUnit == drup.MinUnit {
			//		count_number = drugInfo.Count
			//	}
			//
			//	//  比较数据大小
			//	//如果当期医嘱数量小于最后一次出库则退库
			//	if device_number < count_number {
			//		var cha_number int64
			//		var maxNumber int64
			//		var minNumber int64
			//		cha_number = count_number - device_number
			//		maxNumber = cha_number / drup.MinNumber
			//		minNumber = cha_number % drup.MinNumber
			//		//更改库存
			//		ModifyDrugWarehouse(drugInfo.WarehouseInfoId, maxNumber, minNumber)
			//
			//		//修改出库表
			//		info := models.DrugWarehouseOutInfo{
			//			Count:     device_number,
			//			CountUnit: advice.PrescribingNumberUnit,
			//		}
			//
			//		ModifyDrugWarehouseOutInfo(info, advice.DrugId, advice.PatientId, advice.RecordDate)
			//
			//		//修改自动出库表
			//		detail := models.DrugAutomaticReduceDetail{
			//			Count:     device_number,
			//			CountUnit: advice.PrescribingNumberUnit,
			//		}
			//		ModifyAutoMaticReduce(detail, advice.PatientId, advice.RecordDate, advice.DrugId)
			//		//修改流水
			//		flow := models.DrugFlow{
			//			Count:   device_number,
			//			MaxUnit: drup.MinUnit,
			//		}
			//		ModifyDrugFlow(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId)
			//
			//	}
			//
			//	//如果当期医嘱数量大于最后一次出库则需要出库
			//	if device_number > count_number {
			//		var cha_number int64
			//		cha_number = device_number - count_number
			//
			//		// 根据先进先出原则，查询最先入库的批次，进行出库
			//
			//		storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
			//		lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//		if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//			var stockMax int64
			//			var stockMin int64
			//			stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//			stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//			ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//			UpdateMinNumber(lastWarehouse.ID, stockMin)
			//		}
			//		warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//		//查找药品信息
			//		//baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
			//		if err != nil {
			//			return err
			//		}
			//
			//		// 将该批次的剩余库存数量转换为拆零数量
			//		var stock_number int64
			//		var maxNumber int64
			//		var minNumber int64
			//		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
			//
			//		//如果库存数量大于出库数据,正常出库
			//		if stock_number >= cha_number {
			//			//扣减库存
			//			maxNumber = cha_number / drup.MinNumber
			//			minNumber = cha_number % drup.MinNumber
			//
			//			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//				minNumber = maxNumber
			//			}
			//
			//			if drup.MaxUnit != drup.MinUnit {
			//				if warehouse.StockMaxNumber < maxNumber {
			//					return errors.New("库存数量不足")
			//				}
			//			}
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//			if warehouse.StockMaxNumber < 0 {
			//				warehouse.StockMaxNumber = 0
			//			}
			//
			//			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)
			//
			//			if errThree != nil {
			//				return errThree
			//			}
			//
			//			//修改出库表
			//			info := models.DrugWarehouseOutInfo{
			//				Count:     device_number,
			//				CountUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyDrugWarehouseOutInfoOne(info, advice.DrugId, advice.PatientId, advice.RecordDate, warehouse.ID)
			//			//修改自动出库表
			//			detail := models.DrugAutomaticReduceDetail{
			//				Count:     device_number,
			//				CountUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyAutoMaticReduceOne(detail, advice.PatientId, advice.RecordDate, advice.DrugId, warehouse.ID)
			//			//修改流水
			//			flow := models.DrugFlow{
			//				Count:   device_number,
			//				MaxUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyDrugFlowOne(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId, warehouse.ID)
			//		}
			//		//如果库存数量小于出库数据,则需要出库到下一个批次
			//		if stock_number < cha_number {
			//
			//			//修改出库表
			//			info := models.DrugWarehouseOutInfo{
			//				Count:     cha_number,
			//				CountUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyDrugWarehouseOutInfoOne(info, advice.DrugId, advice.PatientId, advice.RecordDate, warehouse.ID)
			//			//修改自动出库表
			//			detail := models.DrugAutomaticReduceDetail{
			//				Count:     cha_number,
			//				CountUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyAutoMaticReduceOne(detail, advice.PatientId, advice.RecordDate, advice.DrugId, warehouse.ID)
			//			//修改流水
			//			flow := models.DrugFlow{
			//				Count:   cha_number,
			//				MaxUnit: advice.PrescribingNumberUnit,
			//			}
			//			ModifyDrugFlowOne(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId, warehouse.ID)
			//
			//			druginfo := &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,
			//				StorehouseId:      storeConfig.DrugStorehouseOut,
			//				IsCheck:           1,
			//			}
			//			errThree := UpDateDrugWarehouseInfoByStock(druginfo)
			//			if errThree != nil {
			//				return errThree
			//			}
			//
			//			// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//			prescribingNumber_two_temp := cha_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
			//}
			//
			////采购管理耗材出库逻辑
			//func ConsumablesDeliveryNight(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64, creator int64, warehouse_out_id int64, cancel_out_id int64) (err error) {
			//
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//	var maxNumber int64 = 0
			//
			//	deliver_number = goods.Count
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//	// 如果没有对应的库存，则报错
			//	warehouse, err := FindFirstWarehousingInfoByStockNight(goods.GoodId, goods.GoodTypeId, warehouse_out_id, goods.IsSource, houseConfig.StorehouseOutInfo)
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	stock_number = warehouse.StockCount
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			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,
			//			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//		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:          goods.WarehouseOutId,
			//			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:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseOut.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//		}
			//
			//		//创建出库流水
			//		CreateStockFlowOne(stockFlow)
			//
			//		maxNumber = goods.Count
			//
			//		if warehouse.StockCount < maxNumber {
			//			return errors.New("库存数量不足")
			//		}
			//
			//		warehouse.StockCount = warehouse.StockCount - maxNumber
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		//扣减库存
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		//出库数量增加
			//		AddGoodSumOutCount(houseConfig.StorehouseOutInfo, warehouse.GoodId, warehouse.OrgId, goods.Count)
			//		ModifyGoodReduceInformationSix(warehouse.GoodId, maxNumber, warehouse.OrgId, warehouse.PackingPrice)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//	} else {
			//
			//		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			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:                   warehouse.PackingPrice,
			//			LicenseNumber:           goods.LicenseNumber,
			//			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//		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:                   stock_number,
			//			UserOrgId:               goods.OrgId,
			//			PatientId:               0,
			//			SystemTime:              record_time,
			//			ConsumableType:          2,
			//			IsSys:                   0,
			//			WarehousingOrder:        "",
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			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:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseOut.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//		}
			//
			//		//创建出库明细
			//		CreateStockFlowOne(stockFlow)
			//		// 出库完成后，要将该批次库存清零
			//		ModifyGoodReduceInformationSix(warehouse.GoodId, warehouse.StockCount, warehouse.OrgId, warehouse.PackingPrice)
			//		warehouse.StockCount = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//		//出库数量增加
			//		AddGoodSumOutCount(houseConfig.StorehouseOutInfo, warehouse.GoodId, warehouse.OrgId, warehouse.StockCount)
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		goods.Count = deliver_number - stock_number
			//
			//		ConsumablesDeliveryNight(orgID, record_time, goods, warehouseOut, count, creator, warehouse_out_id, cancel_out_id)
			//
			//	}
			//	return nil
			//}
			//
			//func FindFirstWarehousingInfoByStockNight(good_id int64, good_type_id int64, warehouse_out_id int64, is_source int64, storehouse_id int64) (info models.WarehousingInfo, err error) {
			//
			//	if is_source == 1 {
			//		err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND good_type_id = ? AND status = 1 and stock_count > 0 and supply_warehouse_id = ? and storehouse_id = ?", good_id, good_type_id, warehouse_out_id, storehouse_id).Order("ctime").First(&info).Error
			//
			//	}
			//	if is_source == 2 || is_source == 0 {
			//		err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND good_type_id = ? AND status = 1 and stock_count > 0 and storehouse_id = ?", good_id, good_type_id, storehouse_id).Order("ctime").First(&info).Error
			//	}
			//	return info, err
			//}
			//
			//// 药品出库 递归方式
			//func AutoDrugDeliverInfoNight(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo, warehouse_out_id int64, cancel_out_id int64) (err error) {
			//
			//	houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//	var retail_price float64
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//		formatInt := strconv.FormatInt(prescribingNumber, 10)
			//		floatcount, _ := strconv.ParseFloat(formatInt, 64)
			//		retail_price = floatcount * advice.Price
			//	} else {
			//		deliver_number = prescribingNumber
			//		formatInt := strconv.FormatInt(prescribingNumber, 10)
			//		floatcount, _ := strconv.ParseFloat(formatInt, 64)
			//		retail_price = floatcount * advice.Price
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, houseConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByIDSix(advice.DrugId, warehouse_out_id, advice.IsSource, houseConfig.DrugStorehouseOut)
			//
			//	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:          advice.WarehouseOutId,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  advice.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            advice.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           advice.SysRecordTime,
			//			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,
			//			AdviceId:                advice.ID,
			//			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//
			//		warehouseOutInfo.Count = prescribingNumber
			//		warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   deliver_number,
			//			Price:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			//			SystemTime:              advice.SysRecordTime,
			//			StorehouseId:            warehouse.StorehouseId,
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehousingId:           warehouse.ID,
			//			RetailPrice:             retail_price,
			//			LastPrice:               warehouse.Price,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		if advice.CountUnit == drup.MinUnit {
			//			maxNumber = prescribingNumber / drup.MinNumber
			//			minNumber = prescribingNumber % drup.MinNumber
			//			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//				minNumber = maxNumber
			//			}
			//		} else {
			//			maxNumber = prescribingNumber
			//		}
			//
			//		if warehouse.StockMaxNumber < maxNumber {
			//
			//			return errors.New("库存数量不足")
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//
			//		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("库存数量不足")
			//		}
			//		if warehouse.StockMaxNumber == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		if warehouse.StockMaxNumber > 0 {
			//			var sum_count int64
			//			sum_count = maxNumber * drup.MinNumber
			//			ModifyDrugReduceInformationSix(warehouse.DrugId, sum_count, warehouse.OrgId, warehouse.RetailPrice)
			//			//出库数量增加
			//			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, sum_count, warehouse.OrgId, warehouse.DrugId)
			//		}
			//
			//		if warehouse.StockMinNumber > 0 {
			//			ModifyDrugReduceInformationSix(warehouse.DrugId, minNumber, warehouse.OrgId, warehouse.RetailPrice)
			//			//出库数量增加
			//			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, minNumber, warehouse.OrgId, warehouse.DrugId)
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		return nil
			//	} else {
			//		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
			//		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  advice.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            advice.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           advice.SysRecordTime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			RetailPrice:             advice.RetailPrice,
			//			Price:                   advice.Price,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = stock_number
			//
			//		//warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   stock_number,
			//			Price:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			//			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			//			SystemTime:              advice.SysRecordTime,
			//			StorehouseId:            warehouse.StorehouseId,
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehousingId:           warehouse.ID,
			//			RetailPrice:             retail_price,
			//			LastPrice:               warehouse.Price,
			//		}
			//		CreateDrugFlowOne(drugflow)
			//		if warehouse.StockMaxNumber > 0 {
			//			var sum_count int64
			//			sum_count = warehouse.StockMaxNumber * drup.MinNumber
			//			ModifyDrugReduceInformationSix(warehouse.DrugId, sum_count, warehouse.OrgId, warehouse.RetailPrice)
			//			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, sum_count, warehouse.OrgId, warehouse.DrugId)
			//		}
			//
			//		if warehouse.StockMinNumber > 0 {
			//			ModifyDrugReduceInformationSix(warehouse.DrugId, warehouse.StockMinNumber, warehouse.OrgId, warehouse.RetailPrice)
			//			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, warehouse.StockMinNumber, warehouse.OrgId, warehouse.DrugId)
			//		}
			//
			//		// 出库完成后，要将该批次库存清零
			//		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
			//
			//		AutoDrugDeliverInfoNight(orgID, prescribingNumber_two_temp, warehouseout, drup, advice, warehouse_out_id, cancel_out_id)
			//	}
			//
			//	return
			//}
			//
			////调拨出库逻辑
			//func ConsumablesDeliveryTwelve(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64, creator int64, warehouseInfo *models.WarehousingInfo) (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, goods.StorehouseId)
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	stock_number = warehouse.StockCount
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			WarehouseInfotId:        warehouse.ID,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  goods.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           record_time,
			//			GoodTypeId:              warehouse.GoodTypeId,
			//			GoodId:                  warehouse.GoodId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			Price:                   warehouse.PackingPrice,
			//			LicenseNumber:           warehouse.LicenseNumber,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			//			IsCheck:                 1,
			//		}
			//
			//		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:          12,
			//			IsSys:                   goods.IsSys,
			//			WarehousingOrder:        "",
			//			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			IsEdit:                  1,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 creator,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			//		}
			//
			//		//创建出库流水
			//		CreateStockFlowOne(stockFlow)
			//
			//		maxNumber = goods.Count
			//
			//		if warehouse.StockCount < maxNumber {
			//			return errors.New("库存数量不足")
			//		}
			//
			//		warehouse.StockCount = warehouse.StockCount - maxNumber
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		//扣减库存
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//
			//		//入库
			//		warehouseInfo := &models.WarehousingInfo{
			//			WarehousingOrder:      warehouseInfo.WarehousingOrder,
			//			WarehousingId:         warehouseInfo.WarehousingId,
			//			GoodId:                warehouse.GoodId,
			//			Number:                warehouse.Number,
			//			GoodTypeId:            warehouse.GoodTypeId,
			//			ProductDate:           warehouse.ProductDate,
			//			ExpiryDate:            warehouse.ExpiryDate,
			//			WarehousingCount:      goods.Count,
			//			Price:                 warehouse.Price,
			//			TotalPrice:            0,
			//			Status:                1,
			//			Ctime:                 warehouse.Ctime,
			//			Remark:                goods.Remark,
			//			OrgId:                 warehouse.OrgId,
			//			Type:                  1,
			//			Manufacturer:          warehouse.Manufacturer,
			//			StockCount:            goods.Count,
			//			Dealer:                warehouse.Dealer,
			//			LicenseNumber:         "",
			//			PackingPrice:          warehouse.PackingPrice,
			//			StorehouseId:          warehouseInfo.StorehouseId,
			//			SecondWarehouseInfoId: warehouseInfo.SecondWarehouseInfoId,
			//			IsCheck:               1,
			//		}
			//
			//		AddWarehosingInfo(warehouseInfo)
			//
			//		stockInfoFlow := models.VmStockFlow{
			//			WarehousingId:           warehouseInfo.WarehousingId,
			//			GoodId:                  goods.GoodId,
			//			Number:                  warehouse.Number,
			//			LicenseNumber:           goods.LicenseNumber,
			//			Count:                   goods.Count,
			//			UserOrgId:               goods.OrgId,
			//			PatientId:               goods.PatientId,
			//			SystemTime:              record_time,
			//			ConsumableType:          13,
			//			IsSys:                   goods.IsSys,
			//			WarehousingOrder:        warehouseInfo.WarehousingOrder,
			//			WarehouseOutId:          0,
			//			WarehouseOutOrderNumber: "",
			//			IsEdit:                  1,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 creator,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.Price,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouseInfo.StorehouseId,
			//			SecondWarehouseInfoId:   warehouseInfo.SecondWarehouseInfoId,
			//		}
			//
			//		//创建入库流水
			//		CreateStockFlowOne(stockInfoFlow)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//	} else {
			//
			//		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			WarehouseInfotId:        warehouse.ID,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  goods.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           record_time,
			//			GoodTypeId:              warehouse.GoodTypeId,
			//			GoodId:                  warehouse.GoodId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			Price:                   warehouse.PackingPrice,
			//			LicenseNumber:           warehouse.LicenseNumber,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = warehouse.StockCount
			//
			//		//查询是否已经生成出库单
			//		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:                   warehouse.StockCount,
			//			UserOrgId:               goods.OrgId,
			//			PatientId:               0,
			//			SystemTime:              record_time,
			//			ConsumableType:          12,
			//			IsSys:                   0,
			//			WarehousingOrder:        "",
			//			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			//			WarehouseOutId:          goods.WarehouseOutId,
			//			IsEdit:                  1,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 creator,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.PackingPrice,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            goods.StorehouseId,
			//			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			//		}
			//
			//		//创建出库明细
			//		CreateStockFlowOne(stockFlow)
			//
			//		//入库
			//		warehouseInfo := &models.WarehousingInfo{
			//			WarehousingOrder:      warehouseInfo.WarehousingOrder,
			//			WarehousingId:         warehouseInfo.WarehousingId,
			//			GoodId:                warehouse.GoodId,
			//			Number:                warehouse.Number,
			//			GoodTypeId:            warehouse.GoodTypeId,
			//			ProductDate:           warehouse.ProductDate,
			//			ExpiryDate:            warehouse.ExpiryDate,
			//			WarehousingCount:      warehouse.StockCount,
			//			Price:                 warehouse.Price,
			//			TotalPrice:            0,
			//			Status:                1,
			//			Ctime:                 warehouse.Ctime,
			//			Remark:                goods.Remark,
			//			OrgId:                 warehouse.OrgId,
			//			Type:                  1,
			//			Manufacturer:          warehouse.Manufacturer,
			//			StockCount:            warehouse.StockCount,
			//			Dealer:                warehouse.Dealer,
			//			LicenseNumber:         "",
			//			PackingPrice:          warehouse.PackingPrice,
			//			StorehouseId:          warehouseInfo.StorehouseId,
			//			SecondWarehouseInfoId: warehouseInfo.SecondWarehouseInfoId,
			//			IsCheck:               1,
			//		}
			//
			//		AddWarehosingInfo(warehouseInfo)
			//
			//		stockInfoFlow := models.VmStockFlow{
			//			WarehousingId:           warehouseInfo.WarehousingId,
			//			GoodId:                  goods.GoodId,
			//			Number:                  warehouse.Number,
			//			LicenseNumber:           goods.LicenseNumber,
			//			Count:                   warehouse.StockCount,
			//			UserOrgId:               goods.OrgId,
			//			PatientId:               goods.PatientId,
			//			SystemTime:              record_time,
			//			ConsumableType:          13,
			//			IsSys:                   goods.IsSys,
			//			WarehousingOrder:        warehouseInfo.WarehousingOrder,
			//			WarehouseOutId:          warehouseOut.ID,
			//			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			//			IsEdit:                  1,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 creator,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.Price,
			//			WarehousingDetailId:     0,
			//			WarehouseOutDetailId:    warehouseOutInfo.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouseInfo.StorehouseId,
			//			SecondWarehouseInfoId:   warehouseInfo.SecondWarehouseInfoId,
			//		}
			//
			//		//创建出库流水
			//		CreateStockFlowOne(stockInfoFlow)
			//		// 出库完成后，要将该批次库存清零
			//		warehouse.StockCount = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		goods.Count = deliver_number - stock_number
			//
			//		ConsumablesDeliveryTwelve(orgID, record_time, goods, warehouseOut, count, creator, warehouseInfo)
			//
			//	}
			//	return nil
			//}
			//
			//func AddWarehosingInfo(info *models.WarehousingInfo) error {
			//
			//	err = XTWriteDB().Create(&info).Error
			//	return err
			//}
			//
			//// 药品出库 递归方式
			//func AutoDrugDeliverInfoTwelve(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo, drugWarehouse *models.DrugWarehouseInfo) (err error) {
			//
			//	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//	} else {
			//		deliver_number = prescribingNumber
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//	storeConfig, _ := GetAllStoreHouseConfig(orgID)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	// 将该批次的剩余库存数量转换为拆零数量
			//
			//	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			//			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  advice.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   12,
			//			SysRecordTime:           advice.Ctime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   deliver_number,
			//			RetailPrice:             warehouse.RetailPrice,
			//			Price:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			//			IsCheck:                 1,
			//		}
			//
			//		warehouseOutInfo.Count = prescribingNumber
			//		warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			Count:                   deliver_number,
			//			Price:                   warehouse.RetailPrice,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			UserOrgId:               advice.OrgId,
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			BatchNumber:             warehouse.BatchNumber,
			//			MaxUnit:                 drup.MinUnit,
			//			ConsumableType:          12,
			//			IsEdit:                  1,
			//			Creator:                 0,
			//			IsSys:                   12,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		if advice.CountUnit == drup.MinUnit {
			//			maxNumber = prescribingNumber / drup.MinNumber
			//			minNumber = prescribingNumber % drup.MinNumber
			//			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//				minNumber = maxNumber
			//			}
			//		} 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 == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			return errors.New("库存数量不足")
			//		}
			//
			//		////扣减库存
			//		//if(warehouse.StockMaxNumber > 0){
			//		//  var sum_count int64
			//		//  sum_count = maxNumber * drup.MinNumber
			//		//  ModifyDrugReduceInformationSix(warehouse.DrugId,sum_count,warehouse.OrgId,warehouse.RetailPrice)
			//		//}
			//		//if(warehouse.StockMinNumber > 0){
			//		//  var sum_count int64
			//		//  sum_count = minNumber
			//		//  ModifyDrugReduceInformationSix(warehouse.DrugId,sum_count,warehouse.OrgId,warehouse.RetailPrice)
			//		//}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//入库
			//		drugInfo := models.DrugWarehouseInfo{
			//			WarehousingOrder:      drugWarehouse.WarehousingOrder,
			//			WarehousingId:         drugWarehouse.WarehousingId,
			//			DrugId:                warehouse.DrugId,
			//			Number:                warehouse.Number,
			//			ProductDate:           warehouse.ProductDate,
			//			ExpiryDate:            warehouse.ExpiryDate,
			//			WarehousingCount:      deliver_number,
			//			Price:                 warehouse.RetailPrice,
			//			TotalPrice:            warehouse.TotalPrice,
			//			Status:                1,
			//			Ctime:                 warehouse.Ctime,
			//			Remark:                "",
			//			OrgId:                 warehouse.OrgId,
			//			Type:                  13,
			//			Manufacturer:          warehouse.Manufacturer,
			//			Dealer:                warehouse.Dealer,
			//			StockMaxNumber:        0,
			//			StockMinNumber:        deliver_number,
			//			BatchNumber:           warehouse.BatchNumber,
			//			MaxUnit:               drup.MinUnit,
			//			MinUnit:               drup.MinUnit,
			//			RetailPrice:           warehouse.RetailPrice,
			//			StorehouseId:          drugWarehouse.StorehouseId,
			//			SecondWarehouseInfoId: drugWarehouse.SecondWarehouseInfoId,
			//			IsCheck:               1,
			//		}
			//
			//		CreateDrugWarehouseInfo(drugInfo)
			//
			//		flow := models.DrugFlow{
			//			WarehousingId:           drugWarehouse.WarehousingId,
			//			DrugId:                  warehouse.DrugId,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   deliver_number,
			//			UserOrgId:               warehouse.OrgId,
			//			PatientId:               0,
			//			SystemTime:              0,
			//			ConsumableType:          13,
			//			IsSys:                   13,
			//			WarehousingOrder:        drugWarehouse.WarehousingOrder,
			//			WarehouseOutId:          0,
			//			WarehouseOutOrderNumber: "",
			//			IsEdit:                  0,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 0,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.RetailPrice,
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehouseOutDetailId:    0,
			//			CancelOutDetailId:       0,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			MaxUnit:                 drup.MinUnit,
			//			MinUnit:                 drup.MinUnit,
			//			StockMaxNumber:          0,
			//			StockMinNumber:          deliver_number,
			//			StorehouseId:            drugWarehouse.StorehouseId,
			//			SecondWarehouseInfoId:   drugWarehouse.SecondWarehouseInfoId,
			//		}
			//
			//		CreateDrugFlowOne(flow)
			//
			//		return nil
			//	} else {
			//		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
			//		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			//			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Remark:                  advice.Remark,
			//			OrgId:                   orgID,
			//			Type:                    1,
			//			Manufacturer:            advice.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			IsSys:                   12,
			//			SysRecordTime:           advice.Ctime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			RetailPrice:             advice.RetailPrice,
			//			Price:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			//			IsCheck:                 1,
			//		}
			//		warehouseOutInfo.Count = stock_number
			//
			//		//warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			//			WarehouseOutId:          advice.WarehouseOutId,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             warehouse.ProductDate,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			Count:                   stock_number,
			//			Price:                   warehouse.RetailPrice,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			UserOrgId:               advice.OrgId,
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			BatchNumber:             warehouse.BatchNumber,
			//			MaxUnit:                 drup.MinUnit,
			//			ConsumableType:          12,
			//			IsEdit:                  1,
			//			Creator:                 0,
			//			IsSys:                   12,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			//		}
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要将该批次库存清零
			//
			//		//入库
			//		drugInfo := models.DrugWarehouseInfo{
			//			WarehousingOrder:      drugWarehouse.WarehousingOrder,
			//			WarehousingId:         drugWarehouse.WarehousingId,
			//			DrugId:                warehouse.DrugId,
			//			Number:                warehouse.Number,
			//			ProductDate:           warehouse.ProductDate,
			//			ExpiryDate:            warehouse.ExpiryDate,
			//			WarehousingCount:      stock_number,
			//			Price:                 warehouse.RetailPrice,
			//			TotalPrice:            warehouse.TotalPrice,
			//			Status:                1,
			//			Ctime:                 warehouse.Ctime,
			//			Remark:                "",
			//			OrgId:                 warehouse.OrgId,
			//			Type:                  13,
			//			Manufacturer:          warehouse.Manufacturer,
			//			Dealer:                warehouse.Dealer,
			//			StockMaxNumber:        0,
			//			StockMinNumber:        stock_number,
			//			RetailTotalPrice:      0,
			//			BatchNumber:           warehouse.BatchNumber,
			//			MaxUnit:               drup.MinUnit,
			//			MinUnit:               drup.MinUnit,
			//			RetailPrice:           warehouse.RetailPrice,
			//			StorehouseId:          drugWarehouse.StorehouseId,
			//			SecondWarehouseInfoId: drugWarehouse.SecondWarehouseInfoId,
			//		}
			//
			//		CreateDrugWarehouseInfo(drugInfo)
			//
			//		flow := models.DrugFlow{
			//			WarehousingId:           drugWarehouse.WarehousingId,
			//			DrugId:                  warehouse.DrugId,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			UserOrgId:               warehouse.OrgId,
			//			PatientId:               0,
			//			SystemTime:              0,
			//			ConsumableType:          13,
			//			IsSys:                   13,
			//			WarehousingOrder:        drugWarehouse.WarehousingOrder,
			//			WarehouseOutId:          0,
			//			WarehouseOutOrderNumber: "",
			//			IsEdit:                  0,
			//			CancelStockId:           0,
			//			CancelOrderNumber:       "",
			//			Manufacturer:            warehouse.Manufacturer,
			//			Dealer:                  warehouse.Dealer,
			//			Creator:                 0,
			//			UpdateCreator:           0,
			//			Status:                  1,
			//			Ctime:                   time.Now().Unix(),
			//			Mtime:                   0,
			//			Price:                   warehouse.RetailPrice,
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehouseOutDetailId:    0,
			//			CancelOutDetailId:       0,
			//			ExpireDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			MaxUnit:                 drup.MinUnit,
			//			MinUnit:                 drup.MinUnit,
			//			StockMaxNumber:          0,
			//			StockMinNumber:          stock_number,
			//			StorehouseId:            drugWarehouse.StorehouseId,
			//			SecondWarehouseInfoId:   drugWarehouse.SecondWarehouseInfoId,
			//		}
			//
			//		CreateDrugFlowOne(flow)
			//
			//		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
			//
			//		AutoDrugDeliverInfoTwelve(orgID, prescribingNumber_two_temp, warehouseout, drup, advice, drugWarehouse)
			//	}
			//
			//	return
			//}
			//
			//// 药品手动出库 递归方式
			//func AutoDrugDeliverInfoTwenty(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
			//
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//	} else {
			//		deliver_number = prescribingNumber
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//
			//	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:                  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:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			IsCheck:                 1,
			//		}
			//
			//		if warehouse.RetailPrice == 0 {
			//			warehouseOutInfo.Price = advice.Price
			//		}
			//
			//		warehouseOutInfo.Count = prescribingNumber
			//		warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//		}
			//		if warehouse.RetailPrice == 0 {
			//			drugflow.Price = advice.Price
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		//var stock_max_number int64 = 0
			//		//stock_max_number = warehouse.StockMaxNumber
			//
			//		maxNumber = deliver_number / drup.MinNumber
			//		minNumber = deliver_number % drup.MinNumber
			//
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//			if minNumber > 0 {
			//				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				} else {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//				}
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 {
			//				if warehouse.StockMinNumber > 0 {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				}
			//
			//			}
			//
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//
			//				//if warehouse.StockMinNumber == 0 {
			//				//  warehouse.StockMaxNumber = stock_max_number
			//				//}
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//				sum_count += it.StockMaxNumber + it.StockMinNumber
			//				sum_in_count += it.WarehousingCount
			//			}
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//
			//		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:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           advice.Ctime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			RetailPrice:             advice.RetailPrice,
			//			Price:                   warehouse.RetailPrice,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			IsCheck:                 1,
			//		}
			//		if warehouse.RetailPrice == 0 {
			//			warehouseOutInfo.Price = advice.Price
			//		}
			//		warehouseOutInfo.Count = stock_number
			//
			//		//warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
			//		if errOne != nil {
			//			return errOne
			//		}
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          warehouseout.ID,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   stock_number,
			//			Price:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//		}
			//		if warehouse.RetailPrice == 0 {
			//			drugflow.Price = advice.Price
			//		}
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要将该批次库存清零
			//		//扣减库存
			//
			//		warehouse.StockMaxNumber = 0
			//		warehouse.StockMinNumber = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//				sum_count += it.StockMaxNumber + it.StockMinNumber
			//				sum_in_count += it.WarehousingCount
			//			}
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//		if errThree != nil {
			//			return errThree
			//		}
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		prescribingNumber_two_temp := deliver_number - stock_number
			//
			//		advice.CountUnit = drup.MinUnit
			//
			//		AutoDrugDeliverInfoTwenty(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
			//	}
			//
			//	return
			//}
			//
			//// 药品手动出库 递归方式
			//func AutoDrugDeliverInfoTwentyOne(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {
			//	//开事务
			//	//tx := XTWriteDB().Begin()
			//	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//	} else {
			//		deliver_number = prescribingNumber
			//	}
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//	// 如果没有对应的库存，则报错
			//	//开启事物
			//	storeConfig, _ := GetAllStoreHouseConfig(orgID)
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//
			//	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:                  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,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//			IsCheck:                 1,
			//		}
			//
			//		warehouseOutInfo.Count = prescribingNumber
			//		warehouseOutInfo.CountUnit = advice.CountUnit
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//		}
			//		if warehouse.RetailPrice == 0 {
			//			drugflow.Price = advice.Price
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		var maxNumber int64 = 0
			//		var minNumber int64 = 0
			//		//var stock_max_number int64 = 0
			//		//stock_max_number = warehouse.StockMaxNumber
			//
			//		maxNumber = deliver_number / drup.MinNumber
			//		minNumber = deliver_number % drup.MinNumber
			//
			//		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			//			minNumber = maxNumber
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//			if minNumber > 0 {
			//				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				} else {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//				}
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 {
			//				if warehouse.StockMinNumber > 0 {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				}
			//
			//			}
			//
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) > 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//
			//				//if warehouse.StockMinNumber == 0 {
			//				//  warehouse.StockMaxNumber = stock_max_number
			//				//}
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//		fmt.Println(errThree)
			//		//if errThree != nil {
			//		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//				sum_count += it.StockMaxNumber + it.StockMinNumber
			//				sum_in_count += it.WarehousingCount
			//			}
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//
			//		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:                  warehouse.Dealer,
			//			IsSys:                   0,
			//			SysRecordTime:           advice.Ctime,
			//			DrugId:                  advice.DrugId,
			//			ExpiryDate:              warehouse.ExpiryDate,
			//			ProductDate:             warehouse.ProductDate,
			//			Number:                  warehouse.Number,
			//			BatchNumber:             warehouse.BatchNumber,
			//			Count:                   stock_number,
			//			RetailPrice:             advice.RetailPrice,
			//			Price:                   advice.Price,
			//			WarehouseInfoId:         warehouse.ID,
			//			CountUnit:               drup.MinUnit,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//			IsCheck:                 1,
			//		}
			//
			//		warehouseOutInfo.Count = stock_number
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          warehouseout.ID,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   stock_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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		// 出库完成后，要将该批次库存清零
			//		//扣减库存
			//
			//		warehouse.StockMaxNumber = 0
			//		warehouse.StockMinNumber = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//		fmt.Println(errThree)
			//		//if errThree != nil {
			//		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
			//		//	tx.Rollback()
			//		//} else {
			//		//	tx.Commit()
			//		//}
			//
			//		//查询默认仓库
			//		houseConfig, _ := GetAllStoreHouseConfig(orgID)
			//		//查询默认仓库剩余多少库存
			//		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
			//		var sum_count int64
			//		var sum_in_count int64
			//		for _, it := range list {
			//			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			//			if it.MaxUnit == baseDrug.MaxUnit {
			//				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
			//				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			//				sum_count += it.StockMaxNumber + it.StockMinNumber
			//				sum_in_count += it.WarehousingCount
			//			}
			//		}
			//		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
			//		if errThree != nil {
			//			return errThree
			//		}
			//		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			//		prescribingNumber_two_temp := deliver_number - stock_number
			//
			//		advice.CountUnit = drup.MinUnit
			//
			//		AutoDrugDeliverInfoTwentyOne(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
			//	}
			//
			//	return
			//}
			//
			////耗材手动出库
			//func ConsumablesDeliveryThirty(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
			//
			//	// 根据先进先出原则，查询最先入库的批次，进行出库
			//
			//	// 如果没有对应的库存，则报错
			//	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId, goods.StorehouseId)
			//	if err != nil {
			//		goodErrcode := models.XtGoodErrcode{
			//			UserOrgId:      goods.OrgId,
			//			Errcode:        "查询库存信息报错",
			//			GoodId:         goods.GoodId,
			//			Status:         1,
			//			Ctime:          time.Now().Unix(),
			//			Mtime:          0,
			//			Count:          0,
			//			StockCount:     0,
			//			Creater:        creator,
			//			BatchNumberId:  warehouse.ID,
			//			WarehouseOutId: 0,
			//		}
			//		CreateGoodErrcode(goodErrcode)
			//		return err
			//	}
			//
			//	stock_number = warehouse.StockCount
			//
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//		maxNumber = goods.Count
			//		warehouse.StockCount = warehouse.StockCount - maxNumber
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		//扣减库存
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "扣减库存失败",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//			return errThree
			//		}
			//
			//		//查询剩余库存
			//		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
			//		var sum_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//		}
			//
			//		warehouseOutInfo := &models.WarehouseOutInfo{
			//			WarehouseInfotId: warehouse.ID,
			//		}
			//		//添加入库单详情ID
			//		errOne := UpdatedSigleWarehouseOutInfo(goods.ID, warehouseOutInfo)
			//		if errOne != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "添加入库单详情ID",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//			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:        warehouse.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:                   warehouse.PackingPrice, //零售价
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehouseOutDetailId:    goods.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price, //进货价
			//			StockCount:              goods.StockCount,
			//			BatchNumberCount:        warehouse.StockCount - goods.Count,
			//			IsCheck:                 1,
			//			OverCount:               sum_count,
			//			RegisterNumber:          goods.RegisterNumber,
			//		}
			//		//创建出库流水
			//		errflow := CreateStockFlowOne(stockFlow)
			//		if errflow != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "创建流水报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//
			//		//添加入库ID
			//		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, goods.OrgId, sum_count)
			//		if errWarehouse != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "添加入库ID报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//
			//		//更新出库数量
			//		errsumcode := ModifyGoodSumCount(goods.StorehouseId, goods.Count, goods.OrgId, goods.GoodId)
			//		if errsumcode != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "更新出库数量报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//
			//		if warehouse.StockCount < maxNumber {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "出库接口库存数量不足",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//			return errors.New("库存数量不足")
			//
			//		}
			//
			//		return nil
			//	} else {
			//		// 出库完成后，要将该批次库存清零
			//		warehouse.StockCount = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "扣减库存报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//			return errThree
			//		}
			//
			//		//查询剩余库存
			//		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
			//		var sum_count int64
			//		for _, item := range goodList {
			//			sum_count += item.StockCount
			//		}
			//
			//		stockFlow := models.VmStockFlow{
			//			WarehousingId:           warehouse.ID,
			//			GoodId:                  goods.GoodId,
			//			Number:                  warehouse.Number,
			//			LicenseNumber:           goods.LicenseNumber,
			//			Count:                   stock_number,
			//			UserOrgId:               goods.OrgId,
			//			PatientId:               goods.PatientId,
			//			SystemTime:              record_time,
			//			ConsumableType:          2,
			//			IsSys:                   goods.IsSys,
			//			WarehousingOrder:        warehouse.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:                   warehouse.PackingPrice, //零售价
			//			WarehousingDetailId:     warehouse.ID,
			//			WarehouseOutDetailId:    goods.ID,
			//			CancelOutDetailId:       0,
			//			ProductDate:             goods.ProductDate,
			//			ExpireDate:              goods.ExpiryDate,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            warehouse.StorehouseId,
			//			AdminUserId:             goods.AdminUserId,
			//			BuyPrice:                warehouse.Price, //进货价
			//			StockCount:              goods.StockCount,
			//			BatchNumberCount:        0,
			//			IsCheck:                 1,
			//			OverCount:               sum_count,
			//			RegisterNumber:          goods.RegisterNumber,
			//		}
			//		//创建出库流水
			//		errflow := CreateStockFlowOne(stockFlow)
			//		if errflow != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "创建出库流水报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//
			//		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, goods.OrgId, sum_count)
			//		if errWarehouse != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "添加入库ID报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//
			//		//更新出库数量
			//		errcodecout := ModifyGoodSumCount(goods.StorehouseId, stock_number, goods.OrgId, goods.GoodId)
			//
			//		if errcodecout != nil {
			//			goodErrcode := models.XtGoodErrcode{
			//				UserOrgId:      goods.OrgId,
			//				Errcode:        "更新出库数量报错",
			//				GoodId:         goods.GoodId,
			//				Status:         1,
			//				Ctime:          time.Now().Unix(),
			//				Mtime:          0,
			//				Count:          0,
			//				StockCount:     0,
			//				Creater:        creator,
			//				BatchNumberId:  warehouse.ID,
			//				WarehouseOutId: 0,
			//			}
			//			CreateGoodErrcode(goodErrcode)
			//		}
			//	}
			//
			//	goods.Count = deliver_number - stock_number
			//	ConsumablesDeliveryThirty(orgID, record_time, goods, warehouseOut, count, creator)
			//
			//	return nil
			//}
			//
			//// 药品手动出库 递归方式
			//func AutoDrugDeliverInfoFourtyOne(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {
			//
			//	fmt.Println("出库数量", prescribingNumber)
			//
			//	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
			//	var deliver_number int64 = 0
			//	var stock_number int64 = 0
			//	var retail_price float64
			//	if advice.CountUnit == drup.MaxUnit {
			//		deliver_number = prescribingNumber * drup.MinNumber
			//		formatInt := strconv.FormatInt(prescribingNumber, 10)
			//		floatcount, _ := strconv.ParseFloat(formatInt, 64)
			//		retail_price = floatcount * advice.Price
			//	} else {
			//		deliver_number = prescribingNumber
			//		formatInt := strconv.FormatInt(prescribingNumber, 10)
			//		floatcount, _ := strconv.ParseFloat(formatInt, 64)
			//		retail_price = floatcount * advice.Price
			//	}
			//
			//	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//	if lastWarehouse.StockMinNumber >= drup.MinNumber {
			//		var stockMax int64
			//		var stockMin int64
			//		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			//		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			//		fmt.Println("stockmax", stockMax)
			//		fmt.Println("stockMin", stockMin)
			//		ChangeMaxNumber(lastWarehouse.ID, stockMax)
			//		UpdateMinNumber(lastWarehouse.ID, stockMin)
			//	}
			//
			//	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
			//
			//	if err != nil {
			//
			//		return err
			//	}
			//
			//	// 将该批次的剩余库存数量转换为拆零数量
			//	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
			//		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
			//	}
			//	if warehouse.MaxUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
			//		stock_number = warehouse.StockMaxNumber + warehouse.StockMinNumber
			//	}
			//	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit == drup.MinUnit {
			//		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
			//	}
			//
			//	fmt.Println("stock_number", stock_number)
			//	fmt.Println("deliver_number", deliver_number)
			//	// 当库存数量大于或等于出库数量的话，则正常出库该批次
			//	if stock_number >= deliver_number {
			//
			//		// 出库完成后，要减去对应批次的库存数量
			//		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
			//		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 drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//
			//		if drup.MinUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
			//		}
			//		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//		}
			//		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			//		}
			//
			//		if warehouse.StockMaxNumber < 0 {
			//			warehouse.StockMaxNumber = 0
			//		}
			//		if warehouse.StockMinNumber < 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		if warehouse.StockMinNumber < minNumber {
			//			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			//			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			//		} else {
			//			fmt.Println("maxNumber23323323332322323w9", maxNumber)
			//			fmt.Println("maxNumber23323323332322323w9", minNumber)
			//			if minNumber > 0 {
			//				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
			//					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//				} else {
			//					if (warehouse.StockMinNumber - minNumber) >= 0 {
			//						warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			//					}
			//
			//				}
			//			}
			//
			//			if minNumber == 0 && maxNumber != 1 {
			//				if warehouse.StockMinNumber > 0 {
			//					if (warehouse.StockMinNumber - deliver_number) >= 0 {
			//						warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//					}
			//				}
			//			}
			//		}
			//
			//		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			//			if (warehouse.StockMinNumber - deliver_number) >= 0 {
			//				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			//			}
			//
			//		}
			//
			//		if drup.MaxUnit != drup.MinUnit {
			//			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
			//				return errors.New("库存数量不足")
			//			}
			//		}
			//		if warehouse.StockMinNumber <= 0 {
			//			warehouse.StockMinNumber = 0
			//		}
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//
			//		if errThree != nil {
			//			return errors.New("扣减库存失败")
			//		}
			//
			//		//查询该药品剩余库存
			//		infolist, _ := FindDrugWarehouseInfoFlushCount(advice.DrugId, advice.OrgId)
			//		var over_count int64
			//		for _, its := range infolist {
			//			if its.MaxUnit == drup.MaxUnit {
			//				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			//			}
			//			over_count += its.StockMaxNumber + its.StockMinNumber
			//		}
			//
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		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:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//			WarehousingDetailId:     warehouse.ID,
			//			OverCount:               over_count,
			//			RetailPrice:             retail_price, //手动出库出库价格
			//			WarehousingId:           warehouse.ID,
			//		}
			//		if warehouse.RetailPrice == 0 {
			//			drugflow.Price = advice.Price
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//
			//		//更新出库id
			//		UpdateDrugWarehouseOutInfo(advice.ID, warehouse.ID, advice.OrgId, over_count)
			//
			//		return nil
			//
			//	} else {
			//		stock_number_int := strconv.FormatInt(stock_number, 10)
			//		stock_number_int_count, _ := strconv.ParseFloat(stock_number_int, 64)
			//		retail_price = stock_number_int_count * advice.Price
			//		//扣减库存
			//		warehouse.StockMaxNumber = 0
			//		warehouse.StockMinNumber = 0
			//		warehouse.Mtime = time.Now().Unix()
			//
			//		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
			//		if errThree != nil {
			//			return errThree
			//		}
			//
			//		//查询该药品剩余库存
			//		infolist, _ := FindDrugWarehouseInfoFlushCount(advice.DrugId, advice.OrgId)
			//		var over_count int64
			//		for _, its := range infolist {
			//			if its.MaxUnit == drup.MaxUnit {
			//				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			//			}
			//			over_count += its.StockMaxNumber + its.StockMinNumber
			//		}
			//		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
			//		drugflow := models.DrugFlow{
			//			WarehouseOutId:          warehouseout.ID,
			//			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			//			DrugId:                  advice.DrugId,
			//			Number:                  warehouse.Number,
			//			ProductDate:             advice.ProductDate,
			//			ExpireDate:              advice.ExpiryDate,
			//			Count:                   stock_number,
			//			Price:                   warehouse.RetailPrice,
			//			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,
			//			WarehouseOutDetailId:    drugWareInfo.ID,
			//			AdviceId:                advice.ID,
			//			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			//			StorehouseId:            advice.StorehouseId,
			//			AdminUserId:             advice.AdminUserId,
			//			LastPrice:               warehouse.Price,
			//			StockCount:              advice.StockCount,
			//			OverCount:               over_count,
			//			RetailPrice:             retail_price, //手动出库出库价格
			//			WarehousingId:           warehouse.ID,
			//			WarehousingDetailId:     warehouse.ID,
			//		}
			//
			//		CreateDrugFlowOne(drugflow)
			//		//更新出库id
			//		UpdateDrugWarehouseOutInfo(advice.ID, warehouse.ID, advice.OrgId, over_count)
			//		// 出库完成后，要将该批次库存清零
			//
			//		prescribingNumber_two_temp := deliver_number - stock_number
			//
			//		advice.CountUnit = drup.MinUnit
			//
			//		AutoDrugDeliverInfoFourtyOne(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
			//	}
			//
			//	return
			//}
			//
			//func UpdateDrugWarehouseOutInfo(id int64, warehouse_info_id int64, org_id int64, over_count int64) error {
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.DrugWarehouseOutInfo{}).Where("id = ? and org_id = ? and status = 1", id, org_id).Update(map[string]interface{}{"warehouse_info_id": warehouse_info_id, "over_count": over_count}).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func UpdateGoodWarehouseOutById(id int64, warehouse_info_id int64, org_id int64, over_count int64) error {
			//	utx := XTWriteDB().Begin()
			//	err := utx.Model(models.WarehouseOutInfo{}).Where("id = ?  and org_id = ? and status = 1", id, org_id).Update(map[string]interface{}{"warehouse_info_id": warehouse_info_id, "over_count": over_count}).Error
			//	if err != nil {
			//		utx.Rollback()
			//		return err
			//	}
			//	utx.Commit()
			//	return err
			//}
			//
			//func ChangeMaxNumber(id int64, count int64) error {
			//
			//	err = XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
			//	return err
			//
			//}
			//
			//func UpdateMinNumber(id int64, count int64) error {
			//
			//	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Update(map[string]interface{}{"stock_min_number": count}).Error
			//	return err
			//}
			//
			//func FindLastDrugWarehouseOutInfo(orgid int64) (models.DrugWarehouseOutInfo, error) {
			//	info := models.DrugWarehouseOutInfo{}
			//	err := XTReadDB().Where("org_id = ? and status = 1", orgid).Last(&info).Error
			//	return info, err
			//}
			//
			//func GetAllGoodSumCount(goodid int64, orgid int64) (info []*models.WarehousingInfo, err error) {
			//
			//	err = XTReadDB().Where("good_id = ? and org_id = ? and is_check =1 and status= 1 and stock_count > 0", goodid, orgid).Find(&info).Error
			//	return info, err
			//}
			//
			//func CreatedFlushInfo(info models.XtWarehouseFlushInfo) error {
			//	ut := writeDb.Begin()
			//	err := ut.Create(&info).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//
			//}
			//
			//func FindDrugWarehouseInfoList(drugid int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {
			//
			//	err = XTReadDB().Where("drug_id = ? and org_id = ? and status =1 and is_check =1  and (stock_max_number>0 or stock_min_number>0)", drugid, orgid).Find(&info).Error
			//	return info, err
			//}
			//
			//func CreatedDrugFlushInfo(info models.XtDrugWarehouseFlushInfo) error {
			//	ut := writeDb.Begin()
			//	err := ut.Create(&info).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func UpdateWarehouseFlushInfo(warehouse_out_id int64, record_time int64, patient_id int64, batch_nubmer_id int64, good_id int64, sum_count int64, orgid int64) error {
			//
			//	err := XTWriteDB().Model(&models.XtWarehouseFlushInfo{}).Where("warehouse_out_id = ? and system_time = ? and patient_id = ? and batch_number_id = ? and good_id = ? and user_org_id = ?", warehouse_out_id, record_time, patient_id, batch_nubmer_id, good_id, orgid).Update(map[string]interface{}{"flush_count": sum_count}).Error
			//	return err
			//}
			//
			//func FindLastWarehouseOutInfo(orgId int64) (models.WarehouseOutInfo, error) {
			//
			//	info := models.WarehouseOutInfo{}
			//	err := XTReadDB().Model(&info).Where("org_id = ? and status = 1", orgId).Find(&info).Error
			//	return info, err
			//}
			//
			//func ModifyAddGoodInformation(count int64, id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyReduceGoodInformation(count int64, id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddCancelCount(count int64, id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyReduceCancelCount(count int64, id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddDrugInformation(id int64, count int64, orgid int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyReduceDrugInformation(id int64, count int64, orgid int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddCancelAddInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id = ?", id, orgid, storehouse_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddDrugOutReduceInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id  =?", id, orgid, storehouse_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddDrugOutAddInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id  =?", id, orgid, storehouse_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyDrugCancelWarehouseInfo(id int64, count int64, orgid int64, storehouse_id int64) error {
			//	ut := XTWriteDB().Begin()
			//	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id = ?", id, orgid, storehouse_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//
			//	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//
			//	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_act_out_count", gorm.Expr("stock_act_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyReduceGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//
			//	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//
			//	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_act_out_count", gorm.Expr("stock_act_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//
			//	ut.Commit()
			//	return err
			//}
			//
			//func ModifyAddGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {
			//	ut := XTWriteDB().Begin()
			//
			//	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//
			//	ut.Commit()
			//	return err
			//}
			//
			//func UpdateSumAddCancelCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_cancel_count", gorm.Expr("stock_cancel_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func UpdateSumReduceCancelCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_cancel_count", gorm.Expr("stock_cancel_count - ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func UpdateSumAddOutCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {
			//
			//	ut := XTWriteDB().Begin()
			//	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count + ?", count)).Error
			//	if err != nil {
			//		ut.Rollback()
			//		return err
			//	}
			//	ut.Commit()
			//	return err
			//}
			//
			//func FindDrugWarehouseInfoFlushCount(drug_id int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {
			//
			//	err = XTReadDB().Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1", drug_id, orgid).Find(&info).Error
			//	return info, err
			//}
			//
			//func FindDrugWarehouseInfoFlushCountByStorehouse(drug_id int64, orgid int64, storehouse_id int64) (info []*models.DrugWarehouseInfo, err error) {
			//
			//	err = XTReadDB().Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1 and storehouse_id =?", drug_id, orgid, storehouse_id).Find(&info).Error
			//	return info, err
			//}
			//  if(item.PrescribingNumberUnit == drup.MaxUnit && drup.MaxUnit ==drup.MinUnit ){
			//    prescribingNumber_temp := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			//    count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
			//    total_count += count
			//  }
			//  info := models.DrugWarehouseOutInfo{
			//    Count:     total_count,
			//    CountUnit: drup.MinUnit,
			//  }
			//
			//  fmt.Println("total_coutn 233232322323232323233222322wo",total_count)
			//  //更新出库单数据
			//  UpdateDrugWarehouseOutByPatientId(advice.PatientId,advice.AdviceDate,advice.UserOrgId,info)
			//}

		} 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
	}
	fmt.Println(min_price)
	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错

	//查询默认仓库
	storeConfig, _ := GetAllStoreHouseConfig(orgID)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber

		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}
	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)

	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:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Price:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			RetailPrice:             warehouse.RetailPrice,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   deliver_number,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
			LastPrice:               warehouse.Price,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
		if errOne != nil {
			return errOne
		}
		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:                   warehouse.RetailPrice,
			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,
			SystemTime:              advice.AdviceDate,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			LastPrice:               warehouse.Price,
		}

		CreateDrugFlowOne(drugflow)

		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,
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		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

		fmt.Println("maxNumber2323233232323232323232", maxNumber)
		fmt.Println("minNumber2323233232323232323232", minNumber)
		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()
		fmt.Println("warehouse.StockMinNumber", warehouse.StockMinNumber)
		fmt.Println("minNumber", minNumber)
		fmt.Println("maxNumber", maxNumber)
		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			if warehouse.MaxUnit != warehouse.MinUnit {

				warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			}
		} else {

			if minNumber > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			}

		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			}
		}

		if drup.MaxUnit != drup.MinUnit {
			if warehouse.StockMaxNumber < 0 && warehouse.StockMinNumber < 0 {
				return errors.New("库存数量不足")
			}
		}
		if warehouse.StockMinNumber <= 0 {
			warehouse.StockMinNumber = 0
		}
		//扣减库存
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}
		drugInfoList, _ := FindDrugWarehouseInfoList(advice.DrugId, orgID)
		var drug_max_number int64
		var drug_min_number int64
		for _, item := range drugInfoList {
			drug_max_number += item.StockMaxNumber
			drug_min_number += item.StockMinNumber
		}
		drugFlushInfo := models.XtDrugWarehouseFlushInfo{
			DrugMaxNumber:           drug_max_number,
			UserOrgId:               orgID,
			WarehouseOutId:          warehouseout.ID,
			Type:                    1,
			SystemTime:              advice.RecordDate,
			PatientId:               advice.PatientId,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			BatchNumberId:           warehouse.ID,
			DrugId:                  advice.DrugId,
			Count:                   deliver_number,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			Creater:                 warehouseout.Creater,
			DrugMinNumber:           drug_min_number,
			Unit:                    drup.MinUnit,
			AdviceId:                advice.ID,
			Status:                  1,
			WarehouseOutDetailId:    lastDrugOutInfo.ID,
		}
		CreatedDrugFlushInfo(drugFlushInfo)

		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:                   warehouse.RetailPrice,
			RetailPrice:             warehouse.RetailPrice,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   stock_number,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)

		if errOne != nil {
			return errOne
		}
		lastDrugOutInfo, _ := FindLastDrugWarehouseOutInfo(orgID)
		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:                   warehouse.RetailPrice,
			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,
			SystemTime:              advice.AdviceDate,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			WarehouseOutDetailId:    lastDrugOutInfo.ID,
			LastPrice:               warehouse.Price,
		}

		CreateDrugFlowOne(drugflow)

		//查询是否存在数据

		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,
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		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,
			MinUnit:           warehouse.MinUnit,
			WarehousingInfoId: warehouse.WarehousingInfoId,
			StorehouseId:      storeConfig.DrugStorehouseOut,
			IsCheck:           1,
		}
		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 = drup.MinUnit

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

	return
}

// 药品出库 递归方式
func AutoDrugDeliverInfo(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {

	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0

	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
	} else {
		deliver_number = prescribingNumber
	}

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

	storeConfig, _ := GetAllStoreHouseConfig(orgID)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)

	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:                  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:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			IsCheck:                 1,
		}

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

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		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:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		if advice.CountUnit == drup.MinUnit {
			maxNumber = prescribingNumber / drup.MinNumber
			minNumber = prescribingNumber % drup.MinNumber
			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
				minNumber = maxNumber
			}
		} 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 == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			warehouse.StockMinNumber = 0
		}

		if warehouse.StockMaxNumber < 0 {
			return errors.New("库存数量不足")
		}

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
			}
			sum_count += it.StockMaxNumber + it.StockMinNumber
			sum_in_count += it.WarehousingCount
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)

		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:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = stock_number

		//warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   stock_number,
			Price:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
		}
		CreateDrugFlowOne(drugflow)
		// 出库完成后，要将该批次库存清零
		//扣减库存

		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
		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

					goods[j].Count = temp_count
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)

					break
				}
			}
		}
	}

	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
	// goods 这个数据就是需要出库的耗材的数据(新增的数据)

	if len(goods) > 0 {
		out, err := FindStockOutByIsSys(orgID, 1, record_time)
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		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,
				StorehouseId:            houseConfig.StorehouseOutInfo,
				IsCheck:                 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
				}
			}

			var cha_count int64
			var cha_count_two int64
			flowGood, _ := GetStockFlowIsBatchNumberTwo(patient_id, record_time, item.GoodId)
			var out_count int64
			for _, item := range flowGood {
				out_count += item.Count
			}
			cha_count = item.Count - out_count
			//fmt.Println("item.Count", item.Count)
			//fmt.Println("item.Count", out_count)
			//fmt.Println("cha_count2323223232323223", cha_count)
			cha_count_two = out_count - item.Count

			prepare := models.DialysisBeforePrepare{
				GoodTypeId:   item.GoodTypeId,
				GoodId:       item.GoodId,
				Count:        cha_count,
				ProjectId:    item.ProjectId,
				StorehouseId: houseConfig.StorehouseOutInfo,
			}

			ConsumablesGoodDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
			//数量增加
			if cha_count > 0 {
				//出库数量累加
				ModifyGoodSumCount(houseConfig.StorehouseOutInfo, cha_count, orgID, item.GoodId)
			}
			//数量减少
			if cha_count_two > 0 {
				ModifyAddGoodSumCount(houseConfig.StorehouseOutInfo, cha_count_two, orgID, item.GoodId)
				//退库数量增加
				UpdateSumAddCancelCount(orgID, item.GoodId, houseConfig.StorehouseOutInfo, cha_count_two)

			}
			//更新剩余库存
			goodListSix, _ := GetSumGoodList(orgID, houseConfig.StorehouseOutInfo, item.GoodId)
			var flush_count int64
			for _, it := range goodListSix {
				flush_count += it.StockCount
			}
			UpdateSumGood(orgID, houseConfig.StorehouseOutInfo, item.GoodId, flush_count)

		}

	}
	fmt.Println("goods_yc2323323223323223232323232332wode", goods_yc)
	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, goods.StorehouseId)
	if err != nil {
		return errors.New("库存数量不足")
	}

	stock_number = warehouse.StockCount

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

		maxNumber = goods.Count
		//出库
		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
		}
		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		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:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = count

		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
		if errcodes == gorm.ErrRecordNotFound {
			errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
			if errOne != nil {
				return errOne
			}
		} else if errcodes == nil {
			UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
		}

		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,
			ProjectId:               goods.ProjectId,
			StorehouseId:            goods.StorehouseId,
		}
		//查询当天耗材是否已经存在数据
		_, 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:                   warehouse.PackingPrice,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				UserOrgId:               orgID,
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.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,
				ProjectId:               goods.ProjectId,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            goods.StorehouseId,
				OverCount:               sum_count,
			}

			//查询流水是否存在
			exsit, errflow := GetStockFlowIsExsit(warehouse.ID, patient_id, record_time, goods.GoodId)

			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:                   warehouse.PackingPrice,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					UserOrgId:               orgID,
					Manufacturer:            warehouse.Manufacturer,
					Dealer:                  warehouse.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),
					ProjectId:               goods.ProjectId,
					StorehouseId:            goods.StorehouseId,
					OverCount:               sum_count,
				}

				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:                   warehouse.PackingPrice,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				UserOrgId:               orgID,
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.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,
				ProjectId:               goods.ProjectId,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            goods.StorehouseId,
				OverCount:               sum_count,
			}
			//查询流水是否存在
			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:                   warehouse.PackingPrice,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					UserOrgId:               orgID,
					Manufacturer:            warehouse.Manufacturer,
					Dealer:                  warehouse.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),
					ProjectId:               goods.ProjectId,
					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
					StorehouseId:            goods.StorehouseId,
					OverCount:               sum_count,
				}
				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
				DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
				CreateAutoReduceRecord(&details)
			}

		}

		return nil
	} else {

		// 当刚批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}
		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:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = stock_number

		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, goods.PatientId, record_time, goods.ProjectId)

		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:                   warehouse.PackingPrice,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				UserOrgId:               orgID,
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.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,
				ProjectId:               goods.ProjectId,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            goods.StorehouseId,
				OverCount:               sum_count,
			}
			//查询流水是否存在
			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:                   warehouse.PackingPrice,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					UserOrgId:               orgID,
					Manufacturer:            warehouse.Manufacturer,
					Dealer:                  warehouse.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),
					ProjectId:               goods.ProjectId,
					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
					StorehouseId:            goods.StorehouseId,
					OverCount:               sum_count,
				}
				errOne := UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
				if errOne == nil {

				}
			}

		} else if errcodes == nil {

			goods.Count = deliver_number - stock_number
			//更新数量为  该批次剩余数量  + 还有未出的数量
			warehouseOutInfo.Count = stock_number
			UpdatedWarehouseOutInfo(warehouseOutInfo, goods.GoodId, goods.PatientId, record_time, goods.ProjectId)
			//插入库存流水表
			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:                   warehouse.PackingPrice,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				UserOrgId:               orgID,
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.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,
				ProjectId:               goods.ProjectId,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            goods.StorehouseId,
				OverCount:               sum_count,
			}
			//查询流水是否存在
			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:                   warehouse.PackingPrice,
					Status:                  1,
					Ctime:                   time.Now().Unix(),
					UserOrgId:               orgID,
					Manufacturer:            warehouse.Manufacturer,
					Dealer:                  warehouse.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,
					ProjectId:               goods.ProjectId,
					SupplyWarehouseId:       warehouse.SupplyWarehouseId,
					StorehouseId:            goods.StorehouseId,
					OverCount:               sum_count,
				}
				UpdatedStockFlowOne(flow, warehouse.ID, patient_id, record_time, goods.GoodId)
			}
		}

		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		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 {
		// 删除出库完成后，要增加对应批次的库存数量
		errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count, patient_id, record_time, good_yc.GoodId)
		if errThree != nil {
			return errThree
		}
		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(good_yc.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}
		// 判断当前出库的数据和删除出库数量
		if good_yc.Count <= ware.Count {
			delete_count = good_yc.Count
		} else {
			delete_count = ware.Count
		}
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		// 在出库记录表里记录退库详情
		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,
			StorehouseId:  houseConfig.StorehouseOutInfo,
			OverCount:     sum_count,
		}
		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,
				StorehouseId:            houseConfig.StorehouseOutInfo,
			}
			//查询是否当天已经存在数据
			_, 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)
			}
		}

		//扣减数量相加
		ModifyAddGoodSumCount(houseConfig.StorehouseOutInfo, delete_count, good_yc.UserOrgId, good_yc.GoodId)

		//退库数量相加
		UpdateSumAddCancelCount(good_yc.UserOrgId, good_yc.GoodId, houseConfig.StorehouseOutInfo, delete_count)

		// 增加了对应的库存后，看看还有多少需要退库的
		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) {

	////开事务
	//tx := XTWriteDB().Begin()

	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, goods.StorehouseId)
	if err != nil {

		return err
	}

	stock_number = warehouse.StockCount

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

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  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,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price,
			StockCount:              goods.StockCount,
		}
		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:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price,
			StockCount:              goods.StockCount,
		}

		//创建出库流水
		CreateStockFlowOne(stockFlow)

		maxNumber = goods.Count

		if warehouse.StockCount < maxNumber {
			return errors.New("库存数量不足")
		}

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

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		fmt.Println(errThree)
		//if errThree != nil {
		//	utils.ErrorLog("事务失败,原因为: %v", errThree.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}

		//查询该机构默认仓库
		storeConfig, _ := GetAllStoreHouseConfig(goods.OrgId)
		//查询剩余库存
		goodList, _ := GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, goods.GoodId, goods.OrgId)
		var sum_count int64
		var sum_in_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
			sum_in_count += item.WarehousingCount
		}
		UpdateGoodByGoodId(goods.GoodId, sum_count, sum_in_count, goods.OrgId)
		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:                   warehouse.PackingPrice,
			LicenseNumber:           goods.LicenseNumber,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price,
			StockCount:              goods.StockCount,
			IsCheck:                 1,
		}
		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:                   stock_number,
			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:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price,
			StockCount:              goods.StockCount,
		}

		//创建出库明细
		CreateStockFlowOne(stockFlow)
		//查询该机构默认仓库
		storeConfig, _ := GetAllStoreHouseConfig(goods.OrgId)
		//查询剩余库存
		goodList, _ := GetGoodSumCountByStoreId(storeConfig.StorehouseOutInfo, goods.GoodId, goods.OrgId)
		var sum_count int64
		var sum_in_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
			sum_in_count += item.WarehousingCount
		}
		UpdateGoodByGoodId(goods.GoodId, sum_count, sum_in_count, goods.OrgId)
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)
		fmt.Println(errThree)
		//if errThree != nil {
		//	utils.ErrorLog("事务失败,原因为: %v", errThree.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		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) {

	////开事务
	//tx := XTWriteDB().Begin()
	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0

	deliver_number = goods.Count

	// 根据先进先出原则，查询最先入库的批次，进行出库
	warehouse, err := FindFirstWarehousingInfoByGoodId(goods.GoodId, goods.ID, goods.StorehouseId)

	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:                   warehouse.PackingPrice,
			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)
		fmt.Println(errThree)
		//if errThree != nil {
		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}

		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:                   warehouse.PackingPrice,
			LicenseNumber:           goods.LicenseNumber,
			ConsumableType:          2,
			IsCheck:                 1,
			StorehouseId:            goods.StorehouseId,
		}
		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 {
		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}

		fmt.Println(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 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
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//查询默认仓库
	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)

	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:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Price:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			RetailPrice:             drug_price,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number, //出最小单位
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}

		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:                   warehouse.RetailPrice,
			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,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}

		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:                   deliver_number,
			CountUnit:               drup.MinUnit,
			WarehouseInfoId:         warehouse.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

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

		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber

		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
		} else {

			if minNumber > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			}

			if minNumber == 0 && maxNumber != 1 {
				if warehouse.StockMinNumber > 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				}

			}
		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number

				//if warehouse.StockMinNumber == 0 {
				//  warehouse.StockMaxNumber = stock_max_number
				//}
			}

		}

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

		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:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			Count:                   deliver_number,
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}
		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}

		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,
			WarehouseInfoId:         warehouse.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

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

		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,
			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			StorehouseId:      storeConfig.DrugStorehouseOut,
			IsCheck:           1,
		}
		//扣减库存
		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:                   warehouse.RetailPrice,
			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,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}

		CreateDrugFlowOne(drugflow)

		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		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
	}

	fmt.Println(min_price)
	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物
	storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}
	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	//查找药品信息

	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:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Price:                   warehouse.RetailPrice,
			CountUnit:               drup.MinUnit,
			RetailPrice:             warehouse.RetailPrice,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   deliver_number,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}

		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:                   warehouse.RetailPrice,
			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,
			SystemTime:              advice.RecordDate,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}

		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:                   deliver_number,
			CountUnit:               drup.MinUnit,
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		errTwo := AddSigleDrugAutoReduceRecordInfo(details)
		if errTwo != nil {
			return errTwo
		}

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

		var maxNumber int64 = 0
		var minNumber int64 = 0
		//var stock_max_number int64 = 0
		//stock_max_number = warehouse.StockMaxNumber

		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber

		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
		} else {

			if minNumber > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
			}

			if minNumber == 0 && maxNumber != 1 {
				if warehouse.StockMinNumber > 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				}

			}
		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number

				//if warehouse.StockMinNumber == 0 {
				//  warehouse.StockMaxNumber = stock_max_number
				//}
			}

		}

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

		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:                   warehouse.RetailPrice,
			RetailPrice:             warehouse.RetailPrice,
			ProductDate:             warehouse.ProductDate,
			ExpiryDate:              warehouse.ExpiryDate,
			PatientId:               advice.PatientId,
			WarehouseInfoId:         warehouse.ID,
			Count:                   stock_number,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
			IsCheck:                 1,
		}

		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:                   warehouse.RetailPrice,
			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,
			SystemTime:              advice.RecordDate,
			WarehousingDetailId:     warehouse.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}

		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,
			WarehouseInfoId:         warehouse.ID,
			AdviceId:                advice.ID,
			StorehouseId:            storeConfig.DrugStorehouseOut,
		}
		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.RetailPrice,
			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,
			SupplyWarehouseId: warehouse.SupplyWarehouseId,
			StorehouseId:      storeConfig.DrugStorehouseOut,
			IsCheck:           1,
		}
		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
}

// 药品出库 递归方式
func HisAuToReduce(orgID int64, prescribingNumber float64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.HisDoctorAdviceInfo) (err error) {

	//查询最后一次出库数据
	drugInfo, _ := GetDrugWarehouseOutInfoIsExit(advice.DrugId, advice.PatientId, advice.RecordDate)

	prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64)
	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
	var count_number int64
	var device_number int64
	if advice.PrescribingNumberUnit == drup.MaxUnit {
		device_number = count * drup.MinNumber
	}
	if advice.PrescribingNumberUnit == drup.MinUnit {
		device_number = count
	}

	if drugInfo.CountUnit == drup.MaxUnit {
		count_number = drugInfo.Count * drup.MinNumber
	}
	if drugInfo.CountUnit == drup.MinUnit {
		count_number = drugInfo.Count
	}

	//  比较数据大小
	//如果当期医嘱数量小于最后一次出库则退库
	if device_number < count_number {
		var cha_number int64
		var maxNumber int64
		var minNumber int64
		cha_number = count_number - device_number
		maxNumber = cha_number / drup.MinNumber
		minNumber = cha_number % drup.MinNumber
		//更改库存
		ModifyDrugWarehouse(drugInfo.WarehouseInfoId, maxNumber, minNumber)

		//修改出库表
		info := models.DrugWarehouseOutInfo{
			Count:     device_number,
			CountUnit: advice.PrescribingNumberUnit,
		}

		ModifyDrugWarehouseOutInfo(info, advice.DrugId, advice.PatientId, advice.RecordDate)

		//修改自动出库表
		detail := models.DrugAutomaticReduceDetail{
			Count:     device_number,
			CountUnit: advice.PrescribingNumberUnit,
		}
		ModifyAutoMaticReduce(detail, advice.PatientId, advice.RecordDate, advice.DrugId)
		//修改流水
		flow := models.DrugFlow{
			Count:   device_number,
			MaxUnit: drup.MinUnit,
		}
		ModifyDrugFlow(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId)

	}

	//如果当期医嘱数量大于最后一次出库则需要出库
	if device_number > count_number {
		var cha_number int64
		cha_number = device_number - count_number

		// 根据先进先出原则，查询最先入库的批次，进行出库

		storeConfig, _ := GetAllStoreHouseConfig(advice.UserOrgId)
		lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
		if lastWarehouse.StockMinNumber >= drup.MinNumber {
			var stockMax int64
			var stockMin int64
			stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
			stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
			ChangeMaxNumber(lastWarehouse.ID, stockMax)
			UpdateMinNumber(lastWarehouse.ID, stockMin)
		}
		warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
		//查找药品信息
		//baseInfo, _ := FindBaseDrugLibRecord(advice.UserOrgId, advice.DrugId)
		if err != nil {
			return err
		}

		// 将该批次的剩余库存数量转换为拆零数量
		var stock_number int64
		var maxNumber int64
		var minNumber int64
		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber

		//如果库存数量大于出库数据,正常出库
		if stock_number >= cha_number {
			//扣减库存
			maxNumber = cha_number / drup.MinNumber
			minNumber = cha_number % drup.MinNumber

			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
				minNumber = maxNumber
			}

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

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
			if warehouse.StockMaxNumber < 0 {
				warehouse.StockMaxNumber = 0
			}

			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)

			if errThree != nil {
				return errThree
			}

			//修改出库表
			info := models.DrugWarehouseOutInfo{
				Count:     device_number,
				CountUnit: advice.PrescribingNumberUnit,
			}
			ModifyDrugWarehouseOutInfoOne(info, advice.DrugId, advice.PatientId, advice.RecordDate, warehouse.ID)
			//修改自动出库表
			detail := models.DrugAutomaticReduceDetail{
				Count:     device_number,
				CountUnit: advice.PrescribingNumberUnit,
			}
			ModifyAutoMaticReduceOne(detail, advice.PatientId, advice.RecordDate, advice.DrugId, warehouse.ID)
			//修改流水
			flow := models.DrugFlow{
				Count:   device_number,
				MaxUnit: advice.PrescribingNumberUnit,
			}
			ModifyDrugFlowOne(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId, warehouse.ID)
		}
		//如果库存数量小于出库数据,则需要出库到下一个批次
		if stock_number < cha_number {

			//修改出库表
			info := models.DrugWarehouseOutInfo{
				Count:     cha_number,
				CountUnit: advice.PrescribingNumberUnit,
			}
			ModifyDrugWarehouseOutInfoOne(info, advice.DrugId, advice.PatientId, advice.RecordDate, warehouse.ID)
			//修改自动出库表
			detail := models.DrugAutomaticReduceDetail{
				Count:     cha_number,
				CountUnit: advice.PrescribingNumberUnit,
			}
			ModifyAutoMaticReduceOne(detail, advice.PatientId, advice.RecordDate, advice.DrugId, warehouse.ID)
			//修改流水
			flow := models.DrugFlow{
				Count:   cha_number,
				MaxUnit: advice.PrescribingNumberUnit,
			}
			ModifyDrugFlowOne(flow, drugInfo.WarehouseOutOrderNumber, advice.DrugId, advice.PatientId, warehouse.ID)

			druginfo := &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,
				StorehouseId:      storeConfig.DrugStorehouseOut,
				IsCheck:           1,
			}
			errThree := UpDateDrugWarehouseInfoByStock(druginfo)
			if errThree != nil {
				return errThree
			}

			// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
			prescribingNumber_two_temp := cha_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
}

//采购管理耗材出库逻辑
func ConsumablesDeliveryNight(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64, creator int64, warehouse_out_id int64, cancel_out_id int64) (err error) {

	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0

	deliver_number = goods.Count

	// 根据先进先出原则，查询最先入库的批次，进行出库
	houseConfig, _ := GetAllStoreHouseConfig(orgID)
	// 如果没有对应的库存，则报错
	warehouse, err := FindFirstWarehousingInfoByStockNight(goods.GoodId, goods.GoodTypeId, warehouse_out_id, goods.IsSource, houseConfig.StorehouseOutInfo)
	if err != nil {

		return err
	}

	stock_number = warehouse.StockCount

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

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			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,
			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			StorehouseId:            warehouse.StorehouseId,
			IsCheck:                 1,
		}
		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:          goods.WarehouseOutId,
			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:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseOut.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
		}

		//创建出库流水
		CreateStockFlowOne(stockFlow)

		maxNumber = goods.Count

		if warehouse.StockCount < maxNumber {
			return errors.New("库存数量不足")
		}

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

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		//出库数量增加
		AddGoodSumOutCount(houseConfig.StorehouseOutInfo, warehouse.GoodId, warehouse.OrgId, goods.Count)
		ModifyGoodReduceInformationSix(warehouse.GoodId, maxNumber, warehouse.OrgId, warehouse.PackingPrice)

		if errThree != nil {
			return errThree
		}

	} else {

		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			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:                   warehouse.PackingPrice,
			LicenseNumber:           goods.LicenseNumber,
			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			StorehouseId:            warehouse.StorehouseId,
			IsCheck:                 1,
		}
		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:                   stock_number,
			UserOrgId:               goods.OrgId,
			PatientId:               0,
			SystemTime:              record_time,
			ConsumableType:          2,
			IsSys:                   0,
			WarehousingOrder:        "",
			WarehouseOutId:          goods.WarehouseOutId,
			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:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyCancelOutId:       warehouseOut.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseOut.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
		}

		//创建出库明细
		CreateStockFlowOne(stockFlow)
		// 出库完成后，要将该批次库存清零
		ModifyGoodReduceInformationSix(warehouse.GoodId, warehouse.StockCount, warehouse.OrgId, warehouse.PackingPrice)
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}
		//出库数量增加
		AddGoodSumOutCount(houseConfig.StorehouseOutInfo, warehouse.GoodId, warehouse.OrgId, warehouse.StockCount)
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		goods.Count = deliver_number - stock_number

		ConsumablesDeliveryNight(orgID, record_time, goods, warehouseOut, count, creator, warehouse_out_id, cancel_out_id)

	}
	return nil
}

func FindFirstWarehousingInfoByStockNight(good_id int64, good_type_id int64, warehouse_out_id int64, is_source int64, storehouse_id int64) (info models.WarehousingInfo, err error) {

	if is_source == 1 {
		err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND good_type_id = ? AND status = 1 and stock_count > 0 and supply_warehouse_id = ? and storehouse_id = ?", good_id, good_type_id, warehouse_out_id, storehouse_id).Order("ctime").First(&info).Error

	}
	if is_source == 2 || is_source == 0 {
		err = readDb.Model(&models.WarehousingInfo{}).Where("good_id = ? AND good_type_id = ? AND status = 1 and stock_count > 0 and storehouse_id = ?", good_id, good_type_id, storehouse_id).Order("ctime").First(&info).Error
	}
	return info, err
}

// 药品出库 递归方式
func AutoDrugDeliverInfoNight(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo, warehouse_out_id int64, cancel_out_id int64) (err error) {

	houseConfig, _ := GetAllStoreHouseConfig(orgID)
	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0
	var retail_price float64
	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
		formatInt := strconv.FormatInt(prescribingNumber, 10)
		floatcount, _ := strconv.ParseFloat(formatInt, 64)
		retail_price = floatcount * advice.Price
	} else {
		deliver_number = prescribingNumber
		formatInt := strconv.FormatInt(prescribingNumber, 10)
		floatcount, _ := strconv.ParseFloat(formatInt, 64)
		retail_price = floatcount * advice.Price
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, houseConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByIDSix(advice.DrugId, warehouse_out_id, advice.IsSource, houseConfig.DrugStorehouseOut)

	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:          advice.WarehouseOutId,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  advice.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.SysRecordTime,
			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,
			AdviceId:                advice.ID,
			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			IsCheck:                 1,
		}

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

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          advice.WarehouseOutId,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   deliver_number,
			Price:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			SystemTime:              advice.SysRecordTime,
			StorehouseId:            warehouse.StorehouseId,
			WarehousingDetailId:     warehouse.ID,
			WarehousingId:           warehouse.ID,
			RetailPrice:             retail_price,
			LastPrice:               warehouse.Price,
		}

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

		if warehouse.StockMaxNumber < maxNumber {

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}

		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("库存数量不足")
		}
		if warehouse.StockMaxNumber == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			warehouse.StockMinNumber = 0
		}

		if warehouse.StockMaxNumber > 0 {
			var sum_count int64
			sum_count = maxNumber * drup.MinNumber
			ModifyDrugReduceInformationSix(warehouse.DrugId, sum_count, warehouse.OrgId, warehouse.RetailPrice)
			//出库数量增加
			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, sum_count, warehouse.OrgId, warehouse.DrugId)
		}

		if warehouse.StockMinNumber > 0 {
			ModifyDrugReduceInformationSix(warehouse.DrugId, minNumber, warehouse.OrgId, warehouse.RetailPrice)
			//出库数量增加
			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, minNumber, warehouse.OrgId, warehouse.DrugId)
		}

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		return nil
	} else {
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          advice.WarehouseOutId,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  advice.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.SysRecordTime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   advice.Price,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = stock_number

		//warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          advice.WarehouseOutId,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   stock_number,
			Price:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyCancelOutId:       warehouseout.SupplyCancelOutId,
			SupplyWarehouseId:       warehouseout.SupplyWarehouseId,
			SystemTime:              advice.SysRecordTime,
			StorehouseId:            warehouse.StorehouseId,
			WarehousingDetailId:     warehouse.ID,
			WarehousingId:           warehouse.ID,
			RetailPrice:             retail_price,
			LastPrice:               warehouse.Price,
		}
		CreateDrugFlowOne(drugflow)
		if warehouse.StockMaxNumber > 0 {
			var sum_count int64
			sum_count = warehouse.StockMaxNumber * drup.MinNumber
			ModifyDrugReduceInformationSix(warehouse.DrugId, sum_count, warehouse.OrgId, warehouse.RetailPrice)
			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, sum_count, warehouse.OrgId, warehouse.DrugId)
		}

		if warehouse.StockMinNumber > 0 {
			ModifyDrugReduceInformationSix(warehouse.DrugId, warehouse.StockMinNumber, warehouse.OrgId, warehouse.RetailPrice)
			AddDrugSumOutCount(houseConfig.DrugStorehouseOut, warehouse.StockMinNumber, warehouse.OrgId, warehouse.DrugId)
		}

		// 出库完成后，要将该批次库存清零
		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

		AutoDrugDeliverInfoNight(orgID, prescribingNumber_two_temp, warehouseout, drup, advice, warehouse_out_id, cancel_out_id)
	}

	return
}

//调拨出库逻辑
func ConsumablesDeliveryTwelve(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64, creator int64, warehouseInfo *models.WarehousingInfo) (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, goods.StorehouseId)
	if err != nil {

		return err
	}

	stock_number = warehouse.StockCount

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

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  goods.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           record_time,
			GoodTypeId:              warehouse.GoodTypeId,
			GoodId:                  warehouse.GoodId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			Price:                   warehouse.PackingPrice,
			LicenseNumber:           warehouse.LicenseNumber,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			IsCheck:                 1,
		}

		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:          12,
			IsSys:                   goods.IsSys,
			WarehousingOrder:        "",
			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
		}

		//创建出库流水
		CreateStockFlowOne(stockFlow)

		maxNumber = goods.Count

		if warehouse.StockCount < maxNumber {
			return errors.New("库存数量不足")
		}

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

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)

		//入库
		warehouseInfo := &models.WarehousingInfo{
			WarehousingOrder:      warehouseInfo.WarehousingOrder,
			WarehousingId:         warehouseInfo.WarehousingId,
			GoodId:                warehouse.GoodId,
			Number:                warehouse.Number,
			GoodTypeId:            warehouse.GoodTypeId,
			ProductDate:           warehouse.ProductDate,
			ExpiryDate:            warehouse.ExpiryDate,
			WarehousingCount:      goods.Count,
			Price:                 warehouse.Price,
			TotalPrice:            0,
			Status:                1,
			Ctime:                 warehouse.Ctime,
			Remark:                goods.Remark,
			OrgId:                 warehouse.OrgId,
			Type:                  1,
			Manufacturer:          warehouse.Manufacturer,
			StockCount:            goods.Count,
			Dealer:                warehouse.Dealer,
			LicenseNumber:         "",
			PackingPrice:          warehouse.PackingPrice,
			StorehouseId:          warehouseInfo.StorehouseId,
			SecondWarehouseInfoId: warehouseInfo.SecondWarehouseInfoId,
			IsCheck:               1,
		}

		AddWarehosingInfo(warehouseInfo)

		stockInfoFlow := models.VmStockFlow{
			WarehousingId:           warehouseInfo.WarehousingId,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           goods.LicenseNumber,
			Count:                   goods.Count,
			UserOrgId:               goods.OrgId,
			PatientId:               goods.PatientId,
			SystemTime:              record_time,
			ConsumableType:          13,
			IsSys:                   goods.IsSys,
			WarehousingOrder:        warehouseInfo.WarehousingOrder,
			WarehouseOutId:          0,
			WarehouseOutOrderNumber: "",
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.Price,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouseInfo.StorehouseId,
			SecondWarehouseInfoId:   warehouseInfo.SecondWarehouseInfoId,
		}

		//创建入库流水
		CreateStockFlowOne(stockInfoFlow)

		if errThree != nil {
			return errThree
		}

	} else {

		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  goods.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           record_time,
			GoodTypeId:              warehouse.GoodTypeId,
			GoodId:                  warehouse.GoodId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			Price:                   warehouse.PackingPrice,
			LicenseNumber:           warehouse.LicenseNumber,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = warehouse.StockCount

		//查询是否已经生成出库单
		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:                   warehouse.StockCount,
			UserOrgId:               goods.OrgId,
			PatientId:               0,
			SystemTime:              record_time,
			ConsumableType:          12,
			IsSys:                   0,
			WarehousingOrder:        "",
			WarehouseOutOrderNumber: goods.WarehouseOutOrderNumber,
			WarehouseOutId:          goods.WarehouseOutId,
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.PackingPrice,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			SecondWarehouseInfoId:   goods.SecondWarehouseInfoId,
		}

		//创建出库明细
		CreateStockFlowOne(stockFlow)

		//入库
		warehouseInfo := &models.WarehousingInfo{
			WarehousingOrder:      warehouseInfo.WarehousingOrder,
			WarehousingId:         warehouseInfo.WarehousingId,
			GoodId:                warehouse.GoodId,
			Number:                warehouse.Number,
			GoodTypeId:            warehouse.GoodTypeId,
			ProductDate:           warehouse.ProductDate,
			ExpiryDate:            warehouse.ExpiryDate,
			WarehousingCount:      warehouse.StockCount,
			Price:                 warehouse.Price,
			TotalPrice:            0,
			Status:                1,
			Ctime:                 warehouse.Ctime,
			Remark:                goods.Remark,
			OrgId:                 warehouse.OrgId,
			Type:                  1,
			Manufacturer:          warehouse.Manufacturer,
			StockCount:            warehouse.StockCount,
			Dealer:                warehouse.Dealer,
			LicenseNumber:         "",
			PackingPrice:          warehouse.PackingPrice,
			StorehouseId:          warehouseInfo.StorehouseId,
			SecondWarehouseInfoId: warehouseInfo.SecondWarehouseInfoId,
			IsCheck:               1,
		}

		AddWarehosingInfo(warehouseInfo)

		stockInfoFlow := models.VmStockFlow{
			WarehousingId:           warehouseInfo.WarehousingId,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           goods.LicenseNumber,
			Count:                   warehouse.StockCount,
			UserOrgId:               goods.OrgId,
			PatientId:               goods.PatientId,
			SystemTime:              record_time,
			ConsumableType:          13,
			IsSys:                   goods.IsSys,
			WarehousingOrder:        warehouseInfo.WarehousingOrder,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.Price,
			WarehousingDetailId:     0,
			WarehouseOutDetailId:    warehouseOutInfo.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouseInfo.StorehouseId,
			SecondWarehouseInfoId:   warehouseInfo.SecondWarehouseInfoId,
		}

		//创建出库流水
		CreateStockFlowOne(stockInfoFlow)
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		goods.Count = deliver_number - stock_number

		ConsumablesDeliveryTwelve(orgID, record_time, goods, warehouseOut, count, creator, warehouseInfo)

	}
	return nil
}

func AddWarehosingInfo(info *models.WarehousingInfo) error {

	err = XTWriteDB().Create(&info).Error
	return err
}

// 药品出库 递归方式
func AutoDrugDeliverInfoTwelve(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo, drugWarehouse *models.DrugWarehouseInfo) (err error) {

	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0

	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
	} else {
		deliver_number = prescribingNumber
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物
	storeConfig, _ := GetAllStoreHouseConfig(orgID)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)

	if err != nil {

		return err
	}

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

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

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

		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			WarehouseOutId:          advice.WarehouseOutId,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  advice.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   12,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   deliver_number,
			RetailPrice:             warehouse.RetailPrice,
			Price:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			IsCheck:                 1,
		}

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

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			WarehouseOutId:          advice.WarehouseOutId,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			Count:                   deliver_number,
			Price:                   warehouse.RetailPrice,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               advice.OrgId,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          12,
			IsEdit:                  1,
			Creator:                 0,
			IsSys:                   12,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			WarehousingDetailId:     warehouse.ID,
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		if advice.CountUnit == drup.MinUnit {
			maxNumber = prescribingNumber / drup.MinNumber
			minNumber = prescribingNumber % drup.MinNumber
			if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
				minNumber = maxNumber
			}
		} 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 == 1 && warehouse.StockMinNumber == 1 && drup.MaxUnit == drup.MinUnit {
			warehouse.StockMinNumber = 0
		}

		if warehouse.StockMaxNumber < 0 {
			return errors.New("库存数量不足")
		}

		////扣减库存
		//if(warehouse.StockMaxNumber > 0){
		//  var sum_count int64
		//  sum_count = maxNumber * drup.MinNumber
		//  ModifyDrugReduceInformationSix(warehouse.DrugId,sum_count,warehouse.OrgId,warehouse.RetailPrice)
		//}
		//if(warehouse.StockMinNumber > 0){
		//  var sum_count int64
		//  sum_count = minNumber
		//  ModifyDrugReduceInformationSix(warehouse.DrugId,sum_count,warehouse.OrgId,warehouse.RetailPrice)
		//}

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}

		//入库
		drugInfo := models.DrugWarehouseInfo{
			WarehousingOrder:      drugWarehouse.WarehousingOrder,
			WarehousingId:         drugWarehouse.WarehousingId,
			DrugId:                warehouse.DrugId,
			Number:                warehouse.Number,
			ProductDate:           warehouse.ProductDate,
			ExpiryDate:            warehouse.ExpiryDate,
			WarehousingCount:      deliver_number,
			Price:                 warehouse.RetailPrice,
			TotalPrice:            warehouse.TotalPrice,
			Status:                1,
			Ctime:                 warehouse.Ctime,
			Remark:                "",
			OrgId:                 warehouse.OrgId,
			Type:                  13,
			Manufacturer:          warehouse.Manufacturer,
			Dealer:                warehouse.Dealer,
			StockMaxNumber:        0,
			StockMinNumber:        deliver_number,
			BatchNumber:           warehouse.BatchNumber,
			MaxUnit:               drup.MinUnit,
			MinUnit:               drup.MinUnit,
			RetailPrice:           warehouse.RetailPrice,
			StorehouseId:          drugWarehouse.StorehouseId,
			SecondWarehouseInfoId: drugWarehouse.SecondWarehouseInfoId,
			IsCheck:               1,
		}

		CreateDrugWarehouseInfo(drugInfo)

		flow := models.DrugFlow{
			WarehousingId:           drugWarehouse.WarehousingId,
			DrugId:                  warehouse.DrugId,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   deliver_number,
			UserOrgId:               warehouse.OrgId,
			PatientId:               0,
			SystemTime:              0,
			ConsumableType:          13,
			IsSys:                   13,
			WarehousingOrder:        drugWarehouse.WarehousingOrder,
			WarehouseOutId:          0,
			WarehouseOutOrderNumber: "",
			IsEdit:                  0,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 0,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.RetailPrice,
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    0,
			CancelOutDetailId:       0,
			ExpireDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			MaxUnit:                 drup.MinUnit,
			MinUnit:                 drup.MinUnit,
			StockMaxNumber:          0,
			StockMinNumber:          deliver_number,
			StorehouseId:            drugWarehouse.StorehouseId,
			SecondWarehouseInfoId:   drugWarehouse.SecondWarehouseInfoId,
		}

		CreateDrugFlowOne(flow)

		return nil
	} else {
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			WarehouseOutId:          advice.WarehouseOutId,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  advice.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            advice.Manufacturer,
			Dealer:                  warehouse.Dealer,
			IsSys:                   12,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			IsCheck:                 1,
		}
		warehouseOutInfo.Count = stock_number

		//warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutOrderNumber: advice.WarehouseOutOrderNumber,
			WarehouseOutId:          advice.WarehouseOutId,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			Count:                   stock_number,
			Price:                   warehouse.RetailPrice,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			UserOrgId:               advice.OrgId,
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			BatchNumber:             warehouse.BatchNumber,
			MaxUnit:                 drup.MinUnit,
			ConsumableType:          12,
			IsEdit:                  1,
			Creator:                 0,
			IsSys:                   12,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			SecondWarehouseInfoId:   advice.SecondWarehouseInfoId,
			WarehousingDetailId:     warehouse.ID,
		}
		CreateDrugFlowOne(drugflow)
		// 出库完成后，要将该批次库存清零

		//入库
		drugInfo := models.DrugWarehouseInfo{
			WarehousingOrder:      drugWarehouse.WarehousingOrder,
			WarehousingId:         drugWarehouse.WarehousingId,
			DrugId:                warehouse.DrugId,
			Number:                warehouse.Number,
			ProductDate:           warehouse.ProductDate,
			ExpiryDate:            warehouse.ExpiryDate,
			WarehousingCount:      stock_number,
			Price:                 warehouse.RetailPrice,
			TotalPrice:            warehouse.TotalPrice,
			Status:                1,
			Ctime:                 warehouse.Ctime,
			Remark:                "",
			OrgId:                 warehouse.OrgId,
			Type:                  13,
			Manufacturer:          warehouse.Manufacturer,
			Dealer:                warehouse.Dealer,
			StockMaxNumber:        0,
			StockMinNumber:        stock_number,
			RetailTotalPrice:      0,
			BatchNumber:           warehouse.BatchNumber,
			MaxUnit:               drup.MinUnit,
			MinUnit:               drup.MinUnit,
			RetailPrice:           warehouse.RetailPrice,
			StorehouseId:          drugWarehouse.StorehouseId,
			SecondWarehouseInfoId: drugWarehouse.SecondWarehouseInfoId,
		}

		CreateDrugWarehouseInfo(drugInfo)

		flow := models.DrugFlow{
			WarehousingId:           drugWarehouse.WarehousingId,
			DrugId:                  warehouse.DrugId,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			UserOrgId:               warehouse.OrgId,
			PatientId:               0,
			SystemTime:              0,
			ConsumableType:          13,
			IsSys:                   13,
			WarehousingOrder:        drugWarehouse.WarehousingOrder,
			WarehouseOutId:          0,
			WarehouseOutOrderNumber: "",
			IsEdit:                  0,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 0,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.RetailPrice,
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    0,
			CancelOutDetailId:       0,
			ExpireDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			MaxUnit:                 drup.MinUnit,
			MinUnit:                 drup.MinUnit,
			StockMaxNumber:          0,
			StockMinNumber:          stock_number,
			StorehouseId:            drugWarehouse.StorehouseId,
			SecondWarehouseInfoId:   drugWarehouse.SecondWarehouseInfoId,
		}

		CreateDrugFlowOne(flow)

		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

		AutoDrugDeliverInfoTwelve(orgID, prescribingNumber_two_temp, warehouseout, drup, advice, drugWarehouse)
	}

	return
}

// 药品手动出库 递归方式
func AutoDrugDeliverInfoTwenty(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

	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
	} else {
		deliver_number = prescribingNumber
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)

	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:                  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:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			IsCheck:                 1,
		}

		if warehouse.RetailPrice == 0 {
			warehouseOutInfo.Price = advice.Price
		}

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

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		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:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
		}
		if warehouse.RetailPrice == 0 {
			drugflow.Price = advice.Price
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		//var stock_max_number int64 = 0
		//stock_max_number = warehouse.StockMaxNumber

		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber

		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
		} else {
			if minNumber > 0 {
				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				} else {
					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
				}
			}

			if minNumber == 0 && maxNumber != 1 {
				if warehouse.StockMinNumber > 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				}

			}

		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number

				//if warehouse.StockMinNumber == 0 {
				//  warehouse.StockMaxNumber = stock_max_number
				//}
			}

		}

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

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errThree
		}

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)

		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:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   warehouse.RetailPrice,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			IsCheck:                 1,
		}
		if warehouse.RetailPrice == 0 {
			warehouseOutInfo.Price = advice.Price
		}
		warehouseOutInfo.Count = stock_number

		//warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   stock_number,
			Price:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
		}
		if warehouse.RetailPrice == 0 {
			drugflow.Price = advice.Price
		}
		CreateDrugFlowOne(drugflow)
		// 出库完成后，要将该批次库存清零
		//扣减库存

		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		advice.CountUnit = drup.MinUnit

		AutoDrugDeliverInfoTwenty(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
	}

	return
}

// 药品手动出库 递归方式
func AutoDrugDeliverInfoTwentyOne(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {
	//开事务
	//tx := XTWriteDB().Begin()
	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0

	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
	} else {
		deliver_number = prescribingNumber
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	//开启事物
	storeConfig, _ := GetAllStoreHouseConfig(orgID)
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, storeConfig.DrugStorehouseOut)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}
	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)

	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:                  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,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
			IsCheck:                 1,
		}

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

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
		}
		if warehouse.RetailPrice == 0 {
			drugflow.Price = advice.Price
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		//var stock_max_number int64 = 0
		//stock_max_number = warehouse.StockMaxNumber

		maxNumber = deliver_number / drup.MinNumber
		minNumber = deliver_number % drup.MinNumber

		if warehouse.StockMaxNumber == 0 && drup.MaxUnit == drup.MinUnit {
			minNumber = maxNumber
		}

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

		warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
		} else {
			if minNumber > 0 {
				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				} else {
					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
				}
			}

			if minNumber == 0 && maxNumber != 1 {
				if warehouse.StockMinNumber > 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				}

			}

		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) > 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number

				//if warehouse.StockMinNumber == 0 {
				//  warehouse.StockMaxNumber = stock_max_number
				//}
			}

		}

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

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		fmt.Println(errThree)
		//if errThree != nil {
		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)

		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:                  warehouse.Dealer,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			Number:                  warehouse.Number,
			BatchNumber:             warehouse.BatchNumber,
			Count:                   stock_number,
			RetailPrice:             advice.RetailPrice,
			Price:                   advice.Price,
			WarehouseInfoId:         warehouse.ID,
			CountUnit:               drup.MinUnit,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
			IsCheck:                 1,
		}

		warehouseOutInfo.Count = stock_number

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)

		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   stock_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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
		}

		CreateDrugFlowOne(drugflow)
		// 出库完成后，要将该批次库存清零
		//扣减库存

		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		fmt.Println(errThree)
		//if errThree != nil {
		//	utils.ErrorLog("事务失败,原因为: %v", err.Error())
		//	tx.Rollback()
		//} else {
		//	tx.Commit()
		//}

		//查询默认仓库
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		//查询默认仓库剩余多少库存
		list, _ := GetDrugSumCountByStorehouseId(houseConfig.DrugStorehouseOut, orgID, warehouse.DrugId)
		var sum_count int64
		var sum_in_count int64
		for _, it := range list {
			baseDrug, _ := GetBaseDrugMedical(it.DrugId)
			if it.MaxUnit == baseDrug.MaxUnit {
				it.StockMaxNumber = it.StockMaxNumber * baseDrug.MinNumber
				it.WarehousingCount = it.WarehousingCount * baseDrug.MinNumber
				sum_count += it.StockMaxNumber + it.StockMinNumber
				sum_in_count += it.WarehousingCount
			}
		}
		UpdateMedicalSumCount(warehouse.DrugId, sum_count, sum_in_count, orgID)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		advice.CountUnit = drup.MinUnit

		AutoDrugDeliverInfoTwentyOne(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
	}

	return
}

//耗材手动出库
func ConsumablesDeliveryThirty(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

	// 根据先进先出原则，查询最先入库的批次，进行出库

	// 如果没有对应的库存，则报错
	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId, goods.StorehouseId)
	if err != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      goods.OrgId,
			Errcode:        "查询库存信息报错",
			GoodId:         goods.GoodId,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creator,
			BatchNumberId:  warehouse.ID,
			WarehouseOutId: 0,
		}
		CreateGoodErrcode(goodErrcode)
		return err
	}

	stock_number = warehouse.StockCount

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		maxNumber = goods.Count
		warehouse.StockCount = warehouse.StockCount - maxNumber
		warehouse.Mtime = time.Now().Unix()

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "扣减库存失败",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseInfotId: warehouse.ID,
		}
		//添加入库单详情ID
		errOne := UpdatedSigleWarehouseOutInfo(goods.ID, warehouseOutInfo)
		if errOne != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "添加入库单详情ID",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			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:        warehouse.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:                   warehouse.PackingPrice, //零售价
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    goods.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price, //进货价
			StockCount:              goods.StockCount,
			BatchNumberCount:        warehouse.StockCount - goods.Count,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          goods.RegisterNumber,
		}
		//创建出库流水
		errflow := CreateStockFlowOne(stockFlow)
		if errflow != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "创建流水报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//添加入库ID
		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, goods.OrgId, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//更新出库数量
		errsumcode := ModifyGoodSumCount(goods.StorehouseId, goods.Count, goods.OrgId, goods.GoodId)
		if errsumcode != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "更新出库数量报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		if warehouse.StockCount < maxNumber {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "出库接口库存数量不足",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errors.New("库存数量不足")

		}

		return nil
	} else {
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "扣减库存报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		stockFlow := models.VmStockFlow{
			WarehousingId:           warehouse.ID,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           goods.LicenseNumber,
			Count:                   stock_number,
			UserOrgId:               goods.OrgId,
			PatientId:               goods.PatientId,
			SystemTime:              record_time,
			ConsumableType:          2,
			IsSys:                   goods.IsSys,
			WarehousingOrder:        warehouse.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:                   warehouse.PackingPrice, //零售价
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    goods.ID,
			CancelOutDetailId:       0,
			ProductDate:             goods.ProductDate,
			ExpireDate:              goods.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             goods.AdminUserId,
			BuyPrice:                warehouse.Price, //进货价
			StockCount:              goods.StockCount,
			BatchNumberCount:        0,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          goods.RegisterNumber,
		}
		//创建出库流水
		errflow := CreateStockFlowOne(stockFlow)
		if errflow != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "创建出库流水报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, goods.OrgId, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//更新出库数量
		errcodecout := ModifyGoodSumCount(goods.StorehouseId, stock_number, goods.OrgId, goods.GoodId)

		if errcodecout != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.OrgId,
				Errcode:        "更新出库数量报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}
	}

	goods.Count = deliver_number - stock_number
	ConsumablesDeliveryThirty(orgID, record_time, goods, warehouseOut, count, creator)

	return nil
}

// 药品手动出库 递归方式
func AutoDrugDeliverInfoFourtyOne(orgID int64, prescribingNumber int64, warehouseout *models.DrugWarehouseOut, drup *models.BaseDrugLib, advice *models.DrugWarehouseOutInfo) (err error) {

	fmt.Println("出库数量", prescribingNumber)

	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0
	var retail_price float64
	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
		formatInt := strconv.FormatInt(prescribingNumber, 10)
		floatcount, _ := strconv.ParseFloat(formatInt, 64)
		retail_price = floatcount * advice.Price
	} else {
		deliver_number = prescribingNumber
		formatInt := strconv.FormatInt(prescribingNumber, 10)
		floatcount, _ := strconv.ParseFloat(formatInt, 64)
		retail_price = floatcount * advice.Price
	}

	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)
	if lastWarehouse.StockMinNumber >= drup.MinNumber {
		var stockMax int64
		var stockMin int64
		stockMax = lastWarehouse.StockMinNumber / drup.MinNumber
		stockMin = lastWarehouse.StockMinNumber % drup.MinNumber
		//fmt.Println("stockmax", stockMax)
		//fmt.Println("stockMin", stockMin)
		ChangeMaxNumber(lastWarehouse.ID, stockMax)
		UpdateMinNumber(lastWarehouse.ID, stockMin)
	}

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId, warehouseout.StorehouseId)

	if err != nil {

		return err
	}

	// 将该批次的剩余库存数量转换为拆零数量
	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	}
	if warehouse.MaxUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
		stock_number = warehouse.StockMaxNumber + warehouse.StockMinNumber
	}
	if warehouse.MaxUnit == drup.MaxUnit && drup.MaxUnit == drup.MinUnit {
		stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	}

	fmt.Println("stock_number", stock_number)
	fmt.Println("deliver_number", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {

		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		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 drup.MaxUnit != drup.MinUnit {
			if warehouse.StockMaxNumber < maxNumber && warehouse.StockMinNumber < minNumber {
				return errors.New("库存数量不足")
			}
		}

		if drup.MinUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
		}
		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		}
		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		}

		if warehouse.StockMaxNumber < 0 {
			warehouse.StockMaxNumber = 0
		}
		if warehouse.StockMinNumber < 0 {
			warehouse.StockMinNumber = 0
		}

		warehouse.Mtime = time.Now().Unix()

		if warehouse.StockMinNumber < minNumber {
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			if warehouse.MaxUnit != warehouse.MinUnit {
				warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			}

		} else {
			//fmt.Println("maxNumber23323323332322323w9", maxNumber)
			//fmt.Println("maxNumber23323323332322323w9", minNumber)
			if minNumber > 0 {
				if minNumber == 1 && maxNumber == 1 && drup.MaxUnit != drup.MinUnit {
					warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
				} else {
					if (warehouse.StockMinNumber - minNumber) >= 0 {
						warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
					}

				}
			}

			if minNumber == 0 && maxNumber != 1 {
				if warehouse.StockMinNumber > 0 {
					if (warehouse.StockMinNumber - deliver_number) >= 0 {
						warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
					}
				}
			}
		}

		if maxNumber == 1 && minNumber == 0 && drup.MaxUnit != drup.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) >= 0 {
				warehouse.StockMinNumber = warehouse.StockMinNumber - deliver_number
			}

		}

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

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)

		if errThree != nil {
			return errors.New("扣减库存失败")
		}

		//查询该药品剩余库存
		infolist, _ := FindDrugWarehouseInfoFlushCount(advice.DrugId, advice.OrgId)
		var over_count int64
		for _, its := range infolist {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			over_count += its.StockMaxNumber + its.StockMinNumber
		}

		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		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:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
			WarehousingDetailId:     warehouse.ID,
			OverCount:               over_count,
			RetailPrice:             retail_price, //手动出库出库价格
			WarehousingId:           warehouse.ID,
		}
		if warehouse.RetailPrice == 0 {
			drugflow.Price = advice.Price
		}

		CreateDrugFlowOne(drugflow)

		//更新出库id
		UpdateDrugWarehouseOutInfo(advice.ID, warehouse.ID, advice.OrgId, over_count)

		return nil

	} else {
		stock_number_int := strconv.FormatInt(stock_number, 10)
		stock_number_int_count, _ := strconv.ParseFloat(stock_number_int, 64)
		retail_price = stock_number_int_count * advice.Price
		//扣减库存
		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		//查询该药品剩余库存
		infolist, _ := FindDrugWarehouseInfoFlushCount(advice.DrugId, advice.OrgId)
		var over_count int64
		for _, its := range infolist {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			over_count += its.StockMaxNumber + its.StockMinNumber
		}
		drugWareInfo, _ := GetLastWarehouseOutInfoById(advice.DrugId)
		drugflow := models.DrugFlow{
			WarehouseOutId:          warehouseout.ID,
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			DrugId:                  advice.DrugId,
			Number:                  warehouse.Number,
			ProductDate:             advice.ProductDate,
			ExpireDate:              advice.ExpiryDate,
			Count:                   stock_number,
			Price:                   warehouse.RetailPrice,
			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,
			WarehouseOutDetailId:    drugWareInfo.ID,
			AdviceId:                advice.ID,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            advice.StorehouseId,
			AdminUserId:             advice.AdminUserId,
			LastPrice:               warehouse.Price,
			StockCount:              advice.StockCount,
			OverCount:               over_count,
			RetailPrice:             retail_price, //手动出库出库价格
			WarehousingId:           warehouse.ID,
			WarehousingDetailId:     warehouse.ID,
		}

		CreateDrugFlowOne(drugflow)
		//更新出库id
		UpdateDrugWarehouseOutInfo(advice.ID, warehouse.ID, advice.OrgId, over_count)
		// 出库完成后，要将该批次库存清零

		prescribingNumber_two_temp := deliver_number - stock_number

		advice.CountUnit = drup.MinUnit

		AutoDrugDeliverInfoFourtyOne(orgID, prescribingNumber_two_temp, warehouseout, drup, advice)
	}

	return
}

func UpdateDrugWarehouseOutInfo(id int64, warehouse_info_id int64, org_id int64, over_count int64) error {
	ut := XTWriteDB().Begin()
	err = ut.Model(&models.DrugWarehouseOutInfo{}).Where("id = ? and org_id = ? and status = 1", id, org_id).Update(map[string]interface{}{"warehouse_info_id": warehouse_info_id, "over_count": over_count}).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func UpdateGoodWarehouseOutById(id int64, warehouse_info_id int64, org_id int64, over_count int64) error {
	utx := XTWriteDB().Begin()
	err := utx.Model(models.WarehouseOutInfo{}).Where("id = ?  and org_id = ? and status = 1", id, org_id).Update(map[string]interface{}{"warehouse_info_id": warehouse_info_id, "over_count": over_count}).Error
	if err != nil {
		utx.Rollback()
		return err
	}
	utx.Commit()
	return err
}

func ChangeMaxNumber(id int64, count int64) error {

	err = XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).UpdateColumn("stock_max_number", gorm.Expr("stock_max_number + ?", count)).Error
	return err

}

func UpdateMinNumber(id int64, count int64) error {

	err := XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Update(map[string]interface{}{"stock_min_number": count}).Error
	return err
}

func FindLastDrugWarehouseOutInfo(orgid int64) (models.DrugWarehouseOutInfo, error) {
	info := models.DrugWarehouseOutInfo{}
	err := XTReadDB().Where("org_id = ? and status = 1", orgid).Last(&info).Error
	return info, err
}

func GetAllGoodSumCount(goodid int64, orgid int64) (info []*models.WarehousingInfo, err error) {

	err = XTReadDB().Where("good_id = ? and org_id = ? and is_check =1 and status= 1 and stock_count > 0", goodid, orgid).Find(&info).Error
	return info, err
}

func CreatedFlushInfo(info models.XtWarehouseFlushInfo) error {
	ut := writeDb.Begin()
	err := ut.Create(&info).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err

}

func FindDrugWarehouseInfoList(drugid int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and org_id = ? and status =1 and is_check =1  and (stock_max_number>0 or stock_min_number>0)", drugid, orgid).Find(&info).Error
	return info, err
}

func CreatedDrugFlushInfo(info models.XtDrugWarehouseFlushInfo) error {
	ut := writeDb.Begin()
	err := ut.Create(&info).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func UpdateWarehouseFlushInfo(warehouse_out_id int64, record_time int64, patient_id int64, batch_nubmer_id int64, good_id int64, sum_count int64, orgid int64) error {

	err := XTWriteDB().Model(&models.XtWarehouseFlushInfo{}).Where("warehouse_out_id = ? and system_time = ? and patient_id = ? and batch_number_id = ? and good_id = ? and user_org_id = ?", warehouse_out_id, record_time, patient_id, batch_nubmer_id, good_id, orgid).Update(map[string]interface{}{"flush_count": sum_count}).Error
	return err
}

func FindLastWarehouseOutInfo(orgId int64) (models.WarehouseOutInfo, error) {

	info := models.WarehouseOutInfo{}
	err := XTReadDB().Model(&info).Where("org_id = ? and status = 1", orgId).Find(&info).Error
	return info, err
}

func ModifyAddGoodInformation(count int64, id int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyReduceGoodInformation(count int64, id int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyAddCancelCount(count int64, id int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyReduceCancelCount(count int64, id int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.GoodInfo{}).Where("id = ? and status =1", id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyAddDrugInformation(id int64, count int64, orgid int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyReduceDrugInformation(id int64, count int64, orgid int64) error {

	ut := XTWriteDB().Begin()
	err = ut.Model(&models.BaseDrugLib{}).Where("id = ? and status = 1 and org_id = ?", id, orgid).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyAddCancelAddInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
	ut := XTWriteDB().Begin()
	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id = ?", id, orgid, storehouse_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyAddDrugOutReduceInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
	ut := XTWriteDB().Begin()
	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id  =?", id, orgid, storehouse_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyAddDrugOutAddInfomation(id int64, count int64, orgid int64, storehouse_id int64) error {
	ut := XTWriteDB().Begin()
	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id  =?", id, orgid, storehouse_id).UpdateColumn("sum_out_count", gorm.Expr("sum_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyDrugCancelWarehouseInfo(id int64, count int64, orgid int64, storehouse_id int64) error {
	ut := XTWriteDB().Begin()
	err = ut.Model(&models.XtDrugStockCount{}).Where("drug_id = ? and status = 1 and user_org_id = ? and storehouse_id = ?", id, orgid, storehouse_id).UpdateColumn("sum_cancel_count", gorm.Expr("sum_cancel_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func ModifyGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {

	ut := XTWriteDB().Begin()

	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}

	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_act_out_count", gorm.Expr("stock_act_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}

	ut.Commit()
	return err
}

func ModifyReduceGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {

	ut := XTWriteDB().Begin()

	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}

	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_act_out_count", gorm.Expr("stock_act_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}

	ut.Commit()
	return err
}

func ModifyAddGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64) error {
	ut := XTWriteDB().Begin()

	err = ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id  = ? and good_id =?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}

	ut.Commit()
	return err
}

func UpdateSumAddCancelCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {

	ut := XTWriteDB().Begin()
	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_cancel_count", gorm.Expr("stock_cancel_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func UpdateSumReduceCancelCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {

	ut := XTWriteDB().Begin()
	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_cancel_count", gorm.Expr("stock_cancel_count - ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func UpdateSumAddOutCount(user_org_id int64, good_id int64, storehouse_id int64, count int64) error {

	ut := XTWriteDB().Begin()
	err := ut.Model(&models.XtGoodStockCount{}).Where("storehouse_id = ? and status = 1 and user_org_id = ? and good_id = ?", storehouse_id, user_org_id, good_id).UpdateColumn("stock_out_count", gorm.Expr("stock_out_count + ?", count)).Error
	if err != nil {
		ut.Rollback()
		return err
	}
	ut.Commit()
	return err
}

func FindDrugWarehouseInfoFlushCount(drug_id int64, orgid int64) (info []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1", drug_id, orgid).Find(&info).Error
	return info, err
}

func FindDrugWarehouseInfoFlushCountByStorehouse(drug_id int64, orgid int64, storehouse_id int64) (info []*models.DrugWarehouseInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and org_id = ? and status = 1 and is_check = 1 and storehouse_id =?", drug_id, orgid, storehouse_id).Find(&info).Error
	return info, err
}

//结算出库
func HisSettleDrugsDelivery(orgID int64, creater int64, advice *models.HisDoctorAdviceInfo, order_id int64) (err error) {

	// 1.判断药品是否来自专用字典的药品库
	// 2.判断当天当前机构有没有创建出库单，没有则创建
	// 3.创建出库流程
	// 3.1 实现先进先出逻辑 由于药品执行后，不可以修改和删除，所以不考虑出库后的退库和修改出库数量等
	isHasWay := false
	record_time := int64(0)
	isHasWay = true
	record_time = advice.RecordDate

	if isHasWay {
		//判断当天当前机构有没有创建结算出库单，没有则创建
		out, err := FindDrugSettleStockOutByIsSys(orgID, 5, record_time)
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		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:                   5,
				StorehouseId:            houseConfig.DrugStorehouseOut,
				IsCheck:                 1,
				OrderId:                 order_id,
			}
			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

			HisSettleDrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice)

		} else {
			return errors.New("药品信息不存在")
		}

	}

	return
}

//耗材结算出库
func ConsumableSettleDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, creator int64, order_id int64) (err error) {

	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0
	fmt.Println("223323233233223233223233223woo", goods.Count)
	deliver_number = goods.Count

	// 根据先进先出原则，查询最先入库的批次，进行出库

	// 如果没有对应的库存，则报错
	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId, goods.StorehouseId)
	if err != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      goods.UserOrgId,
			Errcode:        "查询库存信息报错",
			GoodId:         goods.GoodId,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creator,
			BatchNumberId:  warehouse.ID,
			WarehouseOutId: 0,
		}
		CreateGoodErrcode(goodErrcode)
		return err
	}

	stock_number = warehouse.StockCount

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		maxNumber = goods.Count
		warehouse.StockCount = warehouse.StockCount - maxNumber
		warehouse.Mtime = time.Now().Unix()

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.UserOrgId,
				Errcode:        "扣减库存失败",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseInfotId: warehouse.ID,
		}
		//添加入库单详情ID
		errOne := UpdatedSigleWarehouseOutInfo(goods.ID, warehouseOutInfo)
		if errOne != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.UserOrgId,
				Errcode:        "添加入库单详情ID",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errOne
		}
		OutInfo := &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:                   5,
			SysRecordTime:           record_time,
			GoodTypeId:              goods.GoodTypeId,
			GoodId:                  goods.GoodId,
			PatientId:               patient_id,
			Number:                  warehouse.Number,
			LicenseNumber:           warehouse.LicenseNumber,
			Price:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
			OrderId:                 order_id,
		}
		fmt.Println("goods.count2323232233232233232322332322332", goods.Count)
		OutInfo.Count = goods.Count

		AddSigleWarehouseOutInfo(OutInfo)

		stockFlow := models.VmStockFlow{
			WarehousingId:           warehouse.ID,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           warehouse.LicenseNumber,
			Count:                   goods.Count,
			UserOrgId:               orgID,
			PatientId:               patient_id,
			SystemTime:              record_time,
			ConsumableType:          15,
			IsSys:                   5,
			WarehousingOrder:        warehouse.WarehousingOrder,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.PackingPrice, //零售价
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    goods.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             creator,
			BuyPrice:                warehouse.Price, //进货价
			StockCount:              "",
			BatchNumberCount:        warehouse.StockCount - goods.Count,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
			OrderId:                 order_id,
		}
		//创建出库流水
		errflow := CreateStockFlowOne(stockFlow)
		if errflow != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "创建流水报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//添加入库ID
		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//更新出库数量
		errsumcode := ModifyGoodSumCount(goods.StorehouseId, goods.Count, orgID, goods.GoodId)
		if errsumcode != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "更新出库数量报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		if warehouse.StockCount < maxNumber {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "出库接口库存数量不足",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errors.New("库存数量不足")

		}

		return nil
	} else {
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "扣减库存报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		OutInfo := &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:                   5,
			SysRecordTime:           record_time,
			GoodTypeId:              goods.GoodTypeId,
			GoodId:                  goods.GoodId,
			PatientId:               patient_id,
			Number:                  warehouse.Number,
			LicenseNumber:           warehouse.LicenseNumber,
			Price:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
			OrderId:                 order_id,
		}
		OutInfo.Count = goods.Count

		AddSigleWarehouseOutInfo(OutInfo)

		stockFlow := models.VmStockFlow{
			WarehousingId:           warehouse.ID,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           warehouse.LicenseNumber,
			Count:                   stock_number,
			UserOrgId:               orgID,
			PatientId:               patient_id,
			SystemTime:              record_time,
			ConsumableType:          15,
			IsSys:                   5,
			WarehousingOrder:        warehouse.WarehousingOrder,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			IsEdit:                  1,
			CancelStockId:           0,
			CancelOrderNumber:       "",
			Manufacturer:            warehouse.Manufacturer,
			Dealer:                  warehouse.Dealer,
			Creator:                 creator,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Mtime:                   0,
			Price:                   warehouse.PackingPrice, //零售价
			WarehousingDetailId:     warehouse.ID,
			WarehouseOutDetailId:    goods.ID,
			CancelOutDetailId:       0,
			ProductDate:             warehouse.ProductDate,
			ExpireDate:              warehouse.ExpiryDate,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            warehouse.StorehouseId,
			AdminUserId:             creator,
			BuyPrice:                warehouse.Price, //进货价
			StockCount:              "",
			BatchNumberCount:        0,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
			OrderId:                 order_id,
		}
		//创建出库流水
		errflow := CreateStockFlowOne(stockFlow)
		if errflow != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "创建出库流水报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		//更新出库数量
		errcodecout := ModifyGoodSumCount(goods.StorehouseId, stock_number, orgID, goods.GoodId)

		if errcodecout != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "更新出库数量报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}
	}

	goods.Count = deliver_number - stock_number
	prepare := &models.DialysisBeforePrepare{
		Count: deliver_number - stock_number,
	}
	ConsumableSettleDelivery(orgID, patient_id, record_time, prepare, warehouseOut, creator, order_id)

	return nil
}

//保存处方出库
func ConsumablePrescriptionDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, creator int64) (err error) {

	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0
	fmt.Println("223323233233223233223233223woo", goods.Count)
	deliver_number = goods.Count

	// 根据先进先出原则，查询最先入库的批次，进行出库

	// 如果没有对应的库存，则报错
	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId, goods.StorehouseId)
	if err != nil {
		goodErrcode := models.XtGoodErrcode{
			UserOrgId:      goods.UserOrgId,
			Errcode:        "查询库存信息报错",
			GoodId:         goods.GoodId,
			Status:         1,
			Ctime:          time.Now().Unix(),
			Mtime:          0,
			Count:          0,
			StockCount:     0,
			Creater:        creator,
			BatchNumberId:  warehouse.ID,
			WarehouseOutId: 0,
		}
		CreateGoodErrcode(goodErrcode)
		return err
	}

	stock_number = warehouse.StockCount

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		maxNumber = goods.Count
		warehouse.StockCount = warehouse.StockCount - maxNumber
		warehouse.Mtime = time.Now().Unix()

		//扣减库存
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.UserOrgId,
				Errcode:        "扣减库存失败",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseInfotId: warehouse.ID,
		}
		//添加入库单详情ID
		errOne := UpdatedSigleWarehouseOutInfo(goods.ID, warehouseOutInfo)
		if errOne != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      goods.UserOrgId,
				Errcode:        "添加入库单详情ID",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errOne
		}
		OutInfo := &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:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
		}
		fmt.Println("goods.count2323232233232233232322332322332", goods.Count)
		OutInfo.Count = goods.Count

		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
		if errcodes == gorm.ErrRecordNotFound {
			errOne := AddSigleWarehouseOutInfo(OutInfo)
			if errOne != nil {
				return errOne
			}
		} else if errcodes == nil {

			outInfoOne, _ := GetWarehouseOutInfoIsExistThree(goods.GoodId, patient_id, record_time, goods.ProjectId)
			if goods.Count != outInfoOne.Count {
				UpdatedWarehouseOutInfo(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
			}

		}

		lastOut, _ := FindWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId)
		//查询已经出库的数据
		flowGood, _ := GetStockFlowIsBatchNumberSix(patient_id, record_time, goods.GoodId, goods.ProjectId)
		var out_count int64
		var out_count_one int64
		for _, item := range flowGood {
			out_count += item.Count
		}

		//查询退库数据
		flowGoodTwo, _ := GetStockFlowIsBatchNumberThree(patient_id, record_time, goods.GoodId)
		for _, item := range flowGoodTwo {
			out_count_one += item.Count
		}

		//如果本次出库数据大于历史出库数据 新增1条流水
		fmt.Println("goods_count233232323223", goods.Count)
		fmt.Println("out_count - out_count_one", out_count-out_count_one)
		if goods.Count > (out_count - out_count_one) {

			stockFlow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   goods.Count - out_count + out_count_one,
				UserOrgId:               orgID,
				PatientId:               goods.PatientId,
				SystemTime:              record_time,
				ConsumableType:          3,
				IsSys:                   1,
				WarehousingOrder:        warehouse.WarehousingOrder,
				WarehouseOutId:          warehouseOut.ID,
				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
				IsEdit:                  1,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.Dealer,
				Creator:                 creator,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   warehouse.PackingPrice, //零售价
				WarehousingDetailId:     warehouse.ID,
				WarehouseOutDetailId:    goods.ID,
				CancelOutDetailId:       0,
				ProductDate:             warehouse.ProductDate,
				ExpireDate:              warehouse.ExpiryDate,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            warehouse.StorehouseId,
				AdminUserId:             creator,
				BuyPrice:                warehouse.Price, //进货价
				StockCount:              "",
				BatchNumberCount:        warehouse.StockCount - goods.Count,
				IsCheck:                 1,
				OverCount:               sum_count,
				RegisterNumber:          warehouse.RegisterNumber,
				ProjectId:               goods.ProjectId,
			}
			//创建出库流水
			errflow := CreateStockFlowOne(stockFlow)
			if errflow != nil {
				goodErrcode := models.XtGoodErrcode{
					UserOrgId:      orgID,
					Errcode:        "创建流水报错",
					GoodId:         goods.GoodId,
					Status:         1,
					Ctime:          time.Now().Unix(),
					Mtime:          0,
					Count:          0,
					StockCount:     0,
					Creater:        creator,
					BatchNumberId:  warehouse.ID,
					WarehouseOutId: 0,
				}
				CreateGoodErrcode(goodErrcode)
			}
			//更新出库数量
			errsumcode := ModifyGoodSumCount(goods.StorehouseId, stockFlow.Count, orgID, goods.GoodId)
			if errsumcode != nil {
				goodErrcode := models.XtGoodErrcode{
					UserOrgId:      orgID,
					Errcode:        "更新出库数量报错",
					GoodId:         goods.GoodId,
					Status:         1,
					Ctime:          time.Now().Unix(),
					Mtime:          0,
					Count:          0,
					StockCount:     0,
					Creater:        creator,
					BatchNumberId:  warehouse.ID,
					WarehouseOutId: 0,
				}
				CreateGoodErrcode(goodErrcode)
			}
		}

		//如果本次出库数据小于历史出库数据 新增1条退库流水

		if goods.Count < (out_count - out_count_one) {

			operation_time := time.Now().Unix()

			//创建退库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllCancelStockTotal(orgID)
			total = total + 1
			orderNumber := "CKTKD" + strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

			cancelStock := models.CancelStock{
				OrderNumber:  orderNumber,
				OperaTime:    operation_time,
				OrgId:        orgID,
				Creater:      warehouseOut.Creater,
				Ctime:        time.Now().Unix(),
				Status:       1,
				ReturnTime:   record_time,
				Type:         1,
				StorehouseId: goods.StorehouseId,
				IsCheck:      1,
			}
			_, msgerrkonde := GetCancelStockDetailByOrderNumberOne(record_time, orgID)
			if msgerrkonde == gorm.ErrRecordNotFound {
				AddSigleCancelStock(&cancelStock)
			}

			cancel, _ := GetLastCancelStockById(orgID)

			manufacturer, _ := GetManufactureById(warehouse.Manufacturer)
			deaerler, _ := GetDealerById(warehouse.Dealer)
			cancelStockInfo := models.CancelStockInfo{
				GoodId:          goods.GoodId,
				CancelStockId:   cancel.ID,
				GoodTypeId:      goods.GoodTypeId,
				Count:           out_count - out_count_one - goods.Count,
				Price:           warehouse.PackingPrice,
				Total:           0,
				ProductDate:     warehouse.ProductDate,
				ExpiryDate:      warehouse.ExpiryDate,
				Ctime:           time.Now().Unix(),
				Status:          1,
				OrgId:           orgID,
				OrderNumber:     cancel.OrderNumber,
				Type:            0,
				Dealer:          deaerler.DealerName,
				Manufacturer:    manufacturer.ManufacturerName,
				Number:          warehouse.Number,
				RegisterAccount: "",
				Remark:          "",
				WarehouseInfoId: warehouse.ID,
				PatientId:       patient_id,
				RecordDate:      record_time,
				StorehouseId:    goods.StorehouseId,
				IsCheck:         1,
			}
			if orgID == 9671 || orgID == 10265 {
				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
				cancelStockInfo.Price = goodsInfo.PackingPrice
			}
			CreateCancelStockInfoOne(&cancelStockInfo)

			cancelInfo, _ := GetLastCancelStockInfoByGoodId(goods.GoodId)

			flow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   out_count - out_count_one - goods.Count,
				UserOrgId:               orgID,
				PatientId:               patient_id,
				SystemTime:              record_time,
				ConsumableType:          7,
				IsSys:                   1,
				WarehousingOrder:        "",
				WarehouseOutId:          lastOut.WarehouseOutId,
				WarehouseOutOrderNumber: lastOut.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           cancel.ID,
				CancelOrderNumber:       cancel.OrderNumber,
				Manufacturer:            manufacturer.ID,
				Dealer:                  0,
				Creator:                 warehouseOut.Creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   warehouse.PackingPrice,
				WarehousingDetailId:     warehouse.ID,
				WarehouseOutDetailId:    lastOut.ID,
				CancelOutDetailId:       cancelInfo.ID,
				ProductDate:             warehouse.ProductDate,
				ExpireDate:              warehouse.ExpiryDate,
				StorehouseId:            goods.StorehouseId,
				BuyPrice:                warehouse.Price,
				ProjectId:               goods.ProjectId,
				OverCount:               sum_count,
				RegisterNumber:          warehouse.RegisterNumber,
			}
			if orgID == 9671 || orgID == 10265 {
				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
				flow.Price = goodsInfo.PackingPrice
				flow.BuyPrice = goodsInfo.BuyPrice
			}
			CreateStockFlowOne(flow)

			//退库数量增加
			UpdateSumAddCancelCount(orgID, goods.GoodId, goods.StorehouseId, flow.Count)
		}

		//添加入库ID
		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

		if warehouse.StockCount < maxNumber {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "出库接口库存数量不足",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errors.New("库存数量不足")

		}

		return nil
	} else {
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()

		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "扣减库存报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
			return errThree
		}

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		OutInfo := &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:                   warehouse.PackingPrice,
			ExpiryDate:              warehouse.ExpiryDate,
			ProductDate:             warehouse.ProductDate,
			ProjectId:               goods.ProjectId,
			SupplyWarehouseId:       warehouse.SupplyWarehouseId,
			StorehouseId:            goods.StorehouseId,
			IsCheck:                 1,
			OverCount:               sum_count,
			RegisterNumber:          warehouse.RegisterNumber,
		}
		OutInfo.Count = goods.Count

		_, errcodes := GetWarehouseOutInfoIsExistOne(goods.GoodId, patient_id, record_time, goods.ProjectId)
		if errcodes == gorm.ErrRecordNotFound {
			errOne := AddSigleWarehouseOutInfo(OutInfo)
			if errOne != nil {
				return errOne
			}
		} else if errcodes == nil {

			outInfoOne, _ := GetWarehouseOutInfoIsExistThree(goods.GoodId, patient_id, record_time, goods.ProjectId)
			if goods.Count != outInfoOne.Count {
				UpdatedWarehouseOutInfo(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
			}

		}

		lastOut, _ := FindWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId)
		//查询该该批次已经出库的数据
		flowGood, _ := GetStockFlowIsBatchNumber(warehouse.ID, patient_id, record_time, goods.GoodId)
		var out_count int64
		var out_count_one int64
		for _, item := range flowGood {
			out_count += item.Count
		}
		flowGoodTwo, _ := GetStockFlowIsBatchNumberSix(patient_id, record_time, goods.GoodId, goods.ProjectId)
		for _, item := range flowGoodTwo {
			out_count_one += item.Count
		}
		//如果出库数量 大于 历史出库数据 新增1条流水
		if goods.Count > out_count-out_count_one {
			stockFlow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   stock_number,
				UserOrgId:               orgID,
				PatientId:               goods.PatientId,
				SystemTime:              record_time,
				ConsumableType:          3,
				IsSys:                   1,
				WarehousingOrder:        warehouse.WarehousingOrder,
				WarehouseOutId:          warehouseOut.ID,
				WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
				IsEdit:                  1,
				CancelStockId:           0,
				CancelOrderNumber:       "",
				Manufacturer:            warehouse.Manufacturer,
				Dealer:                  warehouse.Dealer,
				Creator:                 creator,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   warehouse.PackingPrice, //零售价
				WarehousingDetailId:     warehouse.ID,
				WarehouseOutDetailId:    goods.ID,
				CancelOutDetailId:       0,
				ProductDate:             warehouse.ProductDate,
				ExpireDate:              warehouse.ExpiryDate,
				SupplyWarehouseId:       warehouse.SupplyWarehouseId,
				StorehouseId:            warehouse.StorehouseId,
				AdminUserId:             creator,
				BuyPrice:                warehouse.Price, //进货价
				StockCount:              "",
				BatchNumberCount:        0,
				IsCheck:                 1,
				OverCount:               sum_count,
				RegisterNumber:          warehouse.RegisterNumber,
				ProjectId:               goods.ProjectId,
			}
			//创建出库流水
			errflow := CreateStockFlowOne(stockFlow)
			if errflow != nil {
				goodErrcode := models.XtGoodErrcode{
					UserOrgId:      orgID,
					Errcode:        "创建出库流水报错",
					GoodId:         goods.GoodId,
					Status:         1,
					Ctime:          time.Now().Unix(),
					Mtime:          0,
					Count:          0,
					StockCount:     0,
					Creater:        creator,
					BatchNumberId:  warehouse.ID,
					WarehouseOutId: 0,
				}
				CreateGoodErrcode(goodErrcode)
			}

			//更新出库数量
			errcodecout := ModifyGoodSumCount(goods.StorehouseId, stock_number, orgID, goods.GoodId)

			if errcodecout != nil {
				goodErrcode := models.XtGoodErrcode{
					UserOrgId:      orgID,
					Errcode:        "更新出库数量报错",
					GoodId:         goods.GoodId,
					Status:         1,
					Ctime:          time.Now().Unix(),
					Mtime:          0,
					Count:          0,
					StockCount:     0,
					Creater:        creator,
					BatchNumberId:  warehouse.ID,
					WarehouseOutId: 0,
				}
				CreateGoodErrcode(goodErrcode)
			}
		}

		//退库
		if goods.Count < out_count-out_count_one {

			operation_time := time.Now().Unix()

			//创建退库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllCancelStockTotal(orgID)
			total = total + 1
			orderNumber := "CKTKD" + strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000" + strconv.FormatInt(total, 10)

			cancelStock := models.CancelStock{
				OrderNumber:  orderNumber,
				OperaTime:    operation_time,
				OrgId:        orgID,
				Creater:      warehouseOut.Creater,
				Ctime:        time.Now().Unix(),
				Status:       1,
				ReturnTime:   record_time,
				Type:         1,
				StorehouseId: goods.StorehouseId,
				IsCheck:      1,
			}
			_, msgerrkonde := GetCancelStockDetailByOrderNumberOne(record_time, orgID)
			if msgerrkonde == gorm.ErrRecordNotFound {
				AddSigleCancelStock(&cancelStock)
			}

			cancel, _ := GetLastCancelStockById(orgID)

			manufacturer, _ := GetManufactureById(warehouse.Manufacturer)
			deaerler, _ := GetDealerById(warehouse.Dealer)
			cancelStockInfo := models.CancelStockInfo{
				GoodId:          goods.GoodId,
				CancelStockId:   cancel.ID,
				GoodTypeId:      goods.GoodTypeId,
				Count:           out_count - out_count_one - goods.Count,
				Price:           warehouse.PackingPrice,
				Total:           0,
				ProductDate:     warehouse.ProductDate,
				ExpiryDate:      warehouse.ExpiryDate,
				Ctime:           time.Now().Unix(),
				Status:          1,
				OrgId:           orgID,
				OrderNumber:     cancel.OrderNumber,
				Type:            0,
				Dealer:          deaerler.DealerName,
				Manufacturer:    manufacturer.ManufacturerName,
				Number:          warehouse.Number,
				RegisterAccount: "",
				Remark:          "",
				WarehouseInfoId: warehouse.ID,
				PatientId:       patient_id,
				RecordDate:      record_time,
				StorehouseId:    goods.StorehouseId,
				IsCheck:         1,
			}
			if orgID == 9671 || orgID == 10265 {
				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
				cancelStockInfo.Price = goodsInfo.PackingPrice
			}
			CreateCancelStockInfoOne(&cancelStockInfo)

			cancelInfo, _ := GetLastCancelStockInfoByGoodId(goods.GoodId)

			flow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   out_count - goods.Count,
				UserOrgId:               orgID,
				PatientId:               patient_id,
				SystemTime:              record_time,
				ConsumableType:          7,
				IsSys:                   1,
				WarehousingOrder:        "",
				WarehouseOutId:          lastOut.WarehouseOutId,
				WarehouseOutOrderNumber: lastOut.WarehouseOutOrderNumber,
				IsEdit:                  0,
				CancelStockId:           cancel.ID,
				CancelOrderNumber:       cancel.OrderNumber,
				Manufacturer:            manufacturer.ID,
				Dealer:                  0,
				Creator:                 warehouseOut.Creater,
				UpdateCreator:           0,
				Status:                  1,
				Ctime:                   time.Now().Unix(),
				Mtime:                   0,
				Price:                   warehouse.PackingPrice,
				WarehousingDetailId:     warehouse.ID,
				WarehouseOutDetailId:    lastOut.ID,
				CancelOutDetailId:       cancelInfo.ID,
				ProductDate:             warehouse.ProductDate,
				ExpireDate:              warehouse.ExpiryDate,
				StorehouseId:            goods.StorehouseId,
				BuyPrice:                warehouse.Price,
				ProjectId:               goods.ProjectId,
				OverCount:               sum_count,
				RegisterNumber:          warehouse.RegisterNumber,
			}
			if orgID == 9671 || orgID == 10265 {
				goodsInfo, _ := FindeGoodInfo(orgID, goods.ProjectId)
				flow.Price = goodsInfo.PackingPrice
				flow.BuyPrice = goodsInfo.BuyPrice
			}
			CreateStockFlowOne(flow)

			//退库数量增加
			UpdateSumAddCancelCount(orgID, goods.GoodId, goods.StorehouseId, flow.Count)
		}

		errWarehouse := UpdateGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count)
		if errWarehouse != nil {
			goodErrcode := models.XtGoodErrcode{
				UserOrgId:      orgID,
				Errcode:        "添加入库ID报错",
				GoodId:         goods.GoodId,
				Status:         1,
				Ctime:          time.Now().Unix(),
				Mtime:          0,
				Count:          0,
				StockCount:     0,
				Creater:        creator,
				BatchNumberId:  warehouse.ID,
				WarehouseOutId: 0,
			}
			CreateGoodErrcode(goodErrcode)
		}

	}

	goods.Count = deliver_number - stock_number
	prepare := &models.DialysisBeforePrepare{
		Count: deliver_number - stock_number,
	}
	ConsumablePrescriptionDelivery(orgID, patient_id, record_time, prepare, warehouseOut, creator)

	return nil
}