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) {

	drugError := models.XtDrugError{
		ID:                    0,
		UserOrgId:             advice.UserOrgId,
		DrugId:                advice.DrugId,
		RecordDate:            advice.AdviceDate,
		PatientId:             advice.PatientId,
		Remark:                "恒泰中医院出库进来",
		Status:                1,
		Ctime:                 time.Now().Unix(),
		Mtime:                 0,
		Prescribingnumber:     advice.PrescribingNumber,
		PrescribingNumberUnit: advice.PrescribingNumberUnit,
		SumCount:              0,
	}
	CreateDrugError(drugError)
	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	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.MaxUnit != lastWarehouse.MinUnit && drup.MaxUnit != drup.MinUnit && lastWarehouse.MinUnit != "" {
		//fmt.Println("lastWarehouse", lastWarehouse.StockMinNumber)
		//fmt.Println("drugp.min", drup.MinNumber)
		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)
		}
	}

	if lastWarehouse.MaxUnit == lastWarehouse.MinUnit && drup.MaxUnit != drup.MinUnit && lastWarehouse.MinUnit != "" {
		//fmt.Println("owowowowowoowowowowowo")
		lastWarehouse.StockMaxNumber = lastWarehouse.StockMaxNumber + lastWarehouse.StockMinNumber
		ChangeMaxNumberOne(lastWarehouse.ID, lastWarehouse.StockMaxNumber)

	}

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

	if err != nil {

		return err
	}

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

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

	// 将该批次的剩余库存数量转换为拆零数量
	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

	}

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

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	//fmt.Println("stock_number", stock_number)
	//fmt.Println("deliver_numberwowowwo", deliver_number)
	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

		//fmt.Println("maxNumberowowowowo", warehouse.StockMaxNumber)
		//fmt.Println("min_nu2o2o2332o23", warehouse.StockMinNumber)
		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("库存数量不足")
			}
		}
		//fmt.Println("min2o2o23o32", minNumber)
		//fmt.Println("maxNumberowowoow", maxNumber)

		if drup.MinUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {

			//fmt.Println("金1")
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
			//fmt.Println("金1", warehouse.StockMaxNumber)
		}

		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			//fmt.Println("金2")
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		}
		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
			//fmt.Println("金3")
			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 {
			//fmt.Println("金4")

			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1

			if minNumber == 2 && warehouse.MaxUnit == warehouse.MinUnit && warehouse.StockMinNumber == 0 {
				warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			}
			if warehouse.MaxUnit != warehouse.MinUnit {
				warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			}
		} else {
			//fmt.Println("金5")
			if minNumber > 0 {
				if (warehouse.StockMinNumber - minNumber) >= 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
				}

			}

			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
				//fmt.Println("6")
				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 && warehouse.MaxUnit != warehouse.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) >= 0 {
				//fmt.Println("金7")
				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)
		//fmt.Println("errThreeo23o2o32o32o23o32", errThree)
		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,
			AdviceId:                advice.ID,
		}

		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,
			AdviceId:                advice.ID,
		}

		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,
			AdviceId:                advice.ID,
		}
		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,
			AdviceId:                advice.ID,
		}
		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,
			AdviceId:                advice.ID,
		}
		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,
			AdviceId:                advice.ID,
		}

		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

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

			////查询今日出库的数据
			//if orgID == 10188 || orgID == 10217 || orgID == 10344 {
			//	//查询这个患者今日用过的总数量
			//	listDrugFlow, _ := GetDrugFlowByWatch(advice.PatientId, advice.DrugId, advice.AdviceDate, advice.UserOrgId)
			//	for _, item := range listDrugFlow {
			//
			//		outInfor, _ := GetDrugWarehouseOutInfor(item.WarehouseOutDetailId, item.UserOrgId)
			//		if item.MaxUnit == outInfor.CountUnit {
			//			if item.Count != outInfor.Count {
			//				UpdateDrugWarehouseOutInfoById(outInfor.ID, item.Count)
			//			}
			//		}
			//
			//	}
			//}

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

	}

	return
}

func GetDrugFlowByWatch(patient_id int64, drug_id int64, advice_date int64, user_org_id int64) (list []*models.DrugFlow, err error) {

	err = XTReadDB().Where("patient_id = ? and drug_id = ? and system_time = ? and user_org_id = ? and status =1 and consumable_type = 3", patient_id, drug_id, advice_date, user_org_id).Find(&list).Error
	return list, err
}

