XT_New/service/warhouse_service.go

package service

import (
	"XT_New/models"
	"XT_New/models/service"
	"XT_New/utils"
	"errors"
	"fmt"
	_ "fmt"
	"github.com/jinzhu/gorm"
	"math"
	"strconv"
	"strings"
	"time"
)

// 药品出库

func DrugsDelivery(orgID int64, 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
	}
	fmt.Println("isHasway99999999999999999999999999999999", isHasWay)
	if isHasWay {
		//判断当天当前机构有没有创建出库单，没有则创建
		out, err := FindDrugStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
			// creater := adminUserInfo.AdminUser.Id
			warehouseOut := models.DrugWarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 creater,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        record_time,
				Dealer:                  0,
				Manufacturer:            0,
				Type:                    1,
				IsSys:                   1,
			}
			err := AddSigleDrugWarehouseOut(&warehouseOut)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

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

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

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

	}

	return
}

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

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

	prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64)
	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)

	fmt.Println("单位1", advice.PrescribingNumber)
	fmt.Println("单位2", drup.MaxUnit)
	if advice.PrescribingNumberUnit == drup.MaxUnit {
		deliver_number = count * drup.MinNumber
	} else {
		deliver_number = count
	}

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

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)

	if err != nil {

		return err
	}

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

	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	fmt.Println("stock_number999999999999", stock_number)
	fmt.Println("deliver_number88888888888", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = deliver_number
		warehouseOutInfo.CountUnit = drup.MinUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)

		if errOne != nil {
			return errOne
		} else {

			details := &models.DrugAutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               advice.PatientId,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              advice.RecordDate,
				OrgId:                   orgID,
				DrugId:                  advice.DrugId,
				Count:                   deliver_number,
				CountUnit:               drup.MinUnit,
			}
			errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			if errTwo != nil {
				return errTwo
			}
		}
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		if advice.PrescribingNumberUnit == drup.MinUnit {
			maxNumber = count / drup.MinNumber
			minNumber = count % drup.MinNumber
		} else {
			maxNumber = count
		}

		if warehouse.StockMaxNumber < maxNumber {

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

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

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

		if warehouse.StockMaxNumber < 0 {
			return errors.New("库存数量不足")
		}
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		return nil
	} else {
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = stock_number

		warehouseOutInfo.CountUnit = drup.MinUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		} else {
			details := &models.DrugAutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               advice.PatientId,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              advice.RecordDate,
				OrgId:                   orgID,
				DrugId:                  advice.DrugId,
				Count:                   stock_number,
				CountUnit:               drup.MinUnit,
			}
			errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			if errTwo != nil {
				return errTwo
			}
		}
		// 出库完成后，要将该批次库存清零
		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number
		overPlusNumber := float64(prescribingNumber_two_temp)
		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
		advice.PrescribingNumberUnit = drup.MinUnit

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

	return
}

// 药品出库

