254 lines
8.3 KiB
Go
254 lines
8.3 KiB
Go
package provider
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"dubbo.apache.org/dubbo-go/v3/common/constant"
|
|
"github.com/topfans/backend/pkg/logger"
|
|
pb "github.com/topfans/backend/pkg/proto/task"
|
|
"github.com/topfans/backend/services/taskService/service"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// TaskMobileProvider 实现 TaskMobileService 接口
|
|
type TaskMobileProvider struct {
|
|
dailySvc service.DailyTaskService
|
|
onboardingSvc service.OnboardingService
|
|
revenueSvc service.RevenueService
|
|
}
|
|
|
|
func NewTaskMobileProvider(
|
|
dailySvc service.DailyTaskService,
|
|
onboardingSvc service.OnboardingService,
|
|
revenueSvc service.RevenueService,
|
|
) *TaskMobileProvider {
|
|
return &TaskMobileProvider{
|
|
dailySvc: dailySvc,
|
|
onboardingSvc: onboardingSvc,
|
|
revenueSvc: revenueSvc,
|
|
}
|
|
}
|
|
|
|
// extractUserInfoFromDubboAttachments 从 Dubbo attachments 提取用户信息
|
|
func extractUserInfoFromDubboAttachments(ctx context.Context) (int64, int64, error) {
|
|
// Dubbo-go 使用 constant.AttachmentKey 获取 attachments
|
|
if attachments := ctx.Value(constant.AttachmentKey); attachments != nil {
|
|
if attMap, ok := attachments.(map[string]interface{}); ok {
|
|
userID, starID := extractUserInfoFromMap(attMap)
|
|
if userID > 0 {
|
|
return userID, starID, nil
|
|
}
|
|
}
|
|
}
|
|
return 0, 0, fmt.Errorf("failed to extract user info from Dubbo attachments")
|
|
}
|
|
|
|
// extractUserInfoFromMap 从 map 中提取用户信息
|
|
func extractUserInfoFromMap(attMap map[string]interface{}) (int64, int64) {
|
|
var userID, starID int64
|
|
|
|
if uid, ok := attMap["user_id"]; ok {
|
|
switch v := uid.(type) {
|
|
case int64:
|
|
userID = v
|
|
case float64:
|
|
userID = int64(v)
|
|
case string:
|
|
if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
|
|
userID = parsed
|
|
}
|
|
case []string:
|
|
if len(v) > 0 {
|
|
if parsed, err := strconv.ParseInt(v[0], 10, 64); err == nil {
|
|
userID = parsed
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if sid, ok := attMap["star_id"]; ok {
|
|
switch v := sid.(type) {
|
|
case int64:
|
|
starID = v
|
|
case float64:
|
|
starID = int64(v)
|
|
case string:
|
|
if parsed, err := strconv.ParseInt(v, 10, 64); err == nil {
|
|
starID = parsed
|
|
}
|
|
case []string:
|
|
if len(v) > 0 {
|
|
if parsed, err := strconv.ParseInt(v[0], 10, 64); err == nil {
|
|
starID = parsed
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return userID, starID
|
|
}
|
|
|
|
func (p *TaskMobileProvider) GetDailyTasks(ctx context.Context, req *pb.GetDailyTasksRequest) (*pb.GetDailyTasksResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("GetDailyTasks: failed to extract user", zap.Error(err))
|
|
return &pb.GetDailyTasksResponse{
|
|
Tasks: []*pb.DailyTaskItem{},
|
|
}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("GetDailyTasks",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID))
|
|
|
|
return p.dailySvc.GetDailyTasks(ctx, userID, starID)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ReportEvent(ctx context.Context, req *pb.ReportEventRequest) (*pb.ReportEventResponse, error) {
|
|
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ReportEvent: failed to extract user", zap.Error(err))
|
|
return &pb.ReportEventResponse{
|
|
Success: false,
|
|
}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("ReportEvent",
|
|
zap.Int64("user_id", userID),
|
|
zap.String("event_type", req.EventType),
|
|
zap.Int64("star_id", req.StarId))
|
|
|
|
return p.dailySvc.ReportEvent(ctx, userID, req.StarId, req.EventType)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ClaimDailyTask(ctx context.Context, req *pb.ClaimDailyTaskRequest) (*pb.ClaimDailyTaskResponse, error) {
|
|
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ClaimDailyTask: failed to extract user", zap.Error(err))
|
|
return &pb.ClaimDailyTaskResponse{Success: false}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("ClaimDailyTask",
|
|
zap.Int64("user_id", userID),
|
|
zap.String("task_key", req.TaskKey),
|
|
zap.Int64("star_id", req.StarId))
|
|
|
|
return p.dailySvc.ClaimDailyTask(ctx, userID, req.StarId, req.TaskKey)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ClaimAllDailyTasks(ctx context.Context, req *pb.ClaimAllDailyTasksRequest) (*pb.ClaimAllDailyTasksResponse, error) {
|
|
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ClaimAllDailyTasks: failed to extract user", zap.Error(err))
|
|
return &pb.ClaimAllDailyTasksResponse{ClaimedCount: 0}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("ClaimAllDailyTasks",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", req.StarId))
|
|
|
|
return p.dailySvc.ClaimAllDailyTasks(ctx, userID, req.StarId)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) CompleteGuide(ctx context.Context, req *pb.CompleteGuideRequest) (*pb.CompleteGuideResponse, error) {
|
|
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("CompleteGuide: failed to extract user", zap.Error(err))
|
|
return &pb.CompleteGuideResponse{}, nil
|
|
}
|
|
|
|
logger.Logger.Info("CompleteGuide",
|
|
zap.Int64("user_id", userID),
|
|
zap.String("task_key", req.TaskKey),
|
|
zap.Int("stages_count", len(req.Stages)))
|
|
|
|
return p.onboardingSvc.CompleteGuide(ctx, userID, req.TaskKey, req.Stages)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) GetOnboardingStatus(ctx context.Context, req *pb.GetOnboardingStatusRequest) (*pb.GetOnboardingStatusResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("GetOnboardingStatus: failed to extract user", zap.Error(err))
|
|
return &pb.GetOnboardingStatusResponse{}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("GetOnboardingStatus",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID))
|
|
|
|
return p.onboardingSvc.GetOnboardingStatus(ctx, userID, starID)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) AdvanceStage(ctx context.Context, req *pb.AdvanceStageRequest) (*pb.AdvanceStageResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("AdvanceStage: failed to extract user", zap.Error(err))
|
|
return &pb.AdvanceStageResponse{}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("AdvanceStage",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID),
|
|
zap.Int32("target_stage", req.TargetStage))
|
|
|
|
return p.onboardingSvc.AdvanceStage(ctx, userID, starID, req.TargetStage)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ClaimOnboardingReward(ctx context.Context, req *pb.ClaimOnboardingRewardRequest) (*pb.ClaimOnboardingRewardResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ClaimOnboardingReward: failed to extract user", zap.Error(err))
|
|
return &pb.ClaimOnboardingRewardResponse{Success: false}, nil
|
|
}
|
|
|
|
return p.onboardingSvc.ClaimOnboardingReward(ctx, userID, starID, req.Stage)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) GetExhibitionRevenue(ctx context.Context, req *pb.GetExhibitionRevenueRequest) (*pb.GetExhibitionRevenueResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("GetExhibitionRevenue: failed to extract user", zap.Error(err))
|
|
return &pb.GetExhibitionRevenueResponse{
|
|
Items: []*pb.ExhibitionRevenueItem{},
|
|
}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("GetExhibitionRevenue",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID),
|
|
zap.String("status", req.Status))
|
|
|
|
return p.revenueSvc.GetExhibitionRevenue(ctx, userID, starID, req.Status, req.Page, req.PageSize)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ClaimExhibitionRevenue(ctx context.Context, req *pb.ClaimExhibitionRevenueRequest) (*pb.ClaimExhibitionRevenueResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ClaimExhibitionRevenue: failed to extract user", zap.Error(err))
|
|
return &pb.ClaimExhibitionRevenueResponse{Success: false}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("ClaimExhibitionRevenue",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID),
|
|
zap.Int64("revenue_id", req.RevenueId))
|
|
|
|
return p.revenueSvc.ClaimExhibitionRevenue(ctx, userID, starID, req.RevenueId)
|
|
}
|
|
|
|
func (p *TaskMobileProvider) ClaimAllExhibitionRevenue(ctx context.Context, req *pb.ClaimAllExhibitionRevenueRequest) (*pb.ClaimAllExhibitionRevenueResponse, error) {
|
|
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
|
if err != nil {
|
|
logger.Logger.Error("ClaimAllExhibitionRevenue: failed to extract user", zap.Error(err))
|
|
return &pb.ClaimAllExhibitionRevenueResponse{ClaimedCount: 0}, nil
|
|
}
|
|
|
|
logger.Logger.Debug("ClaimAllExhibitionRevenue",
|
|
zap.Int64("user_id", userID),
|
|
zap.Int64("star_id", starID))
|
|
|
|
return p.revenueSvc.ClaimAllExhibitionRevenue(ctx, userID, starID)
|
|
}
|