func GetDrugWarehouseOutInfor(id int64, user_org_id int64) (models.DrugWarehouseOutInfo, error) {

	outInfo := models.DrugWarehouseOutInfo{}
	err := XTReadDB().Where("id = ? and org_id = ?", id, user_org_id).Find(&outInfo).Error
	return outInfo, err
}

func UpdateDrugWarehouseOutInfoById(id int64, count int64) error {

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

// 药品出库 递归方式
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 这个数据就是需要出库的耗材的数据(新增的数据)
	fmt.Println("len233333333333333w", len(goods_yc))
	fmt.Println("需要出库的数据", len(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

			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)

		}

	}

	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, goods.StorehouseId)
		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:                   record_time,
			Mtime:                   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:                   record_time,
			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:                   record_time,
				Mtime:                   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:                   record_time,
					Mtime:                   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:                   record_time,
				Mtime:                   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:                   record_time,
					Mtime:                   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, goods.StorehouseId)
		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:                   record_time,
			Mtime:                   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:                   record_time,
				Mtime:                   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:                   record_time,
					Mtime:                   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:                   record_time,
				Mtime:                   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:                   record_time,
					Mtime:                   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
		}

		//查询剩余库存
		houseConfig, _ := GetAllStoreHouseConfig(orgID)
		goodList, _ := GetAllGoodSumCount(good_yc.GoodId, orgID, houseConfig.StorehouseOutInfo)
		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
		}

		// 在出库记录表里记录退库详情
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			//WarehouseInfoId:		 warehouse.ID,
			Status:        1,
			Ctime:         record_time,
			Mtime:         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:                   record_time,
				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)

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

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

		manufacturer, _ := GetManufactureById(ware.Manufacturer)
		deaerler, _ := GetDealerById(ware.Dealer)

		cancelStockInfo := models.CancelStockInfo{
			GoodId:          ware.GoodId,
			CancelStockId:   cancel.ID,
			GoodTypeId:      ware.GoodTypeId,
			Count:           delete_count,
			Price:           ware.Price,
			Total:           0,
			ProductDate:     ware.ProductDate,
			ExpiryDate:      ware.ExpiryDate,
			Ctime:           record_time,
			Mtime:           time.Now().Unix(),
			Status:          1,
			OrgId:           good_yc.UserOrgId,
			OrderNumber:     cancel.OrderNumber,
			Type:            0,
			Dealer:          deaerler.DealerName,
			Manufacturer:    manufacturer.ManufacturerName,
			Number:          ware.Number,
			RegisterAccount: "",
			Remark:          "",
			WarehouseInfoId: ware.WarehouseInfotId,
			PatientId:       ware.PatientId,
			RecordDate:      record_time,
			StorehouseId:    houseConfig.StorehouseOutInfo,
			IsCheck:         1,
		}

		CreateCancelStockInfoOne(&cancelStockInfo)
		cancelInfo, _ := GetLastCancelStockInfoByGoodId(ware.GoodId)
		goodListOne, _ := GetSumGoodList(good_yc.UserOrgId, houseConfig.StorehouseOutInfo, good_yc.GoodId)
		var over_count int64
		for _, it := range goodListOne {
			over_count += it.StockCount
		}
		flow := models.VmStockFlow{
			WarehousingId:           ware.WarehouseInfotId,
			GoodId:                  ware.GoodId,
			Number:                  ware.Number,
			LicenseNumber:           ware.LicenseNumber,
			Count:                   ware.Count,
			UserOrgId:               ware.OrgId,
			PatientId:               ware.PatientId,
			SystemTime:              record_time,
			ConsumableType:          7,
			IsSys:                   0,
			WarehousingOrder:        "",
			WarehouseOutId:          ware.WarehouseOutId,
			WarehouseOutOrderNumber: ware.WarehouseOutOrderNumber,
			IsEdit:                  0,
			CancelStockId:           cancel.ID,
			CancelOrderNumber:       cancel.OrderNumber,
			Manufacturer:            manufacturer.ID,
			Dealer:                  0,
			Creator:                 warehouseOut.Creater,
			UpdateCreator:           0,
			Status:                  1,
			Ctime:                   record_time,
			Mtime:                   time.Now().Unix(),
			Price:                   ware.Price,
			WarehousingDetailId:     ware.WarehouseInfotId,
			WarehouseOutDetailId:    ware.ID,
			CancelOutDetailId:       cancelInfo.ID,
			ProductDate:             ware.ProductDate,
			ExpireDate:              ware.ExpiryDate,
			StorehouseId:            houseConfig.StorehouseOutInfo,
			OverCount:               over_count,
		}
		CreateStockFlowOne(flow)

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

	maxNumber = goods.Count

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

	if warehouse.StockCount-maxNumber >= 0 {
		warehouse.StockCount = warehouse.StockCount - maxNumber
	} else {
		warehouse.StockCount = warehouse.StockCount
	}

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

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

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

		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,
			OverCount:               sum_count,
		}

		//创建出库流水
		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:      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)

		//查询剩余库存
		goodListOne, _ := GetAllGoodSumCount(goods.GoodId, orgID, warehouseInfo.StorehouseId)
		var sum_count_one int64
		for _, item := range goodListOne {
			sum_count_one += item.StockCount
		}
		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,
			OverCount:               sum_count_one,
		}

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

		if errThree != nil {
			return errThree
		}

	} else {

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

		errThree := UpDateWarehouseInfoByStock(&warehouse)

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

		//查询剩余库存
		goodList, _ := GetAllGoodSumCount(goods.GoodId, orgID, goods.StorehouseId)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		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,
			OverCount:               sum_count,
		}
		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:          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,
			OverCount:               sum_count,
		}

		//创建出库明细
		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:      stock_number,
			Price:                 warehouse.Price,
			TotalPrice:            0,
			Status:                1,
			Ctime:                 warehouse.Ctime,
			Remark:                goods.Remark,
			OrgId:                 warehouse.OrgId,
			Type:                  1,
			Manufacturer:          warehouse.Manufacturer,
			StockCount:            stock_number,
			Dealer:                warehouse.Dealer,
			LicenseNumber:         "",
			PackingPrice:          warehouse.PackingPrice,
			StorehouseId:          warehouseInfo.StorehouseId,
			SecondWarehouseInfoId: warehouseInfo.SecondWarehouseInfoId,
			IsCheck:               1,
		}

		AddWarehosingInfo(warehouseInfo)

		//查询剩余库存
		goodListOne, _ := GetAllGoodSumCount(goods.GoodId, orgID, warehouseInfo.StorehouseId)
		var sum_count_one int64
		for _, item := range goodListOne {
			sum_count_one += item.StockCount
		}
		stockInfoFlow := models.VmStockFlow{
			WarehousingId:           warehouseInfo.WarehousingId,
			GoodId:                  goods.GoodId,
			Number:                  warehouse.Number,
			LicenseNumber:           goods.LicenseNumber,
			Count:                   stock_number,
			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,
			OverCount:               sum_count_one,
		}

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

		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, warehouseout.StorehouseId)
	//fmt.Println("lastWarehouse.StockMinNumber", lastWarehouse.StockMinNumber)
	//fmt.Println("drup.MinNumber", drup.MinNumber)
	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

	//fmt.Println("stock23233233232", stock_number)
	//fmt.Println("deliver_number", deliver_number)

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

	//fmt.Println("warehouse.StockMaxNumber",warehouse.StockMaxNumber)
	//fmt.Println("maxNumber9899923323232wo",maxNumber)

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

	if warehouse.StockMaxNumber-maxNumber > 0 {
		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
	}

	//查询剩余库存
	stockInfo, _ := GetDrugAllStockInfo(advice.StorehouseId, 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
	}

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	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,
			OverCount:               sum_count,
		}

		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,
			OverCount:               sum_count,
		}

		CreateDrugFlowOne(drugflow)

		//入库
		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)

		//查询剩余库存
		stockInfoOne, _ := GetDrugAllStockInfo(drugWarehouse.StorehouseId, orgID, advice.DrugId)
		var sum_count_one int64
		for _, its := range stockInfoOne {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			sum_count_one += its.StockMaxNumber + its.StockMinNumber
		}
		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,
			OverCount:               sum_count_one,
		}

		CreateDrugFlowOne(flow)

		return nil
	} else {

		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

		//查询剩余库存
		stockInfo, _ := GetDrugAllStockInfo(advice.StorehouseId, 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: 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,
			OverCount:               sum_count,
		}
		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,
			OverCount:               sum_count,
		}
		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)

		//查询剩余库存
		stockInfoTwo, _ := GetDrugAllStockInfo(drugWarehouse.StorehouseId, orgID, advice.DrugId)
		var sum_count_one int64
		for _, its := range stockInfoTwo {
			if its.MaxUnit == drup.MaxUnit {
				its.StockMaxNumber = its.StockMaxNumber * drup.MinNumber
			}
			sum_count_one += its.StockMaxNumber + its.StockMinNumber
		}
		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,
			OverCount:               sum_count,
		}

		CreateDrugFlowOne(flow)

		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, goods.StorehouseId)
		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:                   record_time,
			Mtime:                   time.Now().Unix(),
			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,
			Remark:                  goods.Remark,
		}
		//创建出库流水
		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, goods.StorehouseId)
		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:                   record_time,
			Mtime:                   time.Now().Unix(),
			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,
			Remark:                  goods.Remark,
		}
		//创建出库流水
		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, unit string) (err error) {

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

	var stock_number int64 = 0

	var drug_price float64
	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber

	} else {
		deliver_number = prescribingNumber

	}
	if advice.CountUnit == drup.MaxUnit {
		drug_price = drup.RetailPrice
	}
	fmt.Println(drug_price)

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

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

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	lastWarehouse, _ := FindLastDrugWarehousingInfoByID(advice.DrugId, advice.StorehouseId)

	if lastWarehouse.MaxUnit != lastWarehouse.MinUnit && drup.MaxUnit != drup.MinUnit && lastWarehouse.MinUnit != "" {
		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)

		}
	}

	if lastWarehouse.MaxUnit == lastWarehouse.MinUnit && drup.MaxUnit != drup.MinUnit && lastWarehouse.MinUnit != "" {

		lastWarehouse.StockMaxNumber = lastWarehouse.StockMaxNumber + lastWarehouse.StockMinNumber
		ChangeMaxNumberOne(lastWarehouse.ID, lastWarehouse.StockMaxNumber)

	}

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

	// 将该批次的剩余库存数量转换为拆零数量
	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

	}
	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 {
			//fmt.Println("金1")
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber*drup.MinNumber
		}

		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit != drup.MinUnit {
			//fmt.Println("金2")
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - maxNumber
		}
		if drup.MaxUnit == warehouse.MaxUnit && drup.MaxUnit == drup.MinUnit {
			//fmt.Println("金3")
			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("stockmin", warehouse.StockMinNumber)
		//fmt.Println("minnubmerr", minNumber)
		if warehouse.StockMinNumber < minNumber {
			//fmt.Println("金4")
			warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			if warehouse.MaxUnit != warehouse.MinUnit {
				warehouse.StockMinNumber = warehouse.StockMinNumber + drup.MinNumber - minNumber
			}
			if minNumber == 2 && warehouse.MaxUnit == warehouse.MinUnit && warehouse.StockMinNumber == 0 {
				warehouse.StockMaxNumber = warehouse.StockMaxNumber - 1
			}
		} else {
			//fmt.Println("金5")
			if minNumber > 0 {
				if (warehouse.StockMinNumber - minNumber) >= 0 {
					warehouse.StockMinNumber = warehouse.StockMinNumber - minNumber
				}

			}

			if minNumber == 0 && maxNumber != 1 && warehouse.StockMaxNumber <= 0 {
				//fmt.Println("6")
				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 && warehouse.MaxUnit != warehouse.MinUnit {
			if (warehouse.StockMinNumber - deliver_number) >= 0 {
				//fmt.Println("金7")
				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:                   advice.SysRecordTime,
			Mtime:                   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:             drug_price, //手动出库出库价格
			WarehousingId:           warehouse.ID,
			SystemTime:              advice.SysRecordTime,
			PatientId:               advice.PatientId,
			Remark:                  advice.Remark,
		}
		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)
		drug_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:                   advice.SysRecordTime,
			Mtime:                   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:             drug_price, //手动出库出库价格
			WarehousingId:           warehouse.ID,
			WarehousingDetailId:     warehouse.ID,
			SystemTime:              advice.SysRecordTime,
			PatientId:               advice.PatientId,
			Remark:                  advice.Remark,
		}

		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, unit)
	}

	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 UpdateNewGoodWarehouseOutById(id int64, warehouse_info_id int64, org_id int64, over_count int64, tx *gorm.DB) error {

	err := tx.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 {
		tx.Rollback()
		return err
	}
	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 ChangeNewMaxNumber(id int64, count int64, tx *gorm.DB) error {

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

}
func ChangeMaxNumberOne(id int64, count int64) error {

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

}

func ChangeNewMaxNumberOne(id int64, count int64, tx *gorm.DB) error {

	err = XTWriteDB().Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Updates(map[string]interface{}{"stock_max_number": count, "stock_min_number": 0}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	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 UpdateNewMinNumber(id int64, count int64, tx *gorm.DB) error {

	err := tx.Model(&models.DrugWarehouseInfo{}).Where("id = ? and status = 1 and is_check = 1", id).Update(map[string]interface{}{"stock_min_number": count}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	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 FindNewLastDrugWarehouseOutInfo(orgid int64, tx *gorm.DB) (models.DrugWarehouseOutInfo, error) {
	info := models.DrugWarehouseOutInfo{}
	err := tx.Where("org_id = ? and status = 1", orgid).Last(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	return info, err
}

func GetAllGoodSumCount(goodid int64, orgid int64, storehouse_id 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 and storehouse_id = ?", goodid, orgid, storehouse_id).Find(&info).Error
	return info, err
}

func GetNewAllGoodSumCount(goodid int64, orgid int64, storehouse_id int64, tx *gorm.DB) (info []*models.WarehousingInfo, err error) {

	err = tx.Where("good_id = ? and org_id = ? and is_check =1 and status= 1 and stock_count > 0 and storehouse_id = ?", goodid, orgid, storehouse_id).Find(&info).Error
	if err != gorm.ErrRecordNotFound {
		if err != nil {
			tx.Rollback()
			return info, err
		}
	}
	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 ModifyNewGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64, tx *gorm.DB) error {

	err = tx.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 {
		tx.Rollback()
		return err
	}

	err = tx.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 {
		tx.Rollback()
		return err
	}

	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 ModifyReduceGoodSumCountTwenty(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 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 ModifyNewAddGoodSumCount(storehouse_id int64, count int64, user_org_id int64, good_id int64, tx *gorm.DB) error {

	err = tx.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 {
		tx.Rollback()
		return err
	}

	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 UpdateNewSumAddCancelCount(user_org_id int64, good_id int64, storehouse_id int64, count int64, tx *gorm.DB) error {

	err := tx.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 {
		tx.Rollback()
		return err
	}
	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

			var prescribingNumberOne int64
			prescribingCount_temp := strconv.FormatFloat(math.Abs(advice.PrescribingNumber), 'f', 0, 64)
			prescribe_count, _ := strconv.ParseInt(prescribingCount_temp, 10, 64)
			if advice.PrescribingNumberUnit == drup.MaxUnit && drup.MaxUnit != drup.MinUnit {
				prescribingNumberOne = prescribe_count * drup.MinNumber
			}
			if advice.PrescribingNumberUnit == drup.MinUnit && drup.MaxUnit != drup.MinUnit {
				prescribingNumberOne = prescribe_count
			}
			if advice.PrescribingNumberUnit == drup.MinUnit && drup.MaxUnit == drup.MinUnit {
				prescribingNumberOne = prescribe_count
			}

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

		} 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

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

	fmt.Println("stock_numnber233232232323", stock_number)
	fmt.Println("deliver_nmuberwooeooo2oo23", deliver_number)
	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, goods.StorehouseId)
		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,
			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)
		}

		//添加入库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, goods.StorehouseId)
		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 = stock_number

		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,
			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)
		}

		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,
		GoodTypeId:   goods.GoodTypeId,
		GoodId:       goods.GoodId,
		PatientId:    goods.PatientId,
		RecordDate:   goods.RecordDate,
		UserOrgId:    orgID,
		Ctime:        time.Now().Unix(),
		Creater:      goods.Creater,
		CommdityCode: goods.CommdityCode,
		Status:       1,
		StorehouseId: goods.StorehouseId,
	}
	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, 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 {
		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

	fmt.Println("sotck_number233223322o", stock_number)
	fmt.Println("deliver_number", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	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, goods.StorehouseId)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

		//查询已经出库的数据
		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, _ := GetStockFlowIsBatchNumberFour(patient_id, record_time, goods.GoodId, goods.ProjectId)
		for _, item := range flowGoodTwo {
			out_count_one += item.Count
		}

		//flowGood, _ := GetStockFlowIsBatchNumberSeventy(patient_id, record_time, goods.GoodId, goods.ProjectId)
		//
		//var out_count int64
		//var out_count_one int64
		var out_count_two int64
		//
		//for _, item := range flowGood {
		//	out_count += item.Count
		//}

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

		wareOutList, _ := GetStockFlowIsBatchNumberSixty(patient_id, record_time, goods.GoodId, goods.ProjectId)
		for _, item := range wareOutList {
			out_count_two += item.Count
		}

		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 = count - out_count_two + out_count_one

		_, errcodes := GetNewWarehouseOutInfoIsExistSix(goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID)
		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 count != outInfoOne.Count {
				UpdatedWarehouseOutInfo(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId)
			}

		}

		lastOut, _ := FindWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId)

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

			stockFlow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   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)
			}
			fmt.Println("stockFlow.Count233232323232322323232332wo0-----------------------", stockFlow.Count)
			//更新出库数量
			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 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 - 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 - 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)
			ModifyAddGoodSumCount(goods.StorehouseId, flow.Count, orgID, goods.GoodId)
		}

		//添加入库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, goods.StorehouseId)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}
		fmt.Println("剩余库存", sum_count)

		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 = stock_number

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

			outInfoOne, _ := GetWarehouseOutInfoIsExistTen(goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID)
			if count != outInfoOne.Count {
				UpdatedWarehouseOutInfoSix(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID)
			}

		}

		lastOut, _ := FindWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId)
		//查询该该批次已经出库的数据
		//flowGood, _ := GetStockFlowIsBatchNumber(warehouse.ID, patient_id, record_time, goods.GoodId)
		//查询已经出库的数据
		//flowGood, _ := GetStockFlowIsBatchNumberSeventy(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, _ := GetStockFlowIsBatchNumberSix(patient_id, record_time, goods.GoodId, goods.ProjectId)
		//for _, item := range flowGoodTwo {
		//	out_count_one += item.Count
		//}
		//查询该该批次已经出库的数据
		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, _ := GetStockFlowIsBatchNumberFour(patient_id, record_time, goods.GoodId, goods.ProjectId)
		for _, item := range flowGoodTwo {
			out_count_one += item.Count
		}
		fmt.Println("count----------------", count)
		fmt.Println("out_count----------", out_count)
		fmt.Println("out_count_one--------", out_count_one)
		//如果出库数量 大于 历史出库数据 新增1条流水
		if 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 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 - 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 - 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.Price,
				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)
			//实际出库减少
			ModifyAddGoodSumCount(goods.StorehouseId, flow.Count, orgID, goods.GoodId)
		}

		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,
		GoodTypeId:   goods.GoodTypeId,
		GoodId:       goods.GoodId,
		PatientId:    goods.PatientId,
		RecordDate:   goods.RecordDate,
		UserOrgId:    orgID,
		Ctime:        time.Now().Unix(),
		Creater:      creator,
		Status:       1,
		StorehouseId: goods.StorehouseId,
		ProjectId:    goods.ProjectId,
	}
	fmt.Println("剩余出库数量", prepare.Count)
	ConsumablePrescriptionDelivery(orgID, patient_id, record_time, prepare, warehouseOut, creator, count)

	return nil
}