func HisDrugsDelivery(orgID int64, creater int64, advice *models.HisDoctorAdviceInfo) (err error) {
	// 1.判断药品是否来自专用字典的药品库
	// 2.判断当天当前机构有没有创建出库单，没有则创建
	// 3.创建出库流程
	// 3.1 实现先进先出逻辑 由于药品执行后，不可以修改和删除，所以不考虑出库后的退库和修改出库数量等
	isHasWay := false
	record_time := int64(0)
	isHasWay = true
	record_time = advice.RecordDate
	if isHasWay {
		//判断当天当前机构有没有创建出库单，没有则创建
		out, err := FindDrugStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
			// creater := adminUserInfo.AdminUser.Id
			warehouseOut := models.DrugWarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 creater,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        record_time,
				Dealer:                  0,
				Manufacturer:            0,
				Type:                    1,
				IsSys:                   1,
			}
			err := AddSigleDrugWarehouseOut(&warehouseOut)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

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

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

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

	}

	return
}

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

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

	prescribingNumber_temp := strconv.FormatFloat(math.Abs(prescribingNumber), 'f', 0, 64)
	count, _ := strconv.ParseInt(prescribingNumber_temp, 10, 64)
	fmt.Println("单位99999999999999999999999999", advice.PrescribingNumberUnit)
	fmt.Println("drup777777777777766666666", drup.MaxUnit)
	if advice.PrescribingNumberUnit == drup.MaxUnit {
		deliver_number = count * drup.MinNumber
	} else {
		deliver_number = count
	}

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

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)

	if err != nil {

		return err
	}

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

	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	fmt.Println("拆零数量2222222222222222222", stock_number)
	fmt.Println("出库数量55555555555555555555", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = deliver_number
		warehouseOutInfo.CountUnit = advice.PrescribingNumberUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)

		if errOne != nil {
			return errOne
		} else {

			details := &models.DrugAutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               advice.PatientId,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              advice.RecordDate,
				OrgId:                   orgID,
				DrugId:                  advice.DrugId,
				Count:                   deliver_number,
				CountUnit:               advice.PrescribingNumberUnit,
			}
			errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			if errTwo != nil {
				return errTwo
			}
		}
		// 出库完成后，要减去对应批次的库存数量
		// 判断处方里药品单位是拆零单位还是包装单位,	如果是拆零单位，则根据规格，将拆零数量转为包装数量
		var maxNumber int64 = 0
		var minNumber int64 = 0
		if advice.PrescribingNumberUnit == drup.MinUnit {
			maxNumber = count / drup.MinNumber
			minNumber = count % drup.MinNumber
		} else {
			maxNumber = count
		}

		if warehouse.StockMaxNumber < maxNumber {

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

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

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

		if warehouse.StockMaxNumber < 0 {
			return errors.New("库存数量不足")
		}
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		return nil
	} else {
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   1,
			SysRecordTime:           advice.RecordDate,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = stock_number

		warehouseOutInfo.CountUnit = drup.MinUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		} else {
			details := &models.DrugAutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               advice.PatientId,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              advice.RecordDate,
				OrgId:                   orgID,
				DrugId:                  advice.DrugId,
				Count:                   stock_number,
				CountUnit:               drup.MinUnit,
			}
			errTwo := AddSigleDrugAutoReduceRecordInfo(details)
			if errTwo != nil {
				return errTwo
			}
		}
		// 出库完成后，要将该批次库存清零
		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number
		overPlusNumber := float64(prescribingNumber_two_temp)
		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
		advice.PrescribingNumberUnit = drup.MinUnit

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

	return
}

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

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

	fmt.Println("单位1", advice.CountUnit)
	fmt.Println("单位2", drup.MaxUnit)
	if advice.CountUnit == drup.MaxUnit {
		deliver_number = prescribingNumber * drup.MinNumber
	} else {
		deliver_number = prescribingNumber
	}

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

	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)

	if err != nil {

		return err
	}

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

	stock_number = warehouse.StockMaxNumber*drup.MinNumber + warehouse.StockMinNumber
	fmt.Println("88i8uu7777777777777777777777777777", stock_number)
	fmt.Println("77777544656666666666666666", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = deliver_number
		warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)

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

		if warehouse.StockMaxNumber < maxNumber {

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

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

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

		if warehouse.StockMaxNumber < 0 {
			return errors.New("库存数量不足")
		}
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		return nil
	} else {
		// 当该批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.DrugWarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseout.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseout.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   0,
			SysRecordTime:           advice.Ctime,
			DrugId:                  advice.DrugId,
		}

		warehouseOutInfo.Count = stock_number

		warehouseOutInfo.CountUnit = advice.CountUnit

		errOne := AddSigleDrugWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		// 出库完成后，要将该批次库存清零
		warehouse.StockMaxNumber = 0
		warehouse.StockMinNumber = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateDrugWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		prescribingNumber_two_temp := deliver_number - stock_number

		advice.CountUnit = drup.MinUnit

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

	return
}

