stat_center/models/refundOrderMod/refund.go

package refundOrderMod

import (
	"context"
	"errors"
	"fmt"
	"stat/common/log"
	"stat/common/mongos"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func Init(ctx context.Context) {
	db = mongos.New(mongos.MgoManager, TN.RefundOrder)
	indexes := []mongo.IndexModel{
		// (appId, orderId) 唯一,从数据库层杜绝重复添加 —— 应用层的"先查后插"
		// 存在并发竞态,两个请求可能同时通过检查。与 log_recharge 的唯一键对齐。
		// orderId 为空的历史数据不参与唯一约束,否则多条空值会互相冲突。
		{
			Keys: bson.D{
				{Key: FN.RefundOrder.AppId, Value: 1},
				{Key: FN.RefundOrder.OrderId, Value: 1},
			},
			Options: options.Index().SetUnique(true).
				SetPartialFilterExpression(bson.M{FN.RefundOrder.OrderId: bson.M{"$gt": ""}}),
		},
		{Keys: bson.D{{Key: FN.RefundOrder.CID, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.TransNo, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.IP, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.UserId, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.ChannelName, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.DistrictCode, Value: 1}}},
		{Keys: bson.D{{Key: FN.RefundOrder.CreatedAt, Value: -1}}},
	}
	if _, err := db.CreateIndex(ctx, indexes); err != nil {
		panic(fmt.Sprintf("(refundOrderMod:Init) CreateIndex failed: %+v", err))
	}
}

// InsertOneRefundOrder 插入一条。
// 必须用 InsertOneTiny: db.InsertOne 会调 addCreatedAt 把 CreatedAt 无条件
// 改写成 time.Now(),而本表的 createdAt 存的是原订单创建时间,不能被覆盖。
// 命中唯一索引时返回的 error 可用 IsDuplicateKey 判定。
func InsertOneRefundOrder(ctx context.Context, doc *RefundOrder) error {
	if err := db.InsertOneTiny(ctx, doc); err != nil {
		if !IsDuplicateKey(err) {
			log.Warn("refundOrderMod InsertOne failed", log.E(err))
		}
		return err
	}
	return nil
}

// IsDuplicateKey 判断是否唯一索引冲突。
// 驱动为 v1.4.1,没有 mongo.IsDuplicateKeyError(1.11 才引入),按错误码 11000 判定。
func IsDuplicateKey(err error) bool {
	var we mongo.WriteException
	if errors.As(err, &we) {
		for _, e := range we.WriteErrors {
			if e.Code == 11000 {
				return true
			}
		}
	}
	return false
}

func FindOneRefundOrder(ctx context.Context, filter bson.M) (*RefundOrder, error) {
	var doc RefundOrder
	if err := db.FindOne(ctx, &doc, filter); err != nil {
		return nil, err
	}
	return &doc, nil
}

func FindManyRefundOrders(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (RefundOrderList, error) {
	list := make(RefundOrderList, 0)
	if err := db.Find(ctx, &list, filter, opts...); err != nil {
		log.Warn("refundOrderMod Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return list, nil
}

func CountRefundOrders(ctx context.Context, filter bson.M) (int64, error) {
	count, err := db.Count(ctx, filter)
	if err != nil {
		log.Warn("refundOrderMod Count failed", log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

// SumRefundOrderMoney 按同一 filter 汇总退款金额(单位:分)。
// 走聚合而不是把 money 累加在业务层,是为了统计整个查询结果而不只是当前这一页。
func SumRefundOrderMoney(ctx context.Context, filter bson.M) (int64, error) {
	var ret []struct {
		TotalMoney int64 `bson:"totalMoney"`
	}
	pipeline := []bson.M{
		{"$match": filter},
		{"$group": bson.M{
			"_id":        nil,
			"totalMoney": bson.M{"$sum": "$" + FN.RefundOrder.Money},
		}},
	}
	if err := db.Aggregate(ctx, &ret, pipeline); err != nil {
		log.Warn("refundOrderMod SumMoney failed", log.E(err), log.Any("filter", filter))
		return 0, err
	}
	if len(ret) == 0 {
		return 0, nil // 没有命中任何记录
	}
	return ret[0].TotalMoney, nil
}

func DelOneRefundOrder(ctx context.Context, filter bson.M) (int64, error) {
	count, err := db.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("refundOrderMod DeleteOne failed", log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}