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, advice *models.DoctorAdvice) (err error) {
	// 1.判断药品是否来自专用字典的药品库
	// 2.判断当天当前机构有没有创建出库单，没有则创建
	// 3.创建出库流程
	// 3.1 实现先进先出逻辑 由于药品执行后，不可以修改和删除，所以不考虑出库后的退库和修改出库数量等
	isHasWay := false
	record_time := int64(0)
	if advice.Way == 1 {
		isHasWay = true
		record_time = advice.RecordDate
	}
	if isHasWay {
		//判断当天当前机构有没有创建出库单，没有则创建
		out, err := FindDrugStockOutByIsSys(orgID, 1, record_time)
		if err == gorm.ErrRecordNotFound {
			timeStr := time.Now().Format("2006-01-02")
			timeArr := strings.Split(timeStr, "-")
			total, _ := FindAllDrugWarehouseOut(orgID)
			total = total + 1
			warehousing_out_order := strconv.FormatInt(orgID, 10) + timeArr[0] + timeArr[1] + timeArr[2] + "000"
			number, _ := strconv.ParseInt(warehousing_out_order, 10, 64)
			number = number + total
			warehousing_out_order = "YPCKD" + strconv.FormatInt(number, 10)
			// creater := adminUserInfo.AdminUser.Id
			warehouseOut := models.DrugWarehouseOut{
				WarehouseOutOrderNumber: warehousing_out_order,
				OperationTime:           time.Now().Unix(),
				OrgId:                   orgID,
				Creater:                 0,
				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)
	if advice.PrescribingNumberUnit == drup.MaxUnit {
		deliver_number = count * drup.MinNumber
	} else {
		deliver_number = count
	}

	// 根据先进先出原则，查询最先入库的批次，进行出库
	// 如果没有对应的库存，则报错
	warehouse, err := FindLastDrugWarehousingInfoByID(advice.DrugId)
	fmt.Println("查询222222222222222222222222222222222222222222222222", err)
	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:                  "",
			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 {
			// prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
			// count, _ := strconv.ParseInt(prescribingNumber, 10, 64)
			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,
		}
		// prescribingNumber := strconv.FormatFloat(math.Abs(item.PrescribingNumber), 'f', 0, 64)
		// count, _ := strconv.ParseInt(prescribingNumber, 10, 64)
		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
		advice.PrescribingNumber = float64(prescribingNumber_two_temp)
		advice.PrescribingNumberUnit = drup.MinUnit
		DrugDeliverInfo(orgID, prescribingNumber, warehouseout, drup, advice)
	}
	return
}