// 耗材出库
func ConsumablesDeliveryTotal(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods, goodOne []*models.NewDialysisBeforePrepareGoods) (err error) {

	//查询该患者当天已经出库的耗材信息
	goods_yc, _ := FindConsumablesByDateTwo(orgID, patient_id, record_time)
	// 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的
	for i := len(goods_yc) - 1; i >= 0; i-- {
		goods_yc_temp := goods_yc[i]
		for j := len(goods) - 1; j >= 0; j-- {
			goods_temp := goods[j]
			// 已经出库和新请求出库都存在该耗材，则判断出库数量，分成是继续出库，还是删除出库
			if goods_yc_temp.GoodTypeId == goods_temp.GoodTypeId && goods_yc_temp.GoodId == goods_temp.GoodId {
				// 已经出库和新请求出库的出库数量一致，则清除两个结构体里的数据（既不出库，也不删除出库）
				if goods_yc_temp.Count == goods_temp.Count {
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					goods = append(goods[:j], goods[j+1:]...)
					break
				}
				// 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库
				if goods_yc_temp.Count > goods_temp.Count {

					temp_count := goods_yc_temp.Count - goods_temp.Count
					goods_yc[i].Count = temp_count
					goods = append(goods[:j], goods[j+1:]...)
					break
				}
				// 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库
				if goods_yc_temp.Count < goods_temp.Count {
					temp_count := goods_temp.Count - goods_yc_temp.Count
					//fmt.Println("988888888888888", temp_count)
					goods[j].Count = temp_count
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					//fmt.Println("888888888", goods_yc)
					break
				}
			}
		}
	}

	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
	// goods 这个数据就是需要出库的耗材的数据(新增的数据)
	fmt.Println("goods222222222222", goods)
	fmt.Println("goodsy999999999999", goods_yc)
	if len(goods) > 0 {
		out, err := FindStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			//没有记录，则创建出库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
			warehouseOut := models.WarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 0,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        record_time,
				Dealer:                  0,
				Manufacturer:            0,
				Type:                    1,
				IsSys:                   1,
			}
			err := AddSigleWarehouseOut(&warehouseOut)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

		for _, item := range goods {
			var newCount int64 = 0
			for _, it := range goodOne {
				if item.GoodTypeId == it.GoodTypeId && item.GoodId == it.GoodId {
					newCount = it.Count
				}
			}
			prepare := models.DialysisBeforePrepare{
				GoodTypeId: item.GoodTypeId,
				GoodId:     item.GoodId,
				Count:      item.Count,
			}

			ConsumablesDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
		}

	}

	if len(goods_yc) > 0 {
		for _, good_yc := range goods_yc {
			out, _ := FindStockOutByIsSys(orgID, 1, record_time)
			ConsumablesDeliveryDelete(orgID, patient_id, record_time, good_yc, &out)
		}
	}

	return nil
}

//耗材出库
func ConsumablesDelivery(orgID int64, patient_id int64, record_time int64, goods *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut, count int64) (err error) {
	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0

	deliver_number = goods.Count
	fmt.Println("添加数量", deliver_number)

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

	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
	fmt.Println("库存数量", warehouse.StockCount)
	if err != nil {
		return
	}

	// 将该批次的剩余库存数量转换为拆零数量
	stock_number = warehouse.StockCount

	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  "",
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            0,
			Dealer:                  0,
			IsSys:                   1,
			SysRecordTime:           record_time,
			GoodTypeId:              goods.GoodTypeId,
			GoodId:                  goods.GoodId,
			PatientId:               patient_id,
		}
		warehouseOutInfo.Count = count
		stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price
		errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		} else {
			details := models.BloodAutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               patient_id,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              record_time,
				OrgId:                   orgID,
				GoodId:                  goods.GoodId,
				GoodTypeId:              goods.GoodTypeId,
				Count:                   count,
			}
			//查询当天耗材是否已经存在数据
			_, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)

			if errcode == gorm.ErrRecordNotFound {
				errTwo := CreateAutoReduceRecord(&details)
				if errTwo != nil {
					return errTwo
				}
			} else if errcode == nil {
				DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, goods.GoodId, goods.GoodTypeId)
				CreateAutoReduceRecord(&details)
			}
		}

		maxNumber = goods.Count

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

		warehouse.StockCount = warehouse.StockCount - maxNumber

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

		if warehouse.StockCount < 0 {
			return errors.New("库存数量不足")
		}
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}

		return nil
	} else {
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		goods.Count = deliver_number - stock_number

		ConsumablesDelivery(orgID, patient_id, record_time, goods, warehouseOut, count)

	}
	return nil
}

