topfans/backend/services/activityService/provider/activity_provider.go

package provider

import (
	"context"
	"time"

	appErrors "github.com/topfans/backend/pkg/errors"
	"github.com/topfans/backend/pkg/logger"
	pb "github.com/topfans/backend/pkg/proto/activity"
	pbCommon "github.com/topfans/backend/pkg/proto/common"
	"github.com/topfans/backend/services/activityService/service"
	"go.uber.org/zap"
)

// ActivityProvider 活动服务Provider实现
// 实现 Triple 协议生成的 ActivityServiceHandler 接口
type ActivityProvider struct {
	activityService service.ActivityService
}

// 确保 ActivityProvider 实现了 ActivityServiceHandler 接口
var _ pb.ActivityServiceHandler = (*ActivityProvider)(nil)

// NewActivityProvider 创建活动服务Provider实例
func NewActivityProvider(activityService service.ActivityService) *ActivityProvider {
	return &ActivityProvider{
		activityService: activityService,
	}
}

// GetActivityList 获取活动列表
func (p *ActivityProvider) GetActivityList(ctx context.Context, req *pb.GetActivityListRequest) (*pb.GetActivityListResponse, error) {
	logger.Logger.Info("Received GetActivityList request",
		zap.Int64("star_id", req.StarId),
		zap.String("status", req.Status),
		zap.Int32("page", req.Page),
		zap.Int32("page_size", req.PageSize),
	)

	// 调用Service层
	resp, err := p.activityService.GetActivityList(ctx, req)
	if err != nil {
		logger.Logger.Error("GetActivityList failed", zap.Error(err))
		return &pb.GetActivityListResponse{
			Base: &pbCommon.BaseResponse{
				Code:      appErrors.ToStatusCode(err),
				Message:   err.Error(),
				Timestamp: time.Now().UnixMilli(),
			},
		}, err
	}

	logger.Logger.Debug("GetActivityList successful",
		zap.Int("activities_count", len(resp.Activities)),
	)

	return resp, nil
}

// GetActivity 获取活动详情
func (p *ActivityProvider) GetActivity(ctx context.Context, req *pb.GetProgressRequest) (*pb.Activity, error) {
	logger.Logger.Info("Received GetActivity request",
		zap.Int64("activity_id", req.ActivityId),
	)

	// 调用Service层
	activity, err := p.activityService.GetActivity(ctx, req)
	if err != nil {
		logger.Logger.Error("GetActivity failed", zap.Error(err))
		if err == appErrors.ErrActivityNotFound {
			return nil, appErrors.ErrActivityNotFound
		}
		return nil, err
	}

	logger.Logger.Debug("GetActivity successful",
		zap.Int64("activity_id", activity.Id),
	)

	return activity, nil
}

// GetActivityItems 获取活动道具列表
func (p *ActivityProvider) GetActivityItems(ctx context.Context, req *pb.GetProgressRequest) (*pb.ActivityItemsResponse, error) {
	logger.Logger.Info("Received GetActivityItems request",
		zap.Int64("activity_id", req.ActivityId),
	)

	// 调用Service层
	items, err := p.activityService.GetActivityItems(ctx, req)
	if err != nil {
		logger.Logger.Error("GetActivityItems failed", zap.Error(err))
		return &pb.ActivityItemsResponse{
			Items: []*pb.ActivityItem{},
		}, err
	}

	logger.Logger.Debug("GetActivityItems successful",
		zap.Int("items_count", len(items)),
	)

	return &pb.ActivityItemsResponse{
		Items: items,
	}, nil
}

// GetProgress 获取活动进度
func (p *ActivityProvider) GetProgress(ctx context.Context, req *pb.GetProgressRequest) (*pb.GetProgressResponse, error) {
	logger.Logger.Info("Received GetProgress request",
		zap.Int64("activity_id", req.ActivityId),
	)

	// 调用Service层
	resp, err := p.activityService.GetProgress(ctx, req)
	if err != nil {
		logger.Logger.Error("GetProgress failed", zap.Error(err))
		return &pb.GetProgressResponse{
			Base: &pbCommon.BaseResponse{
				Code:      appErrors.ToStatusCode(err),
				Message:   err.Error(),
				Timestamp: time.Now().UnixMilli(),
			},
		}, err
	}

	logger.Logger.Debug("GetProgress successful",
		zap.Int64("current_progress", resp.CurrentProgress),
		zap.Int64("target_progress", resp.TargetProgress),
	)

	return resp, nil
}

// PurchaseItem 购买道具
func (p *ActivityProvider) PurchaseItem(ctx context.Context, req *pb.PurchaseItemRequest) (*pb.PurchaseItemResponse, error) {
	logger.Logger.Info("Received PurchaseItem request",
		zap.Int64("activity_id", req.ActivityId),
		zap.String("item_type", req.ItemType),
		zap.Int32("quantity", req.Quantity),
		zap.Int64("star_id", req.StarId),
	)

	// 调用Service层
	resp, err := p.activityService.PurchaseItem(ctx, req)
	if err != nil {
		logger.Logger.Error("PurchaseItem failed", zap.Error(err))
		return &pb.PurchaseItemResponse{
			Base: &pbCommon.BaseResponse{
				Code:      appErrors.ToStatusCode(err),
				Message:   err.Error(),
				Timestamp: time.Now().UnixMilli(),
			},
		}, err
	}

	logger.Logger.Info("PurchaseItem successful",
		zap.Int64("total_crystal_spent", resp.TotalCrystalSpent),
		zap.Int64("total_contribution", resp.TotalContribution),
		zap.Int64("remaining_balance", resp.RemainingBalance),
	)

	return resp, nil
}

// GetContributionRanking 获取贡献点排名
func (p *ActivityProvider) GetContributionRanking(ctx context.Context, req *pb.ContributionRankingRequest) (*pb.ContributionRankingResponse, error) {
	logger.Logger.Info("Received GetContributionRanking request",
		zap.Int64("activity_id", req.ActivityId),
		zap.Int64("star_id", req.StarId),
		zap.Int32("page", req.Page),
		zap.Int32("page_size", req.PageSize),
	)

	// 调用Service层
	resp, err := p.activityService.GetContributionRanking(ctx, req)
	if err != nil {
		logger.Logger.Error("GetContributionRanking failed", zap.Error(err))
		return &pb.ContributionRankingResponse{
			Base: &pbCommon.BaseResponse{
				Code:      appErrors.ToStatusCode(err),
				Message:   err.Error(),
				Timestamp: time.Now().UnixMilli(),
			},
		}, nil
	}

	logger.Logger.Debug("GetContributionRanking successful",
		zap.Int("items_count", len(resp.Items)),
	)

	return resp, nil
}