back/internal/v2/logic/pay/public.go

package pay

import (
	"recook/internal/dbc"
	"recook/internal/define"
	"recook/internal/model/order"
	"recook/internal/v2/model/recook/after"
	"recook/internal/v2/model/recook/goods"
	manage "recook/internal/v2/model/recook/order"
	user2 "recook/internal/v2/model/recook/user"

	"github.com/golangkit/formatime"
	"github.com/jinzhu/gorm"
	"github.com/shopspring/decimal"
)

func AsyncRefundSuccessCallback(refundNo string) error {
	tx := dbc.DB.Begin()
	{
		var asGoods after.RecookAfterSalesGoodsModel
		if err := tx.First(&asGoods, "refund_no = ?", refundNo).Error; err != nil {
			tx.Rollback()
			return err
		}

		if err := privateRefund(tx, &asGoods); err != nil {
			tx.Rollback()
			return err
		}
	}
	tx.Commit()

	return nil
}

func SyncRefundSuccessCallback(tx *gorm.DB, asGoods *after.RecookAfterSalesGoodsModel) error {
	return privateRefund(tx, asGoods)
}

func privateRefund(tx *gorm.DB, asGoods *after.RecookAfterSalesGoodsModel) error {
	var orderGoods manage.RecookOrderGoodsDetailModel
	if err := tx.First(&orderGoods, asGoods.OrderGoodsId).Error; err != nil {
		return err
	}

	var orderInfo manage.RecookOrderInfoModel
	if err := tx.First(&orderInfo, asGoods.OrderId).Error; err != nil {
		return err
	}

	var myWallet user2.RecookUserWalletModel

	if err := tx.First(&myWallet, "user_id = ?", orderInfo.UserId).Error; err != nil {
		return err
	}

	if err := tx.Model(&asGoods).Updates(after.RecookAfterSalesGoodsModel{
		RefundStatus: 2,
		FinishTime:   formatime.NewSecondNow(),
	}).Error; err != nil {
		return err
	}

	if err := tx.Model(&orderGoods).Updates(manage.RecookOrderGoodsDetailModel{
		RefundStatus: 2,
		IsClosed:     1,
	}).Error; err != nil {
		return err
	}

	// 排除订单取消时活动商品库存-1导致数据溢出的情况
	var sku goods.RecookGoodsSkuModel
	tx.First(&sku, orderGoods.SkuId)
	var salesVolume = sku.SalesVolume - orderGoods.Quantity
	if orderInfo.OrderType == 2 {
		salesVolume = sku.SaleVolume2 - orderGoods.Quantity
	}
	if sku.SalesVolume == 0 {
		salesVolume = 0
	}
	if orderInfo.OrderType == 1 {
		if err := tx.Model(&sku).Updates(map[string]interface{}{
			"sales_volume": salesVolume,
			"inventory":    sku.Inventory + orderGoods.Quantity,
		}).Error; err != nil {
			return err
		}
	} else {
		if err := tx.Model(&sku).Updates(map[string]interface{}{
			"sale_volume2":   salesVolume,
			"sale_inventory": sku.SaleInventory + orderGoods.Quantity,
		}).Error; err != nil {
			return err
		}
	}

	// 没有申请过售后的商品数量
	var totalGoodsCount uint
	tx.Table((&manage.RecookOrderGoodsDetailModel{}).TableName()).Where("order_id = ?", asGoods.OrderId).Count(&totalGoodsCount)

	var refundGoodsCount uint
	tx.Table((&manage.RecookOrderGoodsDetailModel{}).TableName()).Where("order_id = ? AND refund_status = 2", asGoods.OrderId).Count(&refundGoodsCount)

	if totalGoodsCount == refundGoodsCount {
		if err := tx.Model(&orderInfo).Updates(manage.RecookOrderInfoModel{
			Status: 5,
		}).Error; err != nil {
			tx.Rollback()
			return err
		}
	}
	var profit []order.Profit
	tx.Find(&profit, "order_id = ?", asGoods.OrderId)

	var ods order.GoodsDetail
	tx.First(&ods, "id = ?", asGoods.OrderGoodsId)
	base := decimal.Zero
	if orderInfo.OrderType == 1 {
		base = ods.GetBase().Mul(decimal.NewFromInt(int64(ods.Quantity)))
	} else {
		v := ods
		extra := v.UnitPrice.Sub(v.PurchasePrice).Mul(decimal.NewFromFloat(0.2)).Round(2)
		base = base.Add(extra.Mul(decimal.NewFromFloat(define.Coefficient)).Round(2).Mul(decimal.NewFromInt(int64(v.Quantity))))
	}

	for i, v := range profit {
		b2 := v.Base.Sub(base)
		patch := map[string]interface{}{
			"base":   b2,
			"income": b2.Mul(v.Type.GetProfit()).Round(2),
			"status": 1,
		}
		if err := tx.Model(&profit[i]).Updates(patch).Error; err != nil {
			return err
		}
	}

	return nil
}