//耗材出库删除
func ConsumablesDeliveryDelete(orgID int64, patient_id int64, record_time int64, good_yc *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut) (err error) {
	// 先根据相关信息查询当天该耗材的出库信息
	warehouseOutInfos, err := FindStockOutInfoByStock(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time, patient_id)
	if err != nil {
		return err
	}

	var delete_count int64 = 0

	for _, ware := range warehouseOutInfos {
		// 判断当前出库的数据和删除出库数量
		if good_yc.Count <= ware.Count {
			delete_count = good_yc.Count
		} else {
			delete_count = ware.Count
		}
		// 在出库记录表里记录退库详情
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			//WarehouseInfoId:		 warehouse.ID,
			Status:        1,
			Ctime:         time.Now().Unix(),
			Remark:        "",
			OrgId:         orgID,
			Type:          1,
			Manufacturer:  0,
			Dealer:        0,
			IsSys:         2,
			SysRecordTime: record_time,
			GoodTypeId:    good_yc.GoodTypeId,
			GoodId:        good_yc.GoodId,
			PatientId:     patient_id,
		}
		warehouseOutInfo.Count = ware.Count - delete_count
		stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price
		errOne := UpdateAutoMaticReduceDetail(good_yc.GoodId, good_yc.GoodTypeId, record_time, patient_id, orgID, warehouseOutInfo)
		if errOne != nil {
			return errOne
		} else {
			details := &models.AutomaticReduceDetail{
				WarehouseOutId:          warehouseOutInfo.ID,
				WarehouseOutOrderNumber: warehouseOutInfo.WarehouseOutOrderNumber,
				PatientId:               patient_id,
				Ctime:                   time.Now().Unix(),
				Mtime:                   time.Now().Unix(),
				Status:                  1,
				RecordTime:              record_time,
				OrgId:                   orgID,
				GoodId:                  good_yc.GoodId,
				GoodTypeId:              good_yc.GoodTypeId,
				Count:                   warehouseOutInfo.Count,
				Type:                    2,
			}
			//查询是否当天已经存在数据
			_, errcode := GetAutoMaticReduceDetail(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId)
			if errcode == gorm.ErrRecordNotFound {
				errTwo := AddSigleAutoReduceRecordInfo(details)
				if errTwo != nil {
					return errTwo
				}
			} else if errcode == nil {
				DeleteAutoRedeceDetailTwo(orgID, patient_id, record_time, good_yc.GoodId, good_yc.GoodTypeId)

				AddSigleAutoReduceRecordInfo(details)
			}
		}

		// 删除出库完成后，要增加对应批次的库存数量

		errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count)
		if errThree != nil {
			return errThree
		}

		// 增加了对应的库存后，看看还有多少需要退库的
		good_yc.Count = good_yc.Count - delete_count
		if good_yc.Count == 0 {
			return nil
		}
	}

	if good_yc.Count == 0 {
		return nil
	} else {
		return errors.New("退库和出库数据不匹配")
	}
}

