854 lines
22 KiB
Go
854 lines
22 KiB
Go
package provider
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
|
||
"dubbo.apache.org/dubbo-go/v3/common/constant"
|
||
appErrors "github.com/topfans/backend/pkg/errors"
|
||
"github.com/topfans/backend/pkg/logger"
|
||
pbCommon "github.com/topfans/backend/pkg/proto/common"
|
||
pb "github.com/topfans/backend/pkg/proto/user"
|
||
"github.com/topfans/backend/services/userService/service"
|
||
"go.uber.org/zap"
|
||
)
|
||
|
||
// UserProvider 用户信息Provider实现
|
||
type UserProvider struct {
|
||
userService service.UserService
|
||
identityService service.IdentityService
|
||
}
|
||
|
||
// NewUserProvider 创建用户信息Provider实例
|
||
func NewUserProvider(userService service.UserService, identityService service.IdentityService) *UserProvider {
|
||
return &UserProvider{
|
||
userService: userService,
|
||
identityService: identityService,
|
||
}
|
||
}
|
||
|
||
// GetUser 获取用户信息
|
||
func (p *UserProvider) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetUser request",
|
||
zap.Int64("user_id", req.UserId),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.GetUser(req)
|
||
if err != nil {
|
||
logger.Logger.Error("GetUser failed",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.GetUserResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Debug("GetUser successful",
|
||
zap.Int64("user_id", req.UserId),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// GetFanProfile 获取粉丝档案
|
||
func (p *UserProvider) GetFanProfile(ctx context.Context, req *pb.GetFanProfileRequest) (*pb.GetFanProfileResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetFanProfile request",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.GetFanProfile(req)
|
||
if err != nil {
|
||
logger.Logger.Error("GetFanProfile failed",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.GetFanProfileResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Debug("GetFanProfile successful",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// GetCurrentUser 获取当前登录用户信息
|
||
// 假设：Gin 网关已经验证 Token，并通过 Dubbo attachments 传递 user_id 和 star_id
|
||
func (p *UserProvider) GetCurrentUser(ctx context.Context, req *pb.GetCurrentUserRequest) (*pb.GetCurrentUserResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetCurrentUser request")
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.GetCurrentUserResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
logger.Logger.Debug("User info extracted from Dubbo attachments",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
)
|
||
|
||
// 调用Service层的GetMyProfile（使用GetMyProfileRequest）
|
||
myProfileReq := &pb.GetMyProfileRequest{}
|
||
resp, err := p.userService.GetMyProfile(myProfileReq, userID, starID)
|
||
if err != nil {
|
||
logger.Logger.Error("GetCurrentUser failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
return &pb.GetCurrentUserResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 转换为GetCurrentUserResponse格式
|
||
currentUserResp := &pb.GetCurrentUserResponse{
|
||
Base: resp.Base,
|
||
User: resp.User,
|
||
FanProfile: resp.FanProfile,
|
||
FanProfiles: resp.FanProfiles,
|
||
}
|
||
|
||
logger.Logger.Debug("GetCurrentUser successful",
|
||
zap.Int64("user_id", userID),
|
||
)
|
||
|
||
return currentUserResp, nil
|
||
}
|
||
|
||
// GetMyProfile 获取个人信息页
|
||
func (p *UserProvider) GetMyProfile(ctx context.Context, req *pb.GetMyProfileRequest) (*pb.GetMyProfileResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetMyProfile request")
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.GetMyProfileResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.GetMyProfile(req, userID, starID)
|
||
if err != nil {
|
||
logger.Logger.Error("GetMyProfile failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.GetMyProfileResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Debug("GetMyProfile successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// CheckNickname 检查昵称是否已被注册
|
||
func (p *UserProvider) CheckNickname(ctx context.Context, req *pb.CheckNicknameRequest) (*pb.CheckNicknameResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received CheckNickname request",
|
||
zap.String("nickname", req.Nickname),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.CheckNickname(req)
|
||
if err != nil {
|
||
logger.Logger.Error("CheckNickname failed",
|
||
zap.String("nickname", req.Nickname),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.CheckNicknameResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("CheckNickname successful",
|
||
zap.String("nickname", req.Nickname),
|
||
zap.Bool("exists", resp.Exists),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// CheckMobile 检查手机号是否已被注册
|
||
func (p *UserProvider) CheckMobile(ctx context.Context, req *pb.CheckMobileRequest) (*pb.CheckMobileResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received CheckMobile request",
|
||
zap.String("mobile", req.Mobile),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.CheckMobile(req)
|
||
if err != nil {
|
||
logger.Logger.Error("CheckMobile failed",
|
||
zap.String("mobile", req.Mobile),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.CheckMobileResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("CheckMobile successful",
|
||
zap.String("mobile", req.Mobile),
|
||
zap.Bool("exists", resp.Exists),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdateNickname 修改昵称
|
||
func (p *UserProvider) UpdateNickname(ctx context.Context, req *pb.UpdateNicknameRequest) (*pb.UpdateNicknameResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received UpdateNickname request")
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.UpdateNicknameResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdateNickname(req, userID, starID)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdateNickname failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdateNicknameResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdateNickname successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
zap.String("new_nickname", req.Nickname),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdatePassword 修改密码
|
||
func (p *UserProvider) UpdatePassword(ctx context.Context, req *pb.UpdatePasswordRequest) (*pb.UpdatePasswordResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received UpdatePassword request")
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.UpdatePasswordResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdatePassword(req, userID)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdatePassword failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdatePasswordResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdatePassword successful",
|
||
zap.Int64("user_id", userID),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdateAvatar 更新用户头像
|
||
func (p *UserProvider) UpdateAvatar(ctx context.Context, req *pb.UpdateAvatarRequest) (*pb.UpdateAvatarResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received UpdateAvatar request")
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.UpdateAvatarResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdateAvatar(req, userID, starID)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdateAvatar failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdateAvatarResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdateAvatar successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.String("avatar_url", req.AvatarUrl),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// GetFanIdentities 获取可选粉丝身份列表
|
||
func (p *UserProvider) GetFanIdentities(ctx context.Context, req *pb.GetFanIdentitiesRequest) (*pb.GetFanIdentitiesResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetFanIdentities request",
|
||
zap.String("keyword", req.Keyword),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.identityService.GetFanIdentities(req)
|
||
if err != nil {
|
||
logger.Logger.Error("GetFanIdentities failed",
|
||
zap.String("keyword", req.Keyword),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.GetFanIdentitiesResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Debug("GetFanIdentities successful",
|
||
zap.String("keyword", req.Keyword),
|
||
zap.Int("count", len(resp.Stars)),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// GetMyFanIdentities 获取我的粉丝身份列表
|
||
func (p *UserProvider) GetMyFanIdentities(ctx context.Context, req *pb.GetMyFanIdentitiesRequest) (*pb.GetMyFanIdentitiesResponse, error) {
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, starID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.GetMyFanIdentitiesResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received GetMyFanIdentities request",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.identityService.GetMyFanIdentities(userID, starID)
|
||
if err != nil {
|
||
logger.Logger.Error("GetMyFanIdentities failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.GetMyFanIdentitiesResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Debug("GetMyFanIdentities successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
zap.Int("count", len(resp.Items)),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// AddIdentity 新增粉丝身份
|
||
func (p *UserProvider) AddIdentity(ctx context.Context, req *pb.AddIdentityRequest) (*pb.AddIdentityResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received AddIdentity request",
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.String("nickname", req.Nickname),
|
||
)
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, _, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.AddIdentityResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.identityService.AddIdentity(req, userID)
|
||
if err != nil {
|
||
logger.Logger.Error("AddIdentity failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.AddIdentityResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("AddIdentity successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", req.StarId),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// SwitchIdentity 切换粉丝身份
|
||
func (p *UserProvider) SwitchIdentity(ctx context.Context, req *pb.SwitchIdentityRequest) (*pb.SwitchIdentityResponse, error) {
|
||
// 记录请求日志
|
||
logger.Logger.Info("Received SwitchIdentity request",
|
||
zap.Int64("new_star_id", req.NewStarId),
|
||
)
|
||
|
||
// 从 Dubbo attachments 获取用户信息（网关已验证并传递）
|
||
userID, currentStarID, err := extractUserInfoFromDubboAttachments(ctx)
|
||
if err != nil {
|
||
logger.Logger.Error("Failed to extract user info from attachments",
|
||
zap.Error(err),
|
||
)
|
||
return &pb.SwitchIdentityResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: pbCommon.StatusCode_STATUS_UNAUTHORIZED,
|
||
Message: "user authentication required",
|
||
Timestamp: 0,
|
||
},
|
||
}, err
|
||
}
|
||
|
||
// 调用Service层
|
||
resp, err := p.identityService.SwitchIdentity(req, userID, currentStarID)
|
||
if err != nil {
|
||
logger.Logger.Error("SwitchIdentity failed",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("current_star_id", currentStarID),
|
||
zap.Int64("new_star_id", req.NewStarId),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.SwitchIdentityResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("SwitchIdentity successful",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("current_star_id", currentStarID),
|
||
zap.Int64("new_star_id", req.NewStarId),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// extractUserInfoFromDubboAttachments 从 Dubbo attachments 中提取用户信息
|
||
// 网关调用：网关已验证 Token 并将 user_id 和 star_id 通过 attachments 传递
|
||
// 直接调用：可以通过 grpcurl -rpc-header 传递 user_id 和 star_id 进行测试
|
||
func extractUserInfoFromDubboAttachments(ctx context.Context) (int64, int64, error) {
|
||
logger.Logger.Info("Extracting user info from Dubbo attachments")
|
||
|
||
// 使用正确的 constant.AttachmentKey 获取 Dubbo attachments
|
||
if attachments := ctx.Value(constant.AttachmentKey); attachments != nil {
|
||
logger.Logger.Info("Found attachments in context",
|
||
zap.Any("attachments", attachments),
|
||
zap.String("key", fmt.Sprintf("%v", constant.AttachmentKey)),
|
||
)
|
||
|
||
if attMap, ok := attachments.(map[string]interface{}); ok {
|
||
logger.Logger.Info("Attachments is a map", zap.Any("map", attMap))
|
||
userID, starID := extractUserInfoFromMap(attMap)
|
||
if userID > 0 && starID > 0 {
|
||
logger.Logger.Info("Successfully extracted user info",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
)
|
||
return userID, starID, nil
|
||
} else {
|
||
logger.Logger.Warn("Extracted zero user_id or star_id",
|
||
zap.Int64("user_id", userID),
|
||
zap.Int64("star_id", starID),
|
||
)
|
||
}
|
||
} else {
|
||
logger.Logger.Warn("Attachments is not a map[string]interface{}",
|
||
zap.String("type", fmt.Sprintf("%T", attachments)),
|
||
)
|
||
}
|
||
} else {
|
||
logger.Logger.Warn("No attachments found in context",
|
||
zap.String("key", fmt.Sprintf("%v", constant.AttachmentKey)),
|
||
)
|
||
}
|
||
|
||
logger.Logger.Error("Failed to extract user info from Dubbo attachments")
|
||
return 0, 0, fmt.Errorf("user info not found in Dubbo attachments (expected user_id and star_id from gateway)")
|
||
}
|
||
|
||
// extractUserInfoFromMap 从 map 中提取 user_id 和 star_id
|
||
// 支持多种类型：int64, float64, string, []string, []interface{}
|
||
func extractUserInfoFromMap(attMap map[string]interface{}) (int64, int64) {
|
||
var userID, starID int64
|
||
|
||
// 提取 user_id
|
||
if v, ok := attMap["user_id"]; ok {
|
||
userID = parseIntValue(v)
|
||
}
|
||
|
||
// 提取 star_id
|
||
if v, ok := attMap["star_id"]; ok {
|
||
starID = parseIntValue(v)
|
||
}
|
||
|
||
return userID, starID
|
||
}
|
||
|
||
// parseIntValue 解析各种类型的值为 int64
|
||
func parseIntValue(v interface{}) int64 {
|
||
switch val := v.(type) {
|
||
case int64:
|
||
return val
|
||
case int:
|
||
return int64(val)
|
||
case float64:
|
||
return int64(val)
|
||
case string:
|
||
var result int64
|
||
fmt.Sscanf(val, "%d", &result)
|
||
return result
|
||
case []string:
|
||
if len(val) > 0 {
|
||
var result int64
|
||
fmt.Sscanf(val[0], "%d", &result)
|
||
return result
|
||
}
|
||
case []interface{}:
|
||
if len(val) > 0 {
|
||
return parseIntValue(val[0])
|
||
}
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// UpdateFanProfileSocial 更新粉丝档案的好友数量（内部RPC调用）
|
||
func (p *UserProvider) UpdateFanProfileSocial(ctx context.Context, req *pb.UpdateFanProfileSocialRequest) (*pb.UpdateFanProfileSocialResponse, error) {
|
||
logger.Logger.Info("Received UpdateFanProfileSocial request",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdateFanProfileSocial(req)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdateFanProfileSocial failed",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdateFanProfileSocialResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdateFanProfileSocial successful",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
zap.Int32("new_social", resp.NewSocial),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdateCrystalBalance 更新水晶余额（内部RPC调用）
|
||
func (p *UserProvider) UpdateCrystalBalance(ctx context.Context, req *pb.UpdateCrystalBalanceRequest) (*pb.UpdateCrystalBalanceResponse, error) {
|
||
logger.Logger.Info("Received UpdateCrystalBalance request",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int64("delta", req.Delta),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdateCrystalBalance(req)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdateCrystalBalance failed",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int64("delta", req.Delta),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdateCrystalBalanceResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdateCrystalBalance successful",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int64("delta", req.Delta),
|
||
zap.Int64("new_balance", resp.NewBalance),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdateAssetsCount 更新资产数量（内部RPC调用）
|
||
func (p *UserProvider) UpdateAssetsCount(ctx context.Context, req *pb.UpdateAssetsCountRequest) (*pb.UpdateAssetsCountResponse, error) {
|
||
logger.Logger.Info("Received UpdateAssetsCount request",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
)
|
||
|
||
// 调用Service层
|
||
resp, err := p.userService.UpdateAssetsCount(req)
|
||
if err != nil {
|
||
logger.Logger.Error("UpdateAssetsCount failed",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
zap.Error(err),
|
||
)
|
||
|
||
// 如果响应为空，构建错误响应
|
||
if resp == nil {
|
||
resp = &pb.UpdateAssetsCountResponse{
|
||
Base: &pbCommon.BaseResponse{
|
||
Code: appErrors.ToStatusCode(err),
|
||
Message: err.Error(),
|
||
Timestamp: 0,
|
||
},
|
||
}
|
||
}
|
||
|
||
return resp, err
|
||
}
|
||
|
||
logger.Logger.Info("UpdateAssetsCount successful",
|
||
zap.Int64("user_id", req.UserId),
|
||
zap.Int64("star_id", req.StarId),
|
||
zap.Int32("delta", req.Delta),
|
||
zap.Int32("new_count", resp.NewCount),
|
||
)
|
||
|
||
return resp, nil
|
||
}
|