315 lines
12 KiB
Go
315 lines
12 KiB
Go
package grpc
|
|
|
|
import (
|
|
"context"
|
|
|
|
activityv1 "hyapp.local/api/proto/activity/v1"
|
|
"hyapp/pkg/appcode"
|
|
"hyapp/pkg/xerr"
|
|
domain "hyapp/services/activity-service/internal/domain/luckygift"
|
|
service "hyapp/services/activity-service/internal/service/luckygift"
|
|
)
|
|
|
|
// LuckyGiftServer 暴露房间送礼主链路调用的幸运礼物查询和抽奖入口。
|
|
type LuckyGiftServer struct {
|
|
activityv1.UnimplementedLuckyGiftServiceServer
|
|
|
|
svc *service.Service
|
|
}
|
|
|
|
func NewLuckyGiftServer(svc *service.Service) *LuckyGiftServer {
|
|
return &LuckyGiftServer{svc: svc}
|
|
}
|
|
|
|
func (s *LuckyGiftServer) CheckLuckyGift(ctx context.Context, req *activityv1.CheckLuckyGiftRequest) (*activityv1.CheckLuckyGiftResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
result, err := s.svc.Check(ctx, domain.CheckCommand{
|
|
PoolID: req.GetPoolId(),
|
|
GiftID: req.GetGiftId(),
|
|
UserID: req.GetUserId(),
|
|
RoomID: req.GetRoomId(),
|
|
})
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
return &activityv1.CheckLuckyGiftResponse{
|
|
Enabled: result.Enabled,
|
|
Reason: result.Reason,
|
|
PoolId: result.PoolID,
|
|
GiftId: result.GiftID,
|
|
GiftPrice: result.GiftPrice,
|
|
RuleVersion: result.RuleVersion,
|
|
TargetRtpPpm: result.TargetRTPPPM,
|
|
ExperiencePool: result.ExperiencePool,
|
|
}, nil
|
|
}
|
|
|
|
func (s *LuckyGiftServer) ExecuteLuckyGiftDraw(ctx context.Context, req *activityv1.ExecuteLuckyGiftDrawRequest) (*activityv1.ExecuteLuckyGiftDrawResponse, error) {
|
|
meta := req.GetLuckyGift()
|
|
ctx = appcode.WithContext(ctx, meta.GetMeta().GetAppCode())
|
|
result, err := s.svc.Draw(ctx, luckyDrawCommandFromProto(meta))
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
return &activityv1.ExecuteLuckyGiftDrawResponse{Result: luckyDrawResultToProto(result)}, nil
|
|
}
|
|
|
|
func (s *LuckyGiftServer) BatchExecuteLuckyGiftDraw(ctx context.Context, req *activityv1.BatchExecuteLuckyGiftDrawRequest) (*activityv1.BatchExecuteLuckyGiftDrawResponse, error) {
|
|
if len(req.GetLuckyGifts()) == 0 {
|
|
return nil, xerr.ToGRPCError(xerr.New(xerr.InvalidArgument, "lucky gift batch draw commands are required"))
|
|
}
|
|
ctx = appcode.WithContext(ctx, req.GetLuckyGifts()[0].GetMeta().GetAppCode())
|
|
cmds := make([]domain.DrawCommand, 0, len(req.GetLuckyGifts()))
|
|
for _, meta := range req.GetLuckyGifts() {
|
|
cmds = append(cmds, luckyDrawCommandFromProto(meta))
|
|
}
|
|
results, err := s.svc.DrawBatch(ctx, cmds)
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
resp := &activityv1.BatchExecuteLuckyGiftDrawResponse{Results: make([]*activityv1.LuckyGiftDrawResult, 0, len(results))}
|
|
for _, result := range results {
|
|
resp.Results = append(resp.Results, luckyDrawResultToProto(result))
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
func luckyDrawCommandFromProto(meta *activityv1.LuckyGiftMeta) domain.DrawCommand {
|
|
return domain.DrawCommand{
|
|
CommandID: meta.GetCommandId(),
|
|
PoolID: meta.GetPoolId(),
|
|
UserID: meta.GetUserId(),
|
|
TargetUserID: meta.GetTargetUserId(),
|
|
DeviceID: meta.GetDeviceId(),
|
|
RoomID: meta.GetRoomId(),
|
|
AnchorID: meta.GetAnchorId(),
|
|
GiftID: meta.GetGiftId(),
|
|
GiftCount: meta.GetGiftCount(),
|
|
CoinSpent: meta.GetCoinSpent(),
|
|
PaidAtMS: meta.GetPaidAtMs(),
|
|
VisibleRegionID: meta.GetVisibleRegionId(),
|
|
CountryID: meta.GetCountryId(),
|
|
}
|
|
}
|
|
|
|
// AdminLuckyGiftServer 暴露后台幸运礼物规则配置和抽奖审计入口。
|
|
type AdminLuckyGiftServer struct {
|
|
activityv1.UnimplementedAdminLuckyGiftServiceServer
|
|
|
|
svc *service.Service
|
|
}
|
|
|
|
func NewAdminLuckyGiftServer(svc *service.Service) *AdminLuckyGiftServer {
|
|
return &AdminLuckyGiftServer{svc: svc}
|
|
}
|
|
|
|
func (s *AdminLuckyGiftServer) GetLuckyGiftConfig(ctx context.Context, req *activityv1.GetLuckyGiftConfigRequest) (*activityv1.GetLuckyGiftConfigResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
config, err := s.svc.GetConfig(ctx, req.GetPoolId())
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
return &activityv1.GetLuckyGiftConfigResponse{Config: luckyRuleConfigToProto(config)}, nil
|
|
}
|
|
|
|
func (s *AdminLuckyGiftServer) UpsertLuckyGiftConfig(ctx context.Context, req *activityv1.UpsertLuckyGiftConfigRequest) (*activityv1.UpsertLuckyGiftConfigResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
config := luckyRuleConfigFromProto(req.GetConfig())
|
|
config.CreatedByAdminID = req.GetOperatorAdminId()
|
|
updated, err := s.svc.UpsertConfig(ctx, config)
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
return &activityv1.UpsertLuckyGiftConfigResponse{Config: luckyRuleConfigToProto(updated)}, nil
|
|
}
|
|
|
|
func (s *AdminLuckyGiftServer) ListLuckyGiftConfigs(ctx context.Context, req *activityv1.ListLuckyGiftConfigsRequest) (*activityv1.ListLuckyGiftConfigsResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
configs, err := s.svc.ListConfigs(ctx)
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
resp := &activityv1.ListLuckyGiftConfigsResponse{Configs: make([]*activityv1.LuckyGiftRuleConfig, 0, len(configs))}
|
|
for _, config := range configs {
|
|
resp.Configs = append(resp.Configs, luckyRuleConfigToProto(config))
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
func (s *AdminLuckyGiftServer) ListLuckyGiftDraws(ctx context.Context, req *activityv1.ListLuckyGiftDrawsRequest) (*activityv1.ListLuckyGiftDrawsResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
draws, total, err := s.svc.ListDraws(ctx, domain.DrawQuery{
|
|
GiftID: req.GetGiftId(),
|
|
PoolID: req.GetPoolId(),
|
|
UserID: req.GetUserId(),
|
|
RoomID: req.GetRoomId(),
|
|
Status: req.GetStatus(),
|
|
Page: req.GetPage(),
|
|
PageSize: req.GetPageSize(),
|
|
})
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
resp := &activityv1.ListLuckyGiftDrawsResponse{Draws: make([]*activityv1.LuckyGiftDrawResult, 0, len(draws)), Total: total}
|
|
for _, draw := range draws {
|
|
resp.Draws = append(resp.Draws, luckyDrawResultToProto(draw))
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
func (s *AdminLuckyGiftServer) GetLuckyGiftDrawSummary(ctx context.Context, req *activityv1.GetLuckyGiftDrawSummaryRequest) (*activityv1.GetLuckyGiftDrawSummaryResponse, error) {
|
|
ctx = appcode.WithContext(ctx, req.GetMeta().GetAppCode())
|
|
summary, err := s.svc.GetDrawSummary(ctx, domain.DrawQuery{
|
|
GiftID: req.GetGiftId(),
|
|
PoolID: req.GetPoolId(),
|
|
UserID: req.GetUserId(),
|
|
RoomID: req.GetRoomId(),
|
|
Status: req.GetStatus(),
|
|
})
|
|
if err != nil {
|
|
return nil, xerr.ToGRPCError(err)
|
|
}
|
|
return &activityv1.GetLuckyGiftDrawSummaryResponse{Summary: luckyDrawSummaryToProto(summary)}, nil
|
|
}
|
|
|
|
func luckyRuleConfigFromProto(config *activityv1.LuckyGiftRuleConfig) domain.RuleConfig {
|
|
if config == nil {
|
|
return domain.RuleConfig{}
|
|
}
|
|
stages := make([]domain.RuleStage, 0, len(config.GetStages()))
|
|
for _, stage := range config.GetStages() {
|
|
tiers := make([]domain.RuleTier, 0, len(stage.GetTiers()))
|
|
for _, tier := range stage.GetTiers() {
|
|
tiers = append(tiers, domain.RuleTier{
|
|
Stage: tier.GetStage(),
|
|
TierID: tier.GetTierId(),
|
|
MultiplierPPM: tier.GetMultiplierPpm(),
|
|
BaseWeightPPM: tier.GetBaseWeightPpm(),
|
|
RewardSource: tier.GetRewardSource(),
|
|
HighWaterOnly: tier.GetHighWaterOnly(),
|
|
BroadcastLevel: tier.GetBroadcastLevel(),
|
|
Enabled: tier.GetEnabled(),
|
|
})
|
|
}
|
|
stages = append(stages, domain.RuleStage{
|
|
Stage: stage.GetStage(),
|
|
Tiers: tiers,
|
|
})
|
|
}
|
|
return domain.RuleConfig{
|
|
AppCode: config.GetAppCode(),
|
|
PoolID: config.GetPoolId(),
|
|
RuleVersion: config.GetRuleVersion(),
|
|
Enabled: config.GetEnabled(),
|
|
TargetRTPPPM: config.GetTargetRtpPpm(),
|
|
PoolRatePPM: config.GetPoolRatePpm(),
|
|
SettlementWindowWager: config.GetSettlementWindowWager(),
|
|
ControlBandPPM: config.GetControlBandPpm(),
|
|
GiftPriceReference: config.GetGiftPriceReference(),
|
|
NoviceMaxEquivalentDraws: config.GetNoviceMaxEquivalentDraws(),
|
|
NormalMaxEquivalentDraws: config.GetNormalMaxEquivalentDraws(),
|
|
EffectiveFromMS: config.GetEffectiveFromMs(),
|
|
CreatedByAdminID: config.GetCreatedByAdminId(),
|
|
CreatedAtMS: config.GetCreatedAtMs(),
|
|
MaxSinglePayout: config.GetMaxSinglePayout(),
|
|
UserHourlyPayoutCap: config.GetUserHourlyPayoutCap(),
|
|
UserDailyPayoutCap: config.GetUserDailyPayoutCap(),
|
|
DeviceDailyPayoutCap: config.GetDeviceDailyPayoutCap(),
|
|
RoomHourlyPayoutCap: config.GetRoomHourlyPayoutCap(),
|
|
AnchorDailyPayoutCap: config.GetAnchorDailyPayoutCap(),
|
|
Stages: stages,
|
|
}
|
|
}
|
|
|
|
func luckyRuleConfigToProto(config domain.RuleConfig) *activityv1.LuckyGiftRuleConfig {
|
|
stages := make([]*activityv1.LuckyGiftRuleStage, 0, len(config.Stages))
|
|
for _, stage := range config.Stages {
|
|
tiers := make([]*activityv1.LuckyGiftRuleTier, 0, len(stage.Tiers))
|
|
for _, tier := range stage.Tiers {
|
|
tiers = append(tiers, &activityv1.LuckyGiftRuleTier{
|
|
Stage: tier.Stage,
|
|
TierId: tier.TierID,
|
|
MultiplierPpm: tier.MultiplierPPM,
|
|
BaseWeightPpm: tier.BaseWeightPPM,
|
|
RewardSource: tier.RewardSource,
|
|
HighWaterOnly: tier.HighWaterOnly,
|
|
BroadcastLevel: tier.BroadcastLevel,
|
|
Enabled: tier.Enabled,
|
|
})
|
|
}
|
|
stages = append(stages, &activityv1.LuckyGiftRuleStage{
|
|
Stage: stage.Stage,
|
|
Tiers: tiers,
|
|
})
|
|
}
|
|
return &activityv1.LuckyGiftRuleConfig{
|
|
AppCode: config.AppCode,
|
|
PoolId: config.PoolID,
|
|
RuleVersion: config.RuleVersion,
|
|
Enabled: config.Enabled,
|
|
TargetRtpPpm: config.TargetRTPPPM,
|
|
PoolRatePpm: config.PoolRatePPM,
|
|
SettlementWindowWager: config.SettlementWindowWager,
|
|
ControlBandPpm: config.ControlBandPPM,
|
|
GiftPriceReference: config.GiftPriceReference,
|
|
NoviceMaxEquivalentDraws: config.NoviceMaxEquivalentDraws,
|
|
NormalMaxEquivalentDraws: config.NormalMaxEquivalentDraws,
|
|
EffectiveFromMs: config.EffectiveFromMS,
|
|
CreatedByAdminId: config.CreatedByAdminID,
|
|
CreatedAtMs: config.CreatedAtMS,
|
|
MaxSinglePayout: config.MaxSinglePayout,
|
|
UserHourlyPayoutCap: config.UserHourlyPayoutCap,
|
|
UserDailyPayoutCap: config.UserDailyPayoutCap,
|
|
DeviceDailyPayoutCap: config.DeviceDailyPayoutCap,
|
|
RoomHourlyPayoutCap: config.RoomHourlyPayoutCap,
|
|
AnchorDailyPayoutCap: config.AnchorDailyPayoutCap,
|
|
Stages: stages,
|
|
}
|
|
}
|
|
|
|
func luckyDrawResultToProto(result domain.DrawResult) *activityv1.LuckyGiftDrawResult {
|
|
return &activityv1.LuckyGiftDrawResult{
|
|
DrawId: result.DrawID,
|
|
CommandId: result.CommandID,
|
|
PoolId: result.PoolID,
|
|
GiftId: result.GiftID,
|
|
RuleVersion: result.RuleVersion,
|
|
ExperiencePool: result.ExperiencePool,
|
|
SelectedTierId: result.SelectedTierID,
|
|
MultiplierPpm: result.MultiplierPPM,
|
|
BaseRewardCoins: result.BaseRewardCoins,
|
|
RoomAtmosphereRewardCoins: result.RoomAtmosphereRewardCoins,
|
|
ActivitySubsidyCoins: result.ActivitySubsidyCoins,
|
|
EffectiveRewardCoins: result.EffectiveRewardCoins,
|
|
BudgetSourcesJson: result.BudgetSourcesJSON,
|
|
RewardStatus: result.RewardStatus,
|
|
RtpWindowIndex: result.RTPWindowIndex,
|
|
GiftRtpWindowIndex: result.GiftRTPWindowIndex,
|
|
GlobalBaseRtpPpm: result.GlobalBaseRTPPPM,
|
|
GiftBaseRtpPpm: result.GiftBaseRTPPPM,
|
|
StageFeedback: result.StageFeedback,
|
|
HighMultiplier: result.HighMultiplier,
|
|
CreatedAtMs: result.CreatedAtMS,
|
|
WalletTransactionId: result.WalletTransactionID,
|
|
CoinBalanceAfter: result.CoinBalanceAfter,
|
|
}
|
|
}
|
|
|
|
func luckyDrawSummaryToProto(summary domain.DrawSummary) *activityv1.LuckyGiftDrawSummary {
|
|
return &activityv1.LuckyGiftDrawSummary{
|
|
PoolId: summary.PoolID,
|
|
TotalDraws: summary.TotalDraws,
|
|
UniqueUsers: summary.UniqueUsers,
|
|
UniqueRooms: summary.UniqueRooms,
|
|
TotalSpentCoins: summary.TotalSpentCoins,
|
|
TotalRewardCoins: summary.TotalRewardCoins,
|
|
BaseRewardCoins: summary.BaseRewardCoins,
|
|
RoomAtmosphereRewardCoins: summary.RoomAtmosphereRewardCoins,
|
|
ActivitySubsidyCoins: summary.ActivitySubsidyCoins,
|
|
ActualRtpPpm: summary.ActualRTPPPM,
|
|
PendingDraws: summary.PendingDraws,
|
|
GrantedDraws: summary.GrantedDraws,
|
|
FailedDraws: summary.FailedDraws,
|
|
}
|
|
}
|