func GetAutoReduceRecordInfoByPatientId(orgid int64, patient_id int64, recordTime int64) (autoReduce []*models.AutomaticReduceDetail, err error) {

	err = XTReadDB().Model(&autoReduce).Where("org_id = ? and patient_id = ? and record_time = ? and status = 1", orgid, patient_id, recordTime).Find(&autoReduce).Error
	return autoReduce, err
}

func DeleteDialysisBefor(orgid int64, patient_id int64, record_date int64, goodid int64, goodtypeid int64) error {
	prepare := models.DialysisBeforePrepare{}
	err := XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and status = 1 and good_id = ? and good_type_id = ?", orgid, patient_id, record_date, goodid, goodtypeid).Updates(map[string]interface{}{"status": 0, "count": 0, "mtime": time.Now().Unix()}).Error
	return err
}

func DeleteDialysisBeforThree(orgid int64, patient_id int64, record_date int64) error {
	prepare := models.DialysisBeforePrepare{}
	err := XTWriteDB().Model(&prepare).Where("user_org_id = ? and patient_id = ? and record_date = ? and status = 1", orgid, patient_id, record_date).Updates(map[string]interface{}{"status": 0, "count": 0, "mtime": time.Now().Unix()}).Error
	return err
}

func ConsumablesDeliveryTotalOne(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods, goodOne []*models.NewDialysisBeforePrepareGoods) (err error) {

	//查询该患者当天已经出库的耗材信息
	goods_yc, _ := FindConsumablesByDateTwo(orgID, patient_id, record_time)
	for _, item := range goods_yc {
		fmt.Println("item0000000000000", item.Count)
	}
	for _, item := range goods {
		fmt.Println("item1111111111111", item.Count)
	}
	// 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的
	for i := len(goods_yc) - 1; i >= 0; i-- {
		goods_yc_temp := goods_yc[i]
		for j := len(goods) - 1; j >= 0; j-- {
			goods_temp := goods[j]
			// 已经出库和新请求出库都存在该耗材，则判断出库数量，分成是继续出库，还是删除出库
			if goods_yc_temp.GoodTypeId == goods_temp.GoodTypeId && goods_yc_temp.GoodId == goods_temp.GoodId {
				// 已经出库和新请求出库的出库数量一致，则清除两个结构体里的数据（既不出库，也不删除出库）
				if goods_yc_temp.Count == goods_temp.Count {
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					goods = append(goods[:j], goods[j+1:]...)
				}
				fmt.Println("998888888888888", goods_yc_temp.Count)
				fmt.Println("7777777777777777", goods_temp.Count)
				// 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库
				if goods_yc_temp.Count > goods_temp.Count {
					fmt.Println("进来了是吗")
					temp_count := goods_yc_temp.Count - goods_temp.Count

					goods_yc[i].Count = temp_count
					goods = append(goods[:j], goods[j+1:]...)
					break
				}
				fmt.Println("555555555555", goods_yc_temp.Count)
				fmt.Println("444444444444", goods_temp.Count)
				// 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库
				if goods_yc_temp.Count < goods_temp.Count {
					temp_count := goods_temp.Count - goods_yc_temp.Count
					fmt.Println("988888888888888", temp_count)
					goods[j].Count = temp_count
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					fmt.Println("888888888", goods_yc)
				}
			}
		}
	}

	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
	// goods 这个数据就是需要出库的耗材的数据
	fmt.Println("goods222222222222", goods)
	fmt.Println("goodsy999999999999", goods_yc)
	if len(goods) > 0 {
		out, err := FindStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			//没有记录，则创建出库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
			warehouseOut := models.WarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 0,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        record_time,
				Dealer:                  0,
				Manufacturer:            0,
				Type:                    1,
				IsSys:                   1,
			}
			err := AddSigleWarehouseOut(&warehouseOut)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

		for _, item := range goods {
			for _, it := range goodOne {
				if item.GoodTypeId == it.GoodTypeId && it.GoodId == it.GoodId {
					it.NewCount = item.Count
				}
			}
		}

		for _, item := range goodOne {
			//prepare := models.DialysisBeforePrepare{
			//	GoodTypeId: item.GoodTypeId,
			//	GoodId:     item.GoodId,
			//	Count:      item.Count,
			//	NewCount:   item.NewCount,
			//}
			info := models.WarehouseOutInfo{
				GoodTypeId: item.GoodTypeId,
				GoodId:     item.GoodId,
				Count:      item.Count,
			}
			ConsumablesDeliveryOne(orgID, record_time, &info, &out, item.Count)
		}
	}

	if len(goods_yc) > 0 {
		for _, good_yc := range goods_yc {
			out, _ := FindStockOutByIsSys(orgID, 1, record_time)
			ConsumablesDeliveryDeleteOne(orgID, record_time, good_yc, &out)
		}
	}

	return nil
}

