785 lines
30 KiB
Go
785 lines
30 KiB
Go
package grpc
|
||
|
||
import (
|
||
"context"
|
||
"time"
|
||
|
||
walletv1 "hyapp.local/api/proto/wallet/v1"
|
||
"hyapp/pkg/appcode"
|
||
"hyapp/pkg/xerr"
|
||
"hyapp/services/wallet-service/internal/domain/ledger"
|
||
walletservice "hyapp/services/wallet-service/internal/service/wallet"
|
||
)
|
||
|
||
// Server 把 wallet-service 用例层适配为 gRPC 接口。
|
||
type Server struct {
|
||
walletv1.UnimplementedWalletServiceServer
|
||
|
||
svc *walletservice.Service
|
||
}
|
||
|
||
// NewServer 创建 wallet gRPC server。
|
||
func NewServer(svc *walletservice.Service) *Server {
|
||
return &Server{svc: svc}
|
||
}
|
||
|
||
// DebitGift 只负责 protobuf 转换和错误映射，扣费规则在 service/repository。
|
||
func (s *Server) DebitGift(ctx context.Context, req *walletv1.DebitGiftRequest) (*walletv1.DebitGiftResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.DebitGift(ctx, ledger.DebitGiftCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
RoomID: req.GetRoomId(),
|
||
SenderUserID: req.GetSenderUserId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
GiftID: req.GetGiftId(),
|
||
GiftCount: req.GetGiftCount(),
|
||
PriceVersion: req.GetPriceVersion(),
|
||
RegionID: req.GetRegionId(),
|
||
TargetIsHost: req.GetTargetIsHost(),
|
||
// 工资政策区域来自 user-service host profile，不能用房间 visible_region_id 兜底。
|
||
TargetHostRegionID: req.GetTargetHostRegionId(),
|
||
TargetAgencyOwnerUserID: req.GetTargetAgencyOwnerUserId(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.DebitGiftResponse{
|
||
BillingReceiptId: receipt.BillingReceiptID,
|
||
BalanceAfter: receipt.BalanceAfter,
|
||
TransactionId: receipt.TransactionID,
|
||
CoinSpent: receipt.CoinSpent,
|
||
ChargeAssetType: receipt.ChargeAssetType,
|
||
ChargeAmount: receipt.ChargeAmount,
|
||
GiftPointAdded: receipt.GiftPointAdded,
|
||
HeatValue: receipt.HeatValue,
|
||
GiftTypeCode: receipt.GiftTypeCode,
|
||
PriceVersion: receipt.PriceVersion,
|
||
HostPeriodDiamondAdded: receipt.HostPeriodDiamondAdded,
|
||
HostPeriodCycleKey: receipt.HostPeriodCycleKey,
|
||
}, nil
|
||
}
|
||
|
||
// GetBalances 返回用户多资产余额投影。
|
||
func (s *Server) GetBalances(ctx context.Context, req *walletv1.GetBalancesRequest) (*walletv1.GetBalancesResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
balances, err := s.svc.GetBalances(ctx, req.GetUserId(), req.GetAssetTypes())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
response := &walletv1.GetBalancesResponse{Balances: make([]*walletv1.AssetBalance, 0, len(balances))}
|
||
for _, balance := range balances {
|
||
response.Balances = append(response.Balances, &walletv1.AssetBalance{
|
||
AppCode: balance.AppCode,
|
||
AssetType: balance.AssetType,
|
||
AvailableAmount: balance.AvailableAmount,
|
||
FrozenAmount: balance.FrozenAmount,
|
||
Version: balance.Version,
|
||
})
|
||
}
|
||
|
||
return response, nil
|
||
}
|
||
|
||
// GetWalletOverview 返回钱包首页摘要，供我的页和钱包二级页复用。
|
||
func (s *Server) GetWalletOverview(ctx context.Context, req *walletv1.GetWalletOverviewRequest) (*walletv1.GetWalletOverviewResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
overview, err := s.svc.GetWalletOverview(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.GetWalletOverviewResponse{
|
||
Balances: balancesToProto(overview.Balances),
|
||
FeatureFlags: walletFeatureFlagsToProto(overview.FeatureFlags),
|
||
}, nil
|
||
}
|
||
|
||
// GetWalletValueSummary 返回我的页钱包卡片最小金币余额。
|
||
func (s *Server) GetWalletValueSummary(ctx context.Context, req *walletv1.GetWalletValueSummaryRequest) (*walletv1.GetWalletValueSummaryResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
summary, err := s.svc.GetWalletValueSummary(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.GetWalletValueSummaryResponse{Summary: &walletv1.WalletValueSummary{
|
||
CoinAmount: summary.CoinAmount,
|
||
UpdatedAtMs: summary.UpdatedAtMS,
|
||
}}, nil
|
||
}
|
||
|
||
// GetUserGiftWall 返回当前用户收到礼物的聚合墙；调用方负责限定 user_id 为当前登录用户。
|
||
func (s *Server) GetUserGiftWall(ctx context.Context, req *walletv1.GetUserGiftWallRequest) (*walletv1.GetUserGiftWallResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
wall, err := s.svc.GetUserGiftWall(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.GetUserGiftWallResponse{
|
||
Items: make([]*walletv1.GiftWallItem, 0, len(wall.Items)),
|
||
GiftKindCount: wall.GiftKindCount,
|
||
GiftTotalCount: wall.GiftTotalCount,
|
||
TotalValue: wall.TotalValue,
|
||
TotalCoinValue: wall.TotalCoinValue,
|
||
TotalDiamondValue: wall.TotalDiamondValue,
|
||
TotalGiftPoint: wall.TotalGiftPoint,
|
||
TotalHeatValue: wall.TotalHeatValue,
|
||
}
|
||
for _, item := range wall.Items {
|
||
resp.Items = append(resp.Items, giftWallItemToProto(item))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// ListRechargeProducts 返回当前用户区域可用的充值渠道和档位。
|
||
func (s *Server) ListRechargeProducts(ctx context.Context, req *walletv1.ListRechargeProductsRequest) (*walletv1.ListRechargeProductsResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
products, channels, err := s.svc.ListRechargeProducts(ctx, req.GetUserId(), req.GetRegionId(), req.GetPlatform())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.ListRechargeProductsResponse{Channels: channels, Products: make([]*walletv1.RechargeProduct, 0, len(products))}
|
||
for _, product := range products {
|
||
resp.Products = append(resp.Products, rechargeProductToProto(product))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// ConfirmGooglePayment 校验 Google Play purchase token 并完成钱包入账。
|
||
func (s *Server) ConfirmGooglePayment(ctx context.Context, req *walletv1.ConfirmGooglePaymentRequest) (*walletv1.ConfirmGooglePaymentResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.ConfirmGooglePayment(ctx, ledger.GooglePaymentCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
UserID: req.GetUserId(),
|
||
RegionID: req.GetRegionId(),
|
||
ProductID: req.GetProductId(),
|
||
ProductCode: req.GetProductCode(),
|
||
PackageName: req.GetPackageName(),
|
||
PurchaseToken: req.GetPurchaseToken(),
|
||
OrderID: req.GetOrderId(),
|
||
PurchaseTimeMS: req.GetPurchaseTimeMs(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.ConfirmGooglePaymentResponse{
|
||
PaymentOrderId: receipt.PaymentOrderID,
|
||
TransactionId: receipt.TransactionID,
|
||
Status: receipt.Status,
|
||
ProductId: receipt.ProductID,
|
||
ProductCode: receipt.ProductCode,
|
||
CoinAmount: receipt.CoinAmount,
|
||
Balance: balanceToProto(receipt.Balance),
|
||
IdempotentReplay: receipt.IdempotentReplay,
|
||
ConsumeState: receipt.ConsumeState,
|
||
}, nil
|
||
}
|
||
|
||
// ListAdminRechargeProducts 返回后台内购配置列表。
|
||
func (s *Server) ListAdminRechargeProducts(ctx context.Context, req *walletv1.ListAdminRechargeProductsRequest) (*walletv1.ListAdminRechargeProductsResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
products, total, err := s.svc.ListAdminRechargeProducts(ctx, ledger.ListRechargeProductsQuery{
|
||
AppCode: req.GetAppCode(),
|
||
Status: req.GetStatus(),
|
||
Platform: req.GetPlatform(),
|
||
RegionID: req.GetRegionId(),
|
||
Keyword: req.GetKeyword(),
|
||
Page: req.GetPage(),
|
||
PageSize: req.GetPageSize(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.ListAdminRechargeProductsResponse{Products: make([]*walletv1.RechargeProduct, 0, len(products)), Total: total}
|
||
for _, product := range products {
|
||
resp.Products = append(resp.Products, rechargeProductToProto(product))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// CreateRechargeProduct 创建后台内购商品配置。
|
||
func (s *Server) CreateRechargeProduct(ctx context.Context, req *walletv1.CreateRechargeProductRequest) (*walletv1.RechargeProductResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
product, err := s.svc.CreateRechargeProduct(ctx, ledger.RechargeProductCommand{
|
||
AppCode: req.GetAppCode(),
|
||
AmountMicro: req.GetAmountMicro(),
|
||
CoinAmount: req.GetCoinAmount(),
|
||
ProductName: req.GetProductName(),
|
||
Description: req.GetDescription(),
|
||
Platform: req.GetPlatform(),
|
||
RegionIDs: req.GetRegionIds(),
|
||
Enabled: req.GetEnabled(),
|
||
OperatorUserID: req.GetOperatorUserId(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.RechargeProductResponse{Product: rechargeProductToProto(product)}, nil
|
||
}
|
||
|
||
// UpdateRechargeProduct 修改后台内购商品配置。
|
||
func (s *Server) UpdateRechargeProduct(ctx context.Context, req *walletv1.UpdateRechargeProductRequest) (*walletv1.RechargeProductResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
product, err := s.svc.UpdateRechargeProduct(ctx, ledger.RechargeProductCommand{
|
||
AppCode: req.GetAppCode(),
|
||
ProductID: req.GetProductId(),
|
||
AmountMicro: req.GetAmountMicro(),
|
||
CoinAmount: req.GetCoinAmount(),
|
||
ProductName: req.GetProductName(),
|
||
Description: req.GetDescription(),
|
||
Platform: req.GetPlatform(),
|
||
RegionIDs: req.GetRegionIds(),
|
||
Enabled: req.GetEnabled(),
|
||
OperatorUserID: req.GetOperatorUserId(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.RechargeProductResponse{Product: rechargeProductToProto(product)}, nil
|
||
}
|
||
|
||
// DeleteRechargeProduct 删除后台内购商品配置。
|
||
func (s *Server) DeleteRechargeProduct(ctx context.Context, req *walletv1.DeleteRechargeProductRequest) (*walletv1.DeleteRechargeProductResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
if err := s.svc.DeleteRechargeProduct(ctx, req.GetAppCode(), req.GetProductId()); err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.DeleteRechargeProductResponse{Deleted: true}, nil
|
||
}
|
||
|
||
// GetDiamondExchangeConfig 返回钻石兑换配置。
|
||
func (s *Server) GetDiamondExchangeConfig(ctx context.Context, req *walletv1.GetDiamondExchangeConfigRequest) (*walletv1.GetDiamondExchangeConfigResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
rules, err := s.svc.GetDiamondExchangeConfig(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.GetDiamondExchangeConfigResponse{Rules: make([]*walletv1.DiamondExchangeRule, 0, len(rules))}
|
||
for _, rule := range rules {
|
||
resp.Rules = append(resp.Rules, &walletv1.DiamondExchangeRule{
|
||
ExchangeType: rule.ExchangeType,
|
||
FromAssetType: rule.FromAssetType,
|
||
ToAssetType: rule.ToAssetType,
|
||
FromAmount: rule.FromAmount,
|
||
ToAmount: rule.ToAmount,
|
||
Enabled: rule.Enabled,
|
||
})
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func rechargeProductToProto(product ledger.RechargeProduct) *walletv1.RechargeProduct {
|
||
return &walletv1.RechargeProduct{
|
||
AppCode: product.AppCode,
|
||
ProductId: product.ProductID,
|
||
ProductCode: product.ProductCode,
|
||
ProductName: product.ProductName,
|
||
Description: product.Description,
|
||
Platform: product.Platform,
|
||
Channel: product.Channel,
|
||
CurrencyCode: product.CurrencyCode,
|
||
AmountMicro: product.AmountMicro,
|
||
AmountMinor: product.AmountMinor,
|
||
CoinAmount: product.CoinAmount,
|
||
PolicyVersion: product.PolicyVersion,
|
||
Status: product.Status,
|
||
Enabled: product.Enabled,
|
||
SortOrder: product.SortOrder,
|
||
RegionIds: product.RegionIDs,
|
||
ResourceAssetType: product.ResourceAssetType,
|
||
CreatedByUserId: product.CreatedByUserID,
|
||
UpdatedByUserId: product.UpdatedByUserID,
|
||
CreatedAtMs: product.CreatedAtMS,
|
||
UpdatedAtMs: product.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
// ListWalletTransactions 返回当前用户钱包流水。
|
||
func (s *Server) ListWalletTransactions(ctx context.Context, req *walletv1.ListWalletTransactionsRequest) (*walletv1.ListWalletTransactionsResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
items, total, err := s.svc.ListWalletTransactions(ctx, ledger.ListWalletTransactionsQuery{
|
||
AppCode: req.GetAppCode(),
|
||
UserID: req.GetUserId(),
|
||
AssetType: req.GetAssetType(),
|
||
Page: req.GetPage(),
|
||
PageSize: req.GetPageSize(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.ListWalletTransactionsResponse{Transactions: make([]*walletv1.WalletTransaction, 0, len(items)), Total: total}
|
||
for _, item := range items {
|
||
resp.Transactions = append(resp.Transactions, &walletv1.WalletTransaction{
|
||
EntryId: item.EntryID,
|
||
TransactionId: item.TransactionID,
|
||
BizType: item.BizType,
|
||
AssetType: item.AssetType,
|
||
AvailableDelta: item.AvailableDelta,
|
||
FrozenDelta: item.FrozenDelta,
|
||
AvailableAfter: item.AvailableAfter,
|
||
FrozenAfter: item.FrozenAfter,
|
||
CounterpartyUserId: item.CounterpartyUserID,
|
||
RoomId: item.RoomID,
|
||
CreatedAtMs: item.CreatedAtMS,
|
||
})
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// ApplyWithdrawal 创建提现申请并冻结美元余额。
|
||
func (s *Server) ApplyWithdrawal(ctx context.Context, req *walletv1.ApplyWithdrawalRequest) (*walletv1.ApplyWithdrawalResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
withdrawal, balance, err := s.svc.ApplyWithdrawal(ctx, ledger.WithdrawalCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
UserID: req.GetUserId(),
|
||
Amount: req.GetAmount(),
|
||
PayoutAccount: req.GetPayoutAccount(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.ApplyWithdrawalResponse{
|
||
Withdrawal: withdrawalToProto(withdrawal),
|
||
Balance: balanceToProto(balance),
|
||
}, nil
|
||
}
|
||
|
||
// ListVipPackages 返回当前 VIP 和可购买包列表。
|
||
func (s *Server) ListVipPackages(ctx context.Context, req *walletv1.ListVipPackagesRequest) (*walletv1.ListVipPackagesResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
current, levels, err := s.svc.ListVipPackages(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.ListVipPackagesResponse{CurrentVip: vipToProto(current), Packages: make([]*walletv1.VipLevel, 0, len(levels))}
|
||
for _, level := range levels {
|
||
resp.Packages = append(resp.Packages, vipLevelToProto(level))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// GetMyVip 返回当前登录用户 VIP 状态。
|
||
func (s *Server) GetMyVip(ctx context.Context, req *walletv1.GetMyVipRequest) (*walletv1.GetMyVipResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
vip, err := s.svc.GetMyVip(ctx, req.GetUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.GetMyVipResponse{Vip: vipToProto(vip)}, nil
|
||
}
|
||
|
||
// PurchaseVip 购买、续期或升级 VIP。
|
||
func (s *Server) PurchaseVip(ctx context.Context, req *walletv1.PurchaseVipRequest) (*walletv1.PurchaseVipResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.PurchaseVip(ctx, ledger.PurchaseVipCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
UserID: req.GetUserId(),
|
||
Level: req.GetLevel(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.PurchaseVipResponse{
|
||
OrderId: receipt.OrderID,
|
||
TransactionId: receipt.TransactionID,
|
||
Vip: vipToProto(receipt.Vip),
|
||
CoinSpent: receipt.CoinSpent,
|
||
CoinBalanceAfter: receipt.CoinBalanceAfter,
|
||
RewardItems: vipRewardItemsToProto(receipt.RewardItems),
|
||
}, nil
|
||
}
|
||
|
||
// GrantVip 统一处理活动和后台赠送 VIP。
|
||
func (s *Server) GrantVip(ctx context.Context, req *walletv1.GrantVipRequest) (*walletv1.GrantVipResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.GrantVip(ctx, ledger.GrantVipCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
Level: req.GetLevel(),
|
||
GrantSource: req.GetGrantSource(),
|
||
OperatorUserID: req.GetOperatorUserId(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.GrantVipResponse{
|
||
TransactionId: receipt.TransactionID,
|
||
Vip: vipToProto(receipt.Vip),
|
||
RewardItems: vipRewardItemsToProto(receipt.RewardItems),
|
||
ServerTimeMs: time.Now().UnixMilli(),
|
||
}, nil
|
||
}
|
||
|
||
// ListAdminVipLevels 返回后台 VIP 配置。
|
||
func (s *Server) ListAdminVipLevels(ctx context.Context, req *walletv1.ListAdminVipLevelsRequest) (*walletv1.ListAdminVipLevelsResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
levels, err := s.svc.ListAdminVipLevels(ctx)
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.ListAdminVipLevelsResponse{Levels: make([]*walletv1.VipLevel, 0, len(levels)), ServerTimeMs: time.Now().UnixMilli()}
|
||
for _, level := range levels {
|
||
resp.Levels = append(resp.Levels, vipLevelToProto(level))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// UpdateAdminVipLevels 保存后台 VIP 配置。
|
||
func (s *Server) UpdateAdminVipLevels(ctx context.Context, req *walletv1.UpdateAdminVipLevelsRequest) (*walletv1.UpdateAdminVipLevelsResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
commands := make([]ledger.AdminVipLevelCommand, 0, len(req.GetLevels()))
|
||
for _, item := range req.GetLevels() {
|
||
if item == nil {
|
||
continue
|
||
}
|
||
commands = append(commands, ledger.AdminVipLevelCommand{
|
||
Level: item.GetLevel(),
|
||
Name: item.GetName(),
|
||
Status: item.GetStatus(),
|
||
PriceCoin: item.GetPriceCoin(),
|
||
DurationMS: item.GetDurationMs(),
|
||
RewardResourceGroupID: item.GetRewardResourceGroupId(),
|
||
RequiredRechargeCoinAmount: item.GetRequiredRechargeCoinAmount(),
|
||
SortOrder: item.GetSortOrder(),
|
||
})
|
||
}
|
||
levels, err := s.svc.UpdateAdminVipLevels(ctx, commands, req.GetOperatorUserId())
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
resp := &walletv1.UpdateAdminVipLevelsResponse{Levels: make([]*walletv1.VipLevel, 0, len(levels)), ServerTimeMs: time.Now().UnixMilli()}
|
||
for _, level := range levels {
|
||
resp.Levels = append(resp.Levels, vipLevelToProto(level))
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
// AdminCreditAsset 处理后台手动调账，公网权限和审计入口由 gateway/admin 层控制。
|
||
func (s *Server) AdminCreditAsset(ctx context.Context, req *walletv1.AdminCreditAssetRequest) (*walletv1.AdminCreditAssetResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
balance, transactionID, err := s.svc.AdminCreditAsset(ctx, ledger.AdminCreditAssetCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
AssetType: req.GetAssetType(),
|
||
Amount: req.GetAmount(),
|
||
OperatorUserID: req.GetOperatorUserId(),
|
||
Reason: req.GetReason(),
|
||
EvidenceRef: req.GetEvidenceRef(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.AdminCreditAssetResponse{
|
||
TransactionId: transactionID,
|
||
Balance: &walletv1.AssetBalance{
|
||
AppCode: balance.AppCode,
|
||
AssetType: balance.AssetType,
|
||
AvailableAmount: balance.AvailableAmount,
|
||
FrozenAmount: balance.FrozenAmount,
|
||
Version: balance.Version,
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
func balancesToProto(balances []ledger.AssetBalance) []*walletv1.AssetBalance {
|
||
items := make([]*walletv1.AssetBalance, 0, len(balances))
|
||
for _, balance := range balances {
|
||
items = append(items, balanceToProto(balance))
|
||
}
|
||
return items
|
||
}
|
||
|
||
func balanceToProto(balance ledger.AssetBalance) *walletv1.AssetBalance {
|
||
return &walletv1.AssetBalance{
|
||
AppCode: balance.AppCode,
|
||
AssetType: balance.AssetType,
|
||
AvailableAmount: balance.AvailableAmount,
|
||
FrozenAmount: balance.FrozenAmount,
|
||
Version: balance.Version,
|
||
}
|
||
}
|
||
|
||
func giftWallItemToProto(item ledger.GiftWallItem) *walletv1.GiftWallItem {
|
||
return &walletv1.GiftWallItem{
|
||
GiftId: item.GiftID,
|
||
GiftName: item.GiftName,
|
||
ResourceId: item.ResourceID,
|
||
Resource: giftWallResourceToProto(item.Resource),
|
||
ResourceSnapshotJson: item.ResourceSnapshotJSON,
|
||
GiftTypeCode: item.GiftTypeCode,
|
||
PresentationJson: item.PresentationJSON,
|
||
GiftCount: item.GiftCount,
|
||
TotalValue: item.TotalValue,
|
||
TotalCoinValue: item.TotalCoinValue,
|
||
TotalDiamondValue: item.TotalDiamondValue,
|
||
TotalGiftPoint: item.TotalGiftPoint,
|
||
TotalHeatValue: item.TotalHeatValue,
|
||
ChargeAssetType: item.ChargeAssetType,
|
||
LastPriceVersion: item.LastPriceVersion,
|
||
FirstReceivedAtMs: item.FirstReceivedAtMS,
|
||
LastReceivedAtMs: item.LastReceivedAtMS,
|
||
SortOrder: item.SortOrder,
|
||
}
|
||
}
|
||
|
||
func giftWallResourceToProto(resource ledger.GiftWallResource) *walletv1.Resource {
|
||
if resource.ResourceID == 0 {
|
||
return nil
|
||
}
|
||
return &walletv1.Resource{
|
||
AppCode: resource.AppCode,
|
||
ResourceId: resource.ResourceID,
|
||
ResourceCode: resource.ResourceCode,
|
||
ResourceType: resource.ResourceType,
|
||
Name: resource.Name,
|
||
Status: resource.Status,
|
||
Grantable: resource.Grantable,
|
||
GrantStrategy: resource.GrantStrategy,
|
||
WalletAssetType: resource.WalletAssetType,
|
||
WalletAssetAmount: resource.WalletAssetAmount,
|
||
UsageScopes: resource.UsageScopes,
|
||
AssetUrl: resource.AssetURL,
|
||
PreviewUrl: resource.PreviewURL,
|
||
AnimationUrl: resource.AnimationURL,
|
||
MetadataJson: resource.MetadataJSON,
|
||
SortOrder: resource.SortOrder,
|
||
CreatedAtMs: resource.CreatedAtMS,
|
||
UpdatedAtMs: resource.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func walletFeatureFlagsToProto(flags ledger.WalletFeatureFlags) *walletv1.WalletFeatureFlags {
|
||
return &walletv1.WalletFeatureFlags{
|
||
RechargeEnabled: flags.RechargeEnabled,
|
||
DiamondExchangeEnabled: flags.DiamondExchangeEnabled,
|
||
WithdrawEnabled: flags.WithdrawEnabled,
|
||
}
|
||
}
|
||
|
||
func withdrawalToProto(withdrawal ledger.WithdrawalRequest) *walletv1.WithdrawalRequest {
|
||
return &walletv1.WithdrawalRequest{
|
||
WithdrawalId: withdrawal.WithdrawalID,
|
||
UserId: withdrawal.UserID,
|
||
AssetType: withdrawal.AssetType,
|
||
Amount: withdrawal.Amount,
|
||
Status: withdrawal.Status,
|
||
PayoutAccount: withdrawal.PayoutAccount,
|
||
Reason: withdrawal.Reason,
|
||
CreatedAtMs: withdrawal.CreatedAtMS,
|
||
UpdatedAtMs: withdrawal.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func vipToProto(vip ledger.UserVip) *walletv1.UserVip {
|
||
return &walletv1.UserVip{
|
||
UserId: vip.UserID,
|
||
Level: vip.Level,
|
||
Name: vip.Name,
|
||
Active: vip.Active,
|
||
StartedAtMs: vip.StartedAtMS,
|
||
ExpiresAtMs: vip.ExpiresAtMS,
|
||
UpdatedAtMs: vip.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func vipLevelToProto(level ledger.VipLevel) *walletv1.VipLevel {
|
||
return &walletv1.VipLevel{
|
||
Level: level.Level,
|
||
Name: level.Name,
|
||
Status: level.Status,
|
||
PriceCoin: level.PriceCoin,
|
||
DurationMs: level.DurationMS,
|
||
RewardResourceGroupId: level.RewardResourceGroupID,
|
||
RewardItems: vipRewardItemsToProto(level.RewardItems),
|
||
CanPurchase: level.CanPurchase,
|
||
SortOrder: level.SortOrder,
|
||
RechargeGateRequired: level.RechargeGateRequired,
|
||
RequiredRechargeCoinAmount: level.RequiredRechargeCoinAmount,
|
||
UserRechargeCoinAmount: level.UserRechargeCoinAmount,
|
||
PurchaseLockedReason: level.PurchaseLockedReason,
|
||
CreatedAtMs: level.CreatedAtMS,
|
||
UpdatedAtMs: level.UpdatedAtMS,
|
||
}
|
||
}
|
||
|
||
func vipRewardItemsToProto(items []ledger.VipRewardItem) []*walletv1.VipRewardItem {
|
||
resp := make([]*walletv1.VipRewardItem, 0, len(items))
|
||
for _, item := range items {
|
||
resp = append(resp, &walletv1.VipRewardItem{
|
||
ResourceId: item.ResourceID,
|
||
ResourceCode: item.ResourceCode,
|
||
ResourceType: item.ResourceType,
|
||
Name: item.Name,
|
||
Quantity: item.Quantity,
|
||
ExpiresAtMs: item.ExpiresAtMS,
|
||
AssetUrl: item.AssetURL,
|
||
PreviewUrl: item.PreviewURL,
|
||
AnimationUrl: item.AnimationURL,
|
||
})
|
||
}
|
||
return resp
|
||
}
|
||
|
||
// CreditTaskReward 处理 activity-service 任务奖励金币入账。
|
||
func (s *Server) CreditTaskReward(ctx context.Context, req *walletv1.CreditTaskRewardRequest) (*walletv1.CreditTaskRewardResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.CreditTaskReward(ctx, ledger.TaskRewardCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
Amount: req.GetAmount(),
|
||
TaskType: req.GetTaskType(),
|
||
TaskID: req.GetTaskId(),
|
||
CycleKey: req.GetCycleKey(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.CreditTaskRewardResponse{
|
||
TransactionId: receipt.TransactionID,
|
||
Amount: receipt.Amount,
|
||
GrantedAtMs: receipt.GrantedAtMS,
|
||
Balance: &walletv1.AssetBalance{
|
||
AppCode: receipt.Balance.AppCode,
|
||
AssetType: receipt.Balance.AssetType,
|
||
AvailableAmount: receipt.Balance.AvailableAmount,
|
||
FrozenAmount: receipt.Balance.FrozenAmount,
|
||
Version: receipt.Balance.Version,
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
// CreditLuckyGiftReward 处理 activity-service 幸运礼物抽奖 outbox 的中奖金币入账。
|
||
func (s *Server) CreditLuckyGiftReward(ctx context.Context, req *walletv1.CreditLuckyGiftRewardRequest) (*walletv1.CreditLuckyGiftRewardResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.CreditLuckyGiftReward(ctx, ledger.LuckyGiftRewardCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
Amount: req.GetAmount(),
|
||
DrawID: req.GetDrawId(),
|
||
RoomID: req.GetRoomId(),
|
||
VisibleRegionID: req.GetVisibleRegionId(),
|
||
GiftID: req.GetGiftId(),
|
||
PoolID: req.GetPoolId(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.CreditLuckyGiftRewardResponse{
|
||
TransactionId: receipt.TransactionID,
|
||
Amount: receipt.Amount,
|
||
GrantedAtMs: receipt.GrantedAtMS,
|
||
Balance: &walletv1.AssetBalance{
|
||
AppCode: receipt.Balance.AppCode,
|
||
AssetType: receipt.Balance.AssetType,
|
||
AvailableAmount: receipt.Balance.AvailableAmount,
|
||
FrozenAmount: receipt.Balance.FrozenAmount,
|
||
Version: receipt.Balance.Version,
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
// ApplyGameCoinChange 处理 game-service 发起的游戏专用金币改账。
|
||
func (s *Server) ApplyGameCoinChange(ctx context.Context, req *walletv1.ApplyGameCoinChangeRequest) (*walletv1.ApplyGameCoinChangeResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.ApplyGameCoinChange(ctx, ledger.GameCoinChangeCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
UserID: req.GetUserId(),
|
||
PlatformCode: req.GetPlatformCode(),
|
||
GameID: req.GetGameId(),
|
||
ProviderOrderID: req.GetProviderOrderId(),
|
||
ProviderRoundID: req.GetProviderRoundId(),
|
||
OpType: req.GetOpType(),
|
||
CoinAmount: req.GetCoinAmount(),
|
||
RoomID: req.GetRoomId(),
|
||
RequestHash: req.GetRequestHash(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
return &walletv1.ApplyGameCoinChangeResponse{
|
||
WalletTransactionId: receipt.TransactionID,
|
||
BalanceAfter: receipt.BalanceAfter,
|
||
IdempotentReplay: receipt.IdempotentReplay,
|
||
}, nil
|
||
}
|
||
|
||
// AdminCreditCoinSellerStock 处理后台币商进货或金币补偿，币商身份由 admin-server 先行校验。
|
||
func (s *Server) AdminCreditCoinSellerStock(ctx context.Context, req *walletv1.AdminCreditCoinSellerStockRequest) (*walletv1.AdminCreditCoinSellerStockResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.AdminCreditCoinSellerStock(ctx, ledger.CoinSellerStockCreditCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
SellerUserID: req.GetSellerUserId(),
|
||
StockType: req.GetStockType(),
|
||
CoinAmount: req.GetCoinAmount(),
|
||
PaidCurrencyCode: req.GetPaidCurrencyCode(),
|
||
PaidAmountMicro: req.GetPaidAmountMicro(),
|
||
PaymentRef: req.GetPaymentRef(),
|
||
EvidenceRef: req.GetEvidenceRef(),
|
||
OperatorUserID: req.GetOperatorUserId(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.AdminCreditCoinSellerStockResponse{
|
||
TransactionId: receipt.TransactionID,
|
||
SellerUserId: receipt.SellerUserID,
|
||
StockType: receipt.StockType,
|
||
CoinAmount: receipt.CoinAmount,
|
||
PaidCurrencyCode: receipt.PaidCurrencyCode,
|
||
PaidAmountMicro: receipt.PaidAmountMicro,
|
||
CountsAsSellerRecharge: receipt.CountsAsSellerRecharge,
|
||
BalanceAfter: receipt.BalanceAfter,
|
||
CreatedAtMs: receipt.CreatedAtMS,
|
||
}, nil
|
||
}
|
||
|
||
// TransferCoinFromSeller 处理币商转玩家金币，调用方必须先完成币商身份校验。
|
||
func (s *Server) TransferCoinFromSeller(ctx context.Context, req *walletv1.TransferCoinFromSellerRequest) (*walletv1.TransferCoinFromSellerResponse, error) {
|
||
ctx = appcode.WithContext(ctx, req.GetAppCode())
|
||
receipt, err := s.svc.TransferCoinFromSeller(ctx, ledger.CoinSellerTransferCommand{
|
||
AppCode: req.GetAppCode(),
|
||
CommandID: req.GetCommandId(),
|
||
SellerUserID: req.GetSellerUserId(),
|
||
TargetUserID: req.GetTargetUserId(),
|
||
SellerRegionID: req.GetSellerRegionId(),
|
||
TargetRegionID: req.GetTargetRegionId(),
|
||
Amount: req.GetAmount(),
|
||
Reason: req.GetReason(),
|
||
})
|
||
if err != nil {
|
||
return nil, xerr.ToGRPCError(err)
|
||
}
|
||
|
||
return &walletv1.TransferCoinFromSellerResponse{
|
||
TransactionId: receipt.TransactionID,
|
||
SellerBalanceAfter: receipt.SellerBalanceAfter,
|
||
TargetBalanceAfter: receipt.TargetBalanceAfter,
|
||
Amount: receipt.Amount,
|
||
RechargeUsdMinor: receipt.RechargeUSDMinor,
|
||
RechargeCurrencyCode: receipt.RechargeCurrencyCode,
|
||
RechargePolicyId: receipt.RechargePolicyID,
|
||
RechargePolicyVersion: receipt.RechargePolicyVersion,
|
||
RechargePolicyCoinAmount: receipt.RechargePolicyCoinAmount,
|
||
RechargePolicyUsdMinorAmount: receipt.RechargePolicyUSDMinorUnit,
|
||
}, nil
|
||
}
|