hadja_server/pub/models/vipordermod/order.go

package vipordermod

import (
	"context"
	"fmt"
	"time"
	"videoweb/pub/common/log"
	"videoweb/pub/common/srvdef"
	"videoweb/pub/mongos"
	"videoweb/pub/pubdef"

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

var coll *mongos.Collection

func Init(ctx context.Context) {
	coll = mongos.Shop.Coll(TN.VipOrder)
	initIndex(ctx)
}

func initIndex(ctx context.Context) {
	indexes := []mongo.IndexModel{
		{Keys: bson.D{{Key: FN.VipOrder.UserId, Value: -1}}},
		{Keys: bson.D{{Key: FN.VipOrder.TradeNo, Value: 1}}, Options: options.Index().SetUnique(true)},
		{Keys: bson.D{{Key: FN.VipOrder.Status, Value: 1}}},
		{Keys: bson.D{{Key: FN.VipOrder.DistrictCode, Value: 1}}},
		{Keys: bson.D{{Key: FN.VipOrder.CreatedAt, Value: -1}}},
	}
	if _, err := coll.CreateIndex(ctx, indexes); err != nil {
		panic(fmt.Sprintf("(vipordermod:initIndex) Create Index failed! err:%+v:", err))
	}
}

func InsertOneVipOrder(ctx context.Context, doc *VipOrder) *srvdef.SrvErr {
	if _, err := coll.InsertOne(ctx, doc); err != nil {
		log.Error("vipordermod:InsertOneVipOrder failed", log.Any("doc", doc), log.E(err))
		return srvdef.New(srvdef.ErrDbInsertError, "", "")
	}
	return nil
}

func FindOneVipOrder(ctx context.Context, filter bson.M) (*VipOrder, *srvdef.SrvErr) {
	var doc VipOrder
	if err := coll.FindOneEx(ctx, &doc, filter); err != nil {
		if err != mongo.ErrNoDocuments {
			log.Warn("vipordermod:FindOneVipOrder failed", log.E(err), log.Any("filter", filter))
			return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
		}
		return nil, srvdef.New(srvdef.ErrNoData, "", "")
	}
	return &doc, nil
}

func FindManyVipOrder(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (VipOrderList, *srvdef.SrvErr) {
	var data VipOrderList
	if err := coll.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("vipordermod:FindManyVipOrder failed", log.E(err), log.Any("filter", filter))
		return nil, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return data, nil
}

func CountVipOrder(ctx context.Context, filter bson.M) (int64, *srvdef.SrvErr) {
	count, err := coll.Count(ctx, filter)
	if err != nil {
		log.Warn("vipordermod:CountVipOrder failed", log.E(err), log.Any("filter", filter))
		return 0, srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return count, nil
}

// StatSyncSuccessOrderList 增量拉取支付成功订单（统计中心同步）
func StatSyncSuccessOrderList(ctx context.Context, successTime time.Time, size int64) (VipOrderList, error) {
	opt := (&options.FindOptions{}).SetLimit(size).SetSort(bson.M{FN.VipOrder.FinishedAt: 1})
	// 预留足够时间让注册数据先到达统计中心，避免充值记录找不到对应注册用户
	endTime := time.Now().Add(-time.Minute * 4)
	filter := bson.M{
		FN.VipOrder.FinishedAt: bson.M{"$gt": successTime, "$lt": endTime},
		FN.VipOrder.Status:     pubdef.VipOrderSuccess,
	}
	list := VipOrderList{}
	if err := coll.Find(ctx, &list, filter, opt); err != nil {
		return nil, err
	}
	return list, nil
}

// StatSyncAllOrderList 增量拉取非失败订单（统计中心同步）
func StatSyncAllOrderList(ctx context.Context, createTime time.Time, size int64) (VipOrderList, error) {
	opt := (&options.FindOptions{}).SetLimit(size).SetSort(bson.M{FN.VipOrder.CreatedAt: 1})
	endTime := time.Now().Add(-time.Minute * 1)
	filter := bson.M{
		FN.VipOrder.CreatedAt: bson.M{"$gt": createTime, "$lt": endTime},
		FN.VipOrder.Status:    bson.M{"$ne": pubdef.VipOrderFailed},
	}
	list := VipOrderList{}
	if err := coll.Find(ctx, &list, filter, opt); err != nil {
		return nil, err
	}
	return list, nil
}

// StatSyncVipOrderList 增量拉取会员购买成功订单（统计中心同步）
func StatSyncVipOrderList(ctx context.Context, successTime time.Time, size int64) (VipOrderList, error) {
	opt := (&options.FindOptions{}).SetLimit(size).SetSort(bson.M{FN.VipOrder.FinishedAt: 1})
	endTime := time.Now().Add(-time.Minute * 1)
	filter := bson.M{
		FN.VipOrder.FinishedAt: bson.M{"$gt": successTime, "$lt": endTime},
		FN.VipOrder.Status:     pubdef.VipOrderSuccess,
		FN.VipOrder.OrderType:  OrderTypeVip,
	}
	list := VipOrderList{}
	if err := coll.Find(ctx, &list, filter, opt); err != nil {
		return nil, err
	}
	return list, nil
}

func EmptyDistrictFilter() bson.M {
	return bson.M{
		"$or": []bson.M{
			{FN.VipOrder.DistrictCode: bson.M{"$exists": false}},
			{FN.VipOrder.DistrictCode: ""},
			{FN.VipOrder.DistrictCode: nil},
		},
	}
}

// AggregateVipOrder 聚合查询充值订单
func AggregateVipOrder(ctx context.Context, bind interface{}, pipeline []bson.M) *srvdef.SrvErr {
	if err := coll.Aggregate(ctx, bind, pipeline); err != nil {
		log.Warn("vipordermod:AggregateVipOrder failed", log.E(err), log.Any("pipeline", pipeline))
		return srvdef.New(srvdef.ErrDbQueryError, "", "")
	}
	return nil
}

func UpdateManyVipOrder(ctx context.Context, filter bson.M, update bson.M) (int64, *srvdef.SrvErr) {
	result, err := coll.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("vipordermod:UpdateManyVipOrder failed", log.E(err), log.Any("filter", filter))
		return 0, srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	return result.ModifiedCount, nil
}

// UpdateOrderSuccess 将订单标记为支付成功
func UpdateOrderSuccess(ctx context.Context, tradeNo string, oid string, realAmount int64, paymentAt time.Time) *srvdef.SrvErr {
	now := time.Now()
	result, err := coll.UpdateOne(ctx,
		bson.M{FN.VipOrder.TradeNo: tradeNo},
		bson.M{"$set": bson.M{
			FN.VipOrder.Status:     pubdef.VipOrderSuccess,
			FN.VipOrder.Oid:        oid,
			FN.VipOrder.Amount:     realAmount,
			FN.VipOrder.FinishedAt: paymentAt,
			FN.VipOrder.UpdatedAt:  now,
		}},
	)
	if err != nil {
		log.Warn("vipordermod:UpdateOrderSuccess failed", log.E(err), log.Any("tradeNo", tradeNo))
		return srvdef.New(srvdef.ErrDbUpdateError, "", "")
	}
	if result.MatchedCount == 0 {
		return srvdef.New(srvdef.ErrNoData, "订单不存在", "")
	}
	return nil
}