//耗材出库
func ConsumablesDeliveryOne(orgID int64, record_time int64, goods *models.WarehouseOutInfo, warehouseOut *models.WarehouseOut, count int64) (err error) {
	// 判断处方里药品单位是拆零单位还是包装单位,	如果是包装单位，则根据规格，将包装数量转为拆零数量
	var deliver_number int64 = 0
	var stock_number int64 = 0
	var maxNumber int64 = 0

	deliver_number = goods.Count
	fmt.Println("添加数量", deliver_number)

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	warehouse, err := FindFirstWarehousingInfoByStock(goods.GoodId, goods.GoodTypeId)
	fmt.Println("err222222222222222222222", warehouse.StockCount)
	if err != nil {
		fmt.Println("232323232323进来")
		return err
	}

	// 将该批次的剩余库存数量转换为拆零数量
	stock_number = warehouse.StockCount
	fmt.Println("3434343434343434", stock_number)
	fmt.Println("8888888888888888888", deliver_number)
	// 当库存数量大于或等于出库数量的话，则正常出库该批次
	if stock_number >= deliver_number {
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  goods.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            goods.Manufacturer,
			Dealer:                  goods.Dealer,
			IsSys:                   0,
			SysRecordTime:           record_time,
			GoodTypeId:              goods.GoodTypeId,
			GoodId:                  goods.GoodId,
			ExpiryDate:              goods.ExpiryDate,
			ProductDate:             goods.ProductDate,
			Number:                  goods.Number,
			Price:                   goods.Price,
		}
		warehouseOutInfo.Count = goods.Count
		stockInInfo, _ := FindLastStockInInfoRecord(goods.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price

		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 {
			fmt.Println("进来33232323232232323233232", warehouse.StockCount)
			return errors.New("库存数量不足")
		}
		return nil
	} else {
		// 当改批次的库存数量小于出库数量的话，则先把该批次出库完后，再进行递归出库
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			WarehouseInfotId:        warehouse.ID,
			Status:                  1,
			Ctime:                   time.Now().Unix(),
			Remark:                  goods.Remark,
			OrgId:                   orgID,
			Type:                    1,
			Manufacturer:            goods.Manufacturer,
			Dealer:                  goods.Dealer,
			IsSys:                   0,
			SysRecordTime:           record_time,
			GoodTypeId:              goods.GoodTypeId,
			GoodId:                  goods.GoodId,
			ExpiryDate:              goods.ExpiryDate,
			ProductDate:             goods.ProductDate,
			Number:                  goods.Number,
			Price:                   goods.Price,
		}
		warehouseOutInfo.Count = stock_number
		stockInInfo, _ := service.FindLastStockInInfoRecord(goods.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price

		errOne := service.AddSigleWarehouseOutInfo(warehouseOutInfo)

		if errOne != nil {
			return errOne
		}
		// 出库完成后，要将该批次库存清零
		warehouse.StockCount = 0
		warehouse.Mtime = time.Now().Unix()
		errThree := UpDateWarehouseInfoByStock(&warehouse)
		if errThree != nil {
			return errThree
		}
		// 清零完该库存后，还有剩余出库未出完，进行对应的递归操作
		goods.Count = deliver_number - stock_number

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

	}
	return nil
}