func CreateAutoDetail(detail models.AutomaticReduceDetail) error {

	err := XTWriteDB().Create(&detail).Error

	return err
}

func CreateNewAutoDetail(detail models.AutomaticReduceDetail, tx *gorm.DB) error {

	err := tx.Create(&detail).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func UpdateAutomaticReduce(patient_id int64, record_date int64, good_id int64, project_id int64) error {

	err := XTWriteDB().Model(&models.AutomaticReduceDetail{}).Where("patient_id = ? and record_time =? and good_id = ? and project_id = ? and status = 1", patient_id, record_date, good_id, project_id).Update(map[string]interface{}{"status": 0}).Error
	return err
}

func UpdateNewAutomaticReduce(patient_id int64, record_date int64, good_id int64, project_id int64, tx *gorm.DB) error {

	err := tx.Model(&models.AutomaticReduceDetail{}).Where("patient_id = ? and record_time =? and good_id = ? and project_id = ? and status = 1", patient_id, record_date, good_id, project_id).Update(map[string]interface{}{"status": 0}).Error
	if err != nil {
		tx.Rollback()
		return err
	}
	return err
}

func GetDrugFLowByAdviceById(drug_id int64, patient_id int64, user_org_id int64, advice_date int64) (outInfo []*models.DrugWarehouseOutInfo, err error) {

	err = XTReadDB().Where("drug_id = ? and patient_id = ? and org_id = ? and sys_record_time = ? and status= 1", drug_id, patient_id, user_org_id, advice_date).Find(&outInfo).Error
	return outInfo, err
}

func UpdateHisAdviceById(id int64) error {

	err := XTWriteDB().Model(&models.HisDoctorAdviceInfo{}).Where("id = ?", id).Updates(map[string]interface{}{"execution_time": "", "execution_staff": "", "execution_state": 2}).Error
	return err
}

func GetAdviceIsOut(advice_id int64, user_org_id int64, patient_id int64, advice_date int64, drug_id int64) (models.DrugWarehouseOutInfo, error) {

	advice := models.DrugWarehouseOutInfo{}

	err := XTReadDB().Where("advice_id = ? and org_id = ? and patient_id = ? and sys_record_time = ? and status=1 and drug_id = ?", advice_id, user_org_id, patient_id, advice_date, drug_id).Find(&advice).Error

	return advice, err
}

// 药品出库

func NewHisDrugsDelivery(orgID int64, creater int64, advice *models.HisDoctorAdviceInfo, tx *gorm.DB) (err error) {

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

	isHasWay := false
	record_time := int64(0)
	isHasWay = true
	record_time = advice.RecordDate

	if isHasWay {
		//判断当天当前机构有没有创建出库单，没有则创建
		out, err := FindNewDrugStockOutByIsSys(orgID, 1, record_time, tx)
		fmt.Println(out)
		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 := AddNewSigleDrugWarehouseOut(&warehouseOut, tx)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

		//出库流程
		//1.查询改药品在药品库的规格信息，并将处方里的规格进行换算（尽量将拆零单位转换成包装单位）
		drup, _ := FindNewBaseDrugLibRecord(orgID, advice.DrugId, tx)
		if drup.ID > 0 {
			prescribingNumber := advice.PrescribingNumber

			NewBloodHisDrugDeliverInfo(orgID, prescribingNumber, &out, &drup, advice, prescribingNumber, advice.PrescribingNumberUnit, tx)

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

	}

	return
}

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

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

	deliver_number = goods.Count

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

	// 如果没有对应的库存，则报错
	warehouse, err := FindNewFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId, goods.StorehouseId, tx)
	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 := UpDateNewWarehouseInfoByStock(&warehouse, tx)
		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, _ := GetNewAllGoodSumCount(goods.GoodId, orgID, goods.StorehouseId, tx)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}

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

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

		var out_count_two int64

		wareOutList, _ := GetNewStockFlowIsBatchNumberSixty(patient_id, record_time, goods.GoodId, goods.ProjectId, tx)
		for _, item := range wareOutList {
			out_count_two += item.Count
		}

		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 = count - out_count_two + out_count_one

		_, errcodes := GetNewNewWarehouseOutInfoIsExistSix(goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID, tx)

		if errcodes == gorm.ErrRecordNotFound {
			errOne := AddNewSigleWarehouseOutInfo(OutInfo, tx)
			if errOne != nil {
				return errOne
			}
		} else if errcodes == nil {
			outInfoOne, _ := GetNewWarehouseOutInfoIsExistThree(goods.GoodId, patient_id, record_time, goods.ProjectId, tx)
			if count != outInfoOne.Count {
				UpdatedNewWarehouseOutInfo(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId, tx)
			}

		}

		lastOut, _ := FindNewWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId, tx)

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

			stockFlow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   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 := CreateNewStockFlowOne(stockFlow, tx)
			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 := ModifyNewGoodSumCount(goods.StorehouseId, stockFlow.Count, orgID, goods.GoodId, tx)
			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 count < (out_count - out_count_one) {

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

			//创建退库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindNewAllCancelStockTotal(orgID, tx)
			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 := GetNewCancelStockDetailByOrderNumberOne(record_time, orgID, tx)
			if msgerrkonde == gorm.ErrRecordNotFound {
				AddNewSigleCancelStock(&cancelStock, tx)
			}

			cancel, _ := GetNewLastCancelStockById(orgID, tx)

			manufacturer, _ := GetNewManufactureById(warehouse.Manufacturer, tx)
			deaerler, _ := GetNewDealerById(warehouse.Dealer, tx)
			cancelStockInfo := models.CancelStockInfo{
				GoodId:          goods.GoodId,
				CancelStockId:   cancel.ID,
				GoodTypeId:      goods.GoodTypeId,
				Count:           out_count - out_count_one - 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, _ := FindeNewGoodInfo(orgID, goods.ProjectId, tx)
				cancelStockInfo.Price = goodsInfo.PackingPrice
			}
			CreateNewCancelStockInfoOne(&cancelStockInfo, tx)

			cancelInfo, _ := GetLastNewCancelStockInfoByGoodId(goods.GoodId, tx)

			flow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   out_count - out_count_one - 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, _ := FindeNewGoodInfo(orgID, goods.ProjectId, tx)
				flow.Price = goodsInfo.PackingPrice
				flow.BuyPrice = goodsInfo.BuyPrice
			}
			CreateNewStockFlowOne(flow, tx)

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

		//添加入库ID
		errWarehouse := UpdateNewGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count, tx)
		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 := UpDateNewWarehouseInfoByStock(&warehouse, tx)
		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, _ := GetNewAllGoodSumCount(goods.GoodId, orgID, goods.StorehouseId, tx)
		var sum_count int64
		for _, item := range goodList {
			sum_count += item.StockCount
		}
		fmt.Println("剩余库存", sum_count)

		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 = stock_number

		_, errcodes := GetNewNewWarehouseOutInfoIsExistSix(goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID, tx)
		if errcodes == gorm.ErrRecordNotFound {
			errOne := AddNewSigleWarehouseOutInfo(OutInfo, tx)
			if errOne != nil {
				return errOne
			}
		} else if errcodes == nil {

			outInfoOne, _ := GetNewWarehouseOutInfoIsExistTen(goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID, tx)
			if count != outInfoOne.Count {
				UpdatedNewWarehouseOutInfoSix(OutInfo, goods.GoodId, patient_id, record_time, goods.ProjectId, warehouse.ID, tx)
			}

		}

		lastOut, _ := FindNewWarehouseOutInfoByPatientIdTwo(patient_id, record_time, goods.GoodId, orgID, goods.ProjectId, tx)

		//查询该该批次已经出库的数据
		flowGood, _ := GetNewStockFlowIsBatchNumberSix(patient_id, record_time, goods.GoodId, goods.ProjectId, tx)
		var out_count int64
		var out_count_one int64
		for _, item := range flowGood {
			out_count += item.Count
		}
		flowGoodTwo, _ := GetNewStockFlowIsBatchNumberFour(patient_id, record_time, goods.GoodId, goods.ProjectId, tx)
		for _, item := range flowGoodTwo {
			out_count_one += item.Count
		}
		//如果出库数量 大于 历史出库数据 新增1条流水
		if 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 := CreateNewStockFlowOne(stockFlow, tx)
			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 := ModifyNewGoodSumCount(goods.StorehouseId, stock_number, orgID, goods.GoodId, tx)

			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 count < out_count-out_count_one {

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

			//创建退库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindNewAllCancelStockTotal(orgID, tx)
			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 := GetNewCancelStockDetailByOrderNumberOne(record_time, orgID, tx)
			if msgerrkonde == gorm.ErrRecordNotFound {
				AddNewSigleCancelStock(&cancelStock, tx)
			}

			cancel, _ := GetNewLastCancelStockById(orgID, tx)

			manufacturer, _ := GetNewManufactureById(warehouse.Manufacturer, tx)
			deaerler, _ := GetNewDealerById(warehouse.Dealer, tx)
			cancelStockInfo := models.CancelStockInfo{
				GoodId:          goods.GoodId,
				CancelStockId:   cancel.ID,
				GoodTypeId:      goods.GoodTypeId,
				Count:           out_count - out_count_one - 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, _ := FindeNewGoodInfo(orgID, goods.ProjectId, tx)
				cancelStockInfo.Price = goodsInfo.PackingPrice
			}
			CreateNewCancelStockInfoOne(&cancelStockInfo, tx)

			cancelInfo, _ := GetLastNewCancelStockInfoByGoodId(goods.GoodId, tx)

			flow := models.VmStockFlow{
				WarehousingId:           warehouse.ID,
				GoodId:                  goods.GoodId,
				Number:                  warehouse.Number,
				LicenseNumber:           warehouse.LicenseNumber,
				Count:                   out_count - 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.Price,
				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, _ := FindeNewGoodInfo(orgID, goods.ProjectId, tx)
				flow.Price = goodsInfo.PackingPrice
				flow.BuyPrice = goodsInfo.BuyPrice
			}
			CreateNewStockFlowOne(flow, tx)

			//退库数量增加
			UpdateNewSumAddCancelCount(orgID, goods.GoodId, goods.StorehouseId, flow.Count, tx)
			//实际出库减少
			ModifyNewAddGoodSumCount(goods.StorehouseId, flow.Count, orgID, goods.GoodId, tx)
		}

		errWarehouse := UpdateNewGoodWarehouseOutById(goods.ID, warehouse.ID, orgID, sum_count, tx)
		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,
		GoodTypeId:   goods.GoodTypeId,
		GoodId:       goods.GoodId,
		PatientId:    goods.PatientId,
		RecordDate:   goods.RecordDate,
		UserOrgId:    orgID,
		Ctime:        time.Now().Unix(),
		Creater:      creator,
		Status:       1,
		StorehouseId: goods.StorehouseId,
		ProjectId:    goods.ProjectId,
	}
	ConsumableNewPrescriptionDelivery(orgID, patient_id, record_time, prepare, warehouseOut, creator, count, tx)

	return nil
}