kpt_xdmy/apiserver/service/purchase.go

package service

import (
	"context"
	"fmt"
	modernPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/xdmy"
	"gitee.com/xuyiping_admin/pkg/xerr"
	"github.com/pkg/errors"
	"gorm.io/gorm"
	"kpt.xdmy/apiserver/model"
	"strconv"
)

// CreateSpecialtyPurchase 创建特殊申购信息
func CreateSpecialtyPurchase(ctx context.Context, req *modernPb.SparePartsRequisitionsRequest) error {
	var bigPartPurchaseId int64 = 0
	// 赠品
	defer func() {
		if req.PurchaseType == modernPb.PurchaseType_Complimentary_Item {
			if err := SpecialtyToProcure(bigPartPurchaseId); err != nil {
				fmt.Println("SpecialtyToProcure===>", bigPartPurchaseId)
			}
		}
	}()

	return s.d.DB.Transaction(func(tx *gorm.DB) error {
		newBigPartPurchase := model.NewBigPartPurchase(
			int64(req.PastureId), int64(req.DepartmentId), int64(req.EmployeId),
			int64(req.ProviderId), int64(req.FunderId),
			req.PurchaseType, req.OrderNumber, req.CreateTime, req.ProviderName,
		)

		if err := tx.Model(new(model.BigPartPurchase)).Create(newBigPartPurchase).Error; err != nil {
			return xerr.WithStack(err)
		}

		partPurchaseList := make([]*model.PartPurchase, 0)
		for _, v := range req.SpotList {
			amount, _ := strconv.Atoi(v.Amount)
			partPurchaseList = append(partPurchaseList, model.NewPartPurchase(
				newBigPartPurchase.Id, int64(req.PastureId), int64(v.PartId), int64(v.BrandId), int64(amount),
				int64(v.ContractId), v.PartCode, v.PartName, v.Specification, v.Unit, v.Purpose, v.Price,
				float64(v.StorageAmount)))
		}

		if len(partPurchaseList) > 0 {
			if err := tx.Model(new(model.PartPurchase)).Create(partPurchaseList).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		bigPartPurchaseId = newBigPartPurchase.Id
		return nil
	})
}

// SpecialtyToProcure 特殊申购-自动流转采购单
func SpecialtyToProcure(id int64) error {
	// 获取特殊申购单信息
	newBigPartPurchase := &model.BigPartPurchase{Id: id}
	if err := s.d.DB.Model(new(model.BigPartPurchase)).First(newBigPartPurchase).Error; err != nil {
		return xerr.WithStack(err)
	}
	// 过滤掉非特殊申购的数据
	if newBigPartPurchase.PurchaseType <= 0 {
		return nil
	}

	newPartPurchase := make([]*model.PartPurchase, 0)
	if err := s.d.DB.Model(new(model.PartPurchase)).Where("bigId = ?", newBigPartPurchase.Id).Find(&newPartPurchase).Error; err != nil {
		return xerr.WithStack(err)
	}

	return s.d.DB.Transaction(func(tx *gorm.DB) error {
		// 获取申购单号
		var orderCode string
		if err := tx.Raw(fmt.Sprintf("CALL createCodeN(%d,'%s')", newBigPartPurchase.PastureId, "CG")).Scan(&orderCode).Error; err != nil {
			return xerr.WithStack(err)
		}

		historyBigBuyDetail := &model.BigBuyDetail{}
		if err := tx.Model(new(model.BigBuyDetail)).Where("buyeCode = ?", orderCode).First(historyBigBuyDetail).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
		// 避免重复提交
		if historyBigBuyDetail.BuyeCode == orderCode {
			return xerr.Customf("该申购单号已经存在:%s", orderCode)
		}

		newBigBuyDetail := model.NewBigBuyDetail(
			orderCode, newBigPartPurchase.OrderNumber, newBigPartPurchase.ProviderName, newBigPartPurchase.PastureId,
			newBigPartPurchase.ProviderId, newBigPartPurchase.EmployeId, newBigPartPurchase.PurchaseType)
		if err := tx.Model(new(model.BigBuyDetail)).Create(newBigBuyDetail).Error; err != nil {
			return xerr.WithStack(err)
		}

		buyDetailList := make([]*model.BuyDetail, 0)
		var allAmount int64 = 0
		for _, v := range newPartPurchase {
			contractId, _ := strconv.Atoi(v.ContractId)
			newContract := &model.Contract{}
			if err := tx.Model(new(model.Contract)).Where("id = ?", contractId).First(newContract).Error; err != nil {
				fmt.Println("newContract", err)
			}

			bigContract := &model.BigContract{}
			if err := tx.Model(new(model.BigContract)).Where("id = ?", newContract.BigID).First(bigContract).Error; err != nil {
				fmt.Println("CreateSpecialtyPurchase", err)
			}

			department := &model.Department{}
			if err := tx.Model(new(model.Department)).Where("pastureId = ?", newBigPartPurchase.PastureId).
				Where("id = ?", newBigPartPurchase.DepartmentId).First(department).Error; err != nil {
				return xerr.WithStack(err)
			}

			price, _ := strconv.ParseFloat(v.Price, 64)
			buyDetailList = append(buyDetailList, model.NewBuyDetail(int64(newBigBuyDetail.ID), int64(newBigBuyDetail.PastureID),
				v.Amount, int64(contractId), v.BrandId, newContract.PartCode, bigContract.ContractCode, v.Purpose, department.Name, price))
			allAmount += v.Amount
		}

		if err := s.d.DB.Model(new(model.BigBuyDetail)).Where("id = ?", newBigBuyDetail.ID).Updates(map[string]interface{}{
			"zeroCou": allAmount,
		}).Error; err != nil {
			return xerr.WithStack(err)
		}

		if len(buyDetailList) > 0 {
			if err := tx.Model(new(model.BuyDetail)).Create(buyDetailList).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		return nil
	})
}