//耗材出库删除
func ConsumablesDeliveryDeleteOne(orgID int64, record_time int64, good_yc *models.DialysisBeforePrepare, warehouseOut *models.WarehouseOut) (err error) {
	// 先根据相关信息查询当天该耗材的出库信息
	warehouseOutInfos, err := FindStockOutInfoByStockOne(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time)
	if err != nil {
		return err
	}

	var delete_count int64 = 0

	for _, ware := range warehouseOutInfos {
		// 判断当前出库的数据和删除出库数量
		if good_yc.Count <= ware.Count {
			delete_count = good_yc.Count
		} else {
			delete_count = ware.Count
		}
		// 在出库记录表里记录退库详情
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			//WarehouseInfoId:		 warehouse.ID,
			Status:        1,
			Ctime:         time.Now().Unix(),
			Remark:        "",
			OrgId:         orgID,
			Type:          1,
			Manufacturer:  0,
			Dealer:        0,
			IsSys:         0,
			SysRecordTime: record_time,
			GoodTypeId:    good_yc.GoodTypeId,
			GoodId:        good_yc.GoodId,
		}
		warehouseOutInfo.Count = delete_count
		stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price
		errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		// 删除出库完成后，要增加对应批次的库存数量

		errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count)
		if errThree != nil {
			return errThree
		}

		// 增加了对应的库存后，看看还有多少需要退库的
		good_yc.Count = good_yc.Count - delete_count
		if good_yc.Count == 0 {
			return nil
		}
	}

	if good_yc.Count == 0 {
		return nil
	} else {
		return errors.New("退库和出库数据不匹配")
	}
}

func ConsumablesDeliveryTotalSix(orgID int64, patient_id int64, record_time int64, goods []*models.DialysisBeforePrepareGoods, goodOne []*models.NewDialysisBeforePrepareGoods) (err error) {

	//查询该患者当天已经出库的耗材信息
	goods_yc, _ := FindConsumablesByDateThree(orgID, patient_id, record_time)
	// 和新请求的出库数据进行对比，分出那些是继续出库的，那些是需要删除出库的
	for i := len(goods_yc) - 1; i >= 0; i-- {
		goods_yc_temp := goods_yc[i]
		for j := len(goods) - 1; j >= 0; j-- {
			goods_temp := goods[j]
			// 已经出库和新请求出库都存在该耗材，则判断出库数量，分成是继续出库，还是删除出库
			if goods_yc_temp.GoodTypeId == goods_temp.GoodTypeId && goods_yc_temp.GoodId == goods_temp.GoodId {
				// 已经出库和新请求出库的出库数量一致，则清除两个结构体里的数据（既不出库，也不删除出库）
				if goods_yc_temp.Count == goods_temp.Count {
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					goods = append(goods[:j], goods[j+1:]...)
					break
				}
				// 如果已经出库的数量 大于 新请求出库的数量，则代表需要删除出库
				if goods_yc_temp.Count > goods_temp.Count {

					temp_count := goods_yc_temp.Count - goods_temp.Count
					goods_yc[i].Count = temp_count
					goods = append(goods[:j], goods[j+1:]...)
					break
				}
				// 如果已经出库的数量 小于 新请求出库的梳理，则代表需要增加出库
				if goods_yc_temp.Count < goods_temp.Count {
					temp_count := goods_temp.Count - goods_yc_temp.Count
					//fmt.Println("988888888888888", temp_count)
					goods[j].Count = temp_count
					goods_yc = append(goods_yc[:i], goods_yc[i+1:]...)
					//fmt.Println("888888888", goods_yc)
					break
				}
			}
		}
	}

	// goods_yc 这个数据就是需要已经出库了，但是现在需要删除出库的耗材数据
	// goods 这个数据就是需要出库的耗材的数据(新增的数据)
	fmt.Println("goods222222222222", goods)
	fmt.Println("goodsy999999999999", goods_yc)
	if len(goods) > 0 {
		out, err := FindStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			//没有记录，则创建出库单
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "CKD" + strconv.FormatInt(number, 10)
			warehouseOut := models.WarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 0,
				Ctime:                   time.Now().Unix(),
				Status:                  1,
				WarehouseOutTime:        record_time,
				Dealer:                  0,
				Manufacturer:            0,
				Type:                    1,
				IsSys:                   1,
			}
			err := AddSigleWarehouseOut(&warehouseOut)
			if err != nil {
				utils.TraceLog("创建出库单失败 err = %v", err)
				return err
			} else {
				out = warehouseOut
			}
		}

		for _, item := range goods {
			var newCount int64 = 0
			for _, it := range goodOne {
				if item.GoodTypeId == it.GoodTypeId && item.GoodId == it.GoodId {
					newCount = it.Count
				}
			}
			prepare := models.DialysisBeforePrepare{
				GoodTypeId: item.GoodTypeId,
				GoodId:     item.GoodId,
				Count:      item.Count,
			}

			ConsumablesDelivery(orgID, patient_id, record_time, &prepare, &out, newCount)
		}

	}

	if len(goods_yc) > 0 {
		for _, good_yc := range goods_yc {
			out, _ := FindStockOutByIsSys(orgID, 1, record_time)
			ConsumablesDeliveryDeleteThree(orgID, record_time, good_yc, &out)
		}
	}

	return nil
}

//耗材出库删除
func ConsumablesDeliveryDeleteThree(orgID int64, record_time int64, good_yc *models.BloodAutomaticReduceDetail, warehouseOut *models.WarehouseOut) (err error) {
	// 先根据相关信息查询当天该耗材的出库信息
	warehouseOutInfos, err := FindStockOutInfoByStockOne(orgID, good_yc.GoodTypeId, good_yc.GoodId, record_time)
	if err != nil {
		return err
	}

	var delete_count int64 = 0

	for _, ware := range warehouseOutInfos {
		// 判断当前出库的数据和删除出库数量
		if good_yc.Count <= ware.Count {
			delete_count = good_yc.Count
		} else {
			delete_count = ware.Count
		}
		// 在出库记录表里记录退库详情
		warehouseOutInfo := &models.WarehouseOutInfo{
			WarehouseOutOrderNumber: warehouseOut.WarehouseOutOrderNumber,
			WarehouseOutId:          warehouseOut.ID,
			//WarehouseInfoId:		 warehouse.ID,
			Status:        1,
			Ctime:         time.Now().Unix(),
			Remark:        "",
			OrgId:         orgID,
			Type:          1,
			Manufacturer:  0,
			Dealer:        0,
			IsSys:         0,
			SysRecordTime: record_time,
			GoodTypeId:    good_yc.GoodTypeId,
			GoodId:        good_yc.GoodId,
		}
		warehouseOutInfo.Count = delete_count
		stockInInfo, _ := FindLastStockInInfoRecord(good_yc.GoodId, orgID)
		warehouseOutInfo.Price = stockInInfo.Price
		errOne := AddSigleWarehouseOutInfo(warehouseOutInfo)
		if errOne != nil {
			return errOne
		}
		// 删除出库完成后，要增加对应批次的库存数量

		errThree := UpDateWarehouseInfoByStockDelete(ware.WarehouseInfotId, delete_count)
		if errThree != nil {
			return errThree
		}

		// 增加了对应的库存后，看看还有多少需要退库的
		good_yc.Count = good_yc.Count - delete_count
		if good_yc.Count == 0 {
			return nil
		}
	}

	if good_yc.Count == 0 {
		return nil
	} else {
		return errors.New("退库和出库数据不匹配")
	}
}