738 lines
29 KiB
Go
738 lines
29 KiB
Go
package mysql
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
mysqlerr "github.com/go-sql-driver/mysql"
|
|
"hyapp/pkg/appcode"
|
|
"hyapp/pkg/xerr"
|
|
)
|
|
|
|
const (
|
|
SourceUser = "user"
|
|
SourceWallet = "wallet"
|
|
SourceRoom = "room"
|
|
SourceGame = "game"
|
|
)
|
|
|
|
// Repository owns the statistics read model. Online queries must use aggregate
|
|
// tables; the optional activity connection only reads lucky-gift day snapshots,
|
|
// never the high-cardinality draw fact table.
|
|
type Repository struct {
|
|
db *sql.DB
|
|
activityDB *sql.DB
|
|
}
|
|
|
|
func Open(ctx context.Context, dsn string, activityDSNs ...string) (*Repository, error) {
|
|
if strings.TrimSpace(dsn) == "" {
|
|
return nil, xerr.New(xerr.InvalidArgument, "mysql_dsn is required")
|
|
}
|
|
db, err := sql.Open("mysql", dsn)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db.PingContext(ctx); err != nil {
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
var activityDB *sql.DB
|
|
if len(activityDSNs) > 0 && strings.TrimSpace(activityDSNs[0]) != "" {
|
|
activityDB, err = sql.Open("mysql", strings.TrimSpace(activityDSNs[0]))
|
|
if err != nil {
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
if err := activityDB.PingContext(ctx); err != nil {
|
|
_ = activityDB.Close()
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
}
|
|
repo := &Repository{db: db, activityDB: activityDB}
|
|
if err := repo.Migrate(ctx); err != nil {
|
|
if activityDB != nil {
|
|
_ = activityDB.Close()
|
|
}
|
|
_ = db.Close()
|
|
return nil, err
|
|
}
|
|
return repo, nil
|
|
}
|
|
|
|
func (r *Repository) Close() error {
|
|
if r == nil {
|
|
return nil
|
|
}
|
|
var err error
|
|
if r.activityDB != nil {
|
|
err = r.activityDB.Close()
|
|
}
|
|
if r.db != nil {
|
|
if dbErr := r.db.Close(); err == nil {
|
|
err = dbErr
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (r *Repository) Ping(ctx context.Context) error {
|
|
if r == nil || r.db == nil {
|
|
return xerr.New(xerr.Unavailable, "mysql repository is not configured")
|
|
}
|
|
if err := r.db.PingContext(ctx); err != nil {
|
|
return err
|
|
}
|
|
if r.activityDB != nil {
|
|
return r.activityDB.PingContext(ctx)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) Migrate(ctx context.Context) error {
|
|
statements := []string{
|
|
`CREATE TABLE IF NOT EXISTS statistics_event_consumption (
|
|
app_code VARCHAR(32) NOT NULL, source VARCHAR(32) NOT NULL, event_id VARCHAR(160) NOT NULL,
|
|
event_type VARCHAR(64) NOT NULL, status VARCHAR(32) NOT NULL, consumed_at_ms BIGINT NOT NULL,
|
|
created_at_ms BIGINT NOT NULL, updated_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, source, event_id),
|
|
KEY idx_statistics_event_type (app_code, source, event_type, consumed_at_ms)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_app_day_country (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
new_users BIGINT NOT NULL DEFAULT 0, active_users BIGINT NOT NULL DEFAULT 0, paid_users BIGINT NOT NULL DEFAULT 0,
|
|
recharge_usd_minor BIGINT NOT NULL DEFAULT 0, new_user_recharge_usd_minor BIGINT NOT NULL DEFAULT 0,
|
|
coin_seller_recharge_usd_minor BIGINT NOT NULL DEFAULT 0, mifapay_recharge_usd_minor BIGINT NOT NULL DEFAULT 0,
|
|
google_recharge_usd_minor BIGINT NOT NULL DEFAULT 0, coin_seller_transfer_coin BIGINT NOT NULL DEFAULT 0,
|
|
gift_coin_spent BIGINT NOT NULL DEFAULT 0,
|
|
lucky_gift_turnover BIGINT NOT NULL DEFAULT 0, lucky_gift_payout BIGINT NOT NULL DEFAULT 0, lucky_gift_payers BIGINT NOT NULL DEFAULT 0,
|
|
game_turnover BIGINT NOT NULL DEFAULT 0, game_players BIGINT NOT NULL DEFAULT 0,
|
|
game_payout BIGINT NOT NULL DEFAULT 0, game_refund BIGINT NOT NULL DEFAULT 0, updated_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, country_id, region_id),
|
|
KEY idx_stat_app_day_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_user_day_activity (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
user_id BIGINT NOT NULL, first_active_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, user_id),
|
|
KEY idx_stat_user_day_country (app_code, stat_day, country_id),
|
|
KEY idx_stat_user_day_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_user_registration (
|
|
app_code VARCHAR(32) NOT NULL, user_id BIGINT NOT NULL, registered_day DATE NOT NULL,
|
|
country_id BIGINT NOT NULL DEFAULT 0, region_id BIGINT NOT NULL DEFAULT 0, registered_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, user_id), KEY idx_stat_user_registration_day (app_code, registered_day, country_id),
|
|
KEY idx_stat_user_registration_region (app_code, registered_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_recharge_day_payers (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
user_id BIGINT NOT NULL, first_paid_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, user_id), KEY idx_stat_recharge_payer_country (app_code, stat_day, country_id),
|
|
KEY idx_stat_recharge_payer_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_lucky_gift_day_payers (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
user_id BIGINT NOT NULL, first_paid_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, user_id),
|
|
KEY idx_stat_lucky_payer_country (app_code, stat_day, country_id),
|
|
KEY idx_stat_lucky_payer_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_lucky_gift_pool_day_country (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
pool_id VARCHAR(96) NOT NULL, turnover_coin BIGINT NOT NULL DEFAULT 0, payout_coin BIGINT NOT NULL DEFAULT 0,
|
|
updated_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, country_id, region_id, pool_id),
|
|
KEY idx_stat_lucky_pool_overview (app_code, stat_day, pool_id),
|
|
KEY idx_stat_lucky_pool_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_game_day_country (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
platform_code VARCHAR(64) NOT NULL DEFAULT '', game_id VARCHAR(96) NOT NULL,
|
|
turnover_coin BIGINT NOT NULL DEFAULT 0, payout_coin BIGINT NOT NULL DEFAULT 0, refund_coin BIGINT NOT NULL DEFAULT 0,
|
|
player_count BIGINT NOT NULL DEFAULT 0, updated_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, country_id, region_id, platform_code, game_id),
|
|
KEY idx_stat_game_day_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
`CREATE TABLE IF NOT EXISTS stat_game_day_players (
|
|
app_code VARCHAR(32) NOT NULL, stat_day DATE NOT NULL, country_id BIGINT NOT NULL DEFAULT 0,
|
|
region_id BIGINT NOT NULL DEFAULT 0,
|
|
platform_code VARCHAR(64) NOT NULL DEFAULT '', game_id VARCHAR(96) NOT NULL,
|
|
user_id BIGINT NOT NULL, first_played_at_ms BIGINT NOT NULL,
|
|
PRIMARY KEY (app_code, stat_day, country_id, platform_code, game_id, user_id),
|
|
KEY idx_stat_game_player_region (app_code, stat_day, region_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
|
|
}
|
|
for _, statement := range statements {
|
|
if _, err := r.db.ExecContext(ctx, statement); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
alterStatements := []string{
|
|
`ALTER TABLE stat_app_day_country ADD COLUMN paid_users BIGINT NOT NULL DEFAULT 0 AFTER active_users`,
|
|
`ALTER TABLE stat_app_day_country ADD COLUMN game_refund BIGINT NOT NULL DEFAULT 0 AFTER game_payout`,
|
|
`ALTER TABLE stat_app_day_country ADD COLUMN lucky_gift_payout BIGINT NOT NULL DEFAULT 0 AFTER lucky_gift_turnover`,
|
|
`ALTER TABLE stat_app_day_country ADD COLUMN coin_seller_transfer_coin BIGINT NOT NULL DEFAULT 0 AFTER google_recharge_usd_minor`,
|
|
`ALTER TABLE stat_game_day_country ADD COLUMN refund_coin BIGINT NOT NULL DEFAULT 0 AFTER payout_coin`,
|
|
`ALTER TABLE stat_app_day_country ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_user_day_activity ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_user_registration ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_recharge_day_payers ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_lucky_gift_day_payers ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_lucky_gift_pool_day_country ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_game_day_country ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_game_day_players ADD COLUMN region_id BIGINT NOT NULL DEFAULT 0 AFTER country_id`,
|
|
`ALTER TABLE stat_app_day_country ADD KEY idx_stat_app_day_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_user_day_activity ADD KEY idx_stat_user_day_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_user_registration ADD KEY idx_stat_user_registration_region (app_code, registered_day, region_id)`,
|
|
`ALTER TABLE stat_recharge_day_payers ADD KEY idx_stat_recharge_payer_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_lucky_gift_day_payers ADD KEY idx_stat_lucky_payer_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_lucky_gift_pool_day_country ADD KEY idx_stat_lucky_pool_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_game_day_country ADD KEY idx_stat_game_day_region (app_code, stat_day, region_id)`,
|
|
`ALTER TABLE stat_game_day_players ADD KEY idx_stat_game_player_region (app_code, stat_day, region_id)`,
|
|
}
|
|
for _, statement := range alterStatements {
|
|
if _, err := r.db.ExecContext(ctx, statement); err != nil && !isDuplicateSchemaError(err) {
|
|
return err
|
|
}
|
|
}
|
|
for table, columns := range map[string][]string{
|
|
"stat_app_day_country": {"app_code", "stat_day", "country_id", "region_id"},
|
|
"stat_lucky_gift_pool_day_country": {"app_code", "stat_day", "country_id", "region_id", "pool_id"},
|
|
"stat_game_day_country": {"app_code", "stat_day", "country_id", "region_id", "platform_code", "game_id"},
|
|
} {
|
|
if err := r.ensurePrimaryKeyColumns(ctx, table, columns); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *Repository) ensurePrimaryKeyColumns(ctx context.Context, table string, expected []string) error {
|
|
rows, err := r.db.QueryContext(ctx, `
|
|
SELECT COLUMN_NAME
|
|
FROM information_schema.KEY_COLUMN_USAGE
|
|
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND CONSTRAINT_NAME = 'PRIMARY'
|
|
ORDER BY ORDINAL_POSITION`, table)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
|
|
actual := make([]string, 0, len(expected))
|
|
for rows.Next() {
|
|
var column string
|
|
if err := rows.Scan(&column); err != nil {
|
|
return err
|
|
}
|
|
actual = append(actual, column)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return err
|
|
}
|
|
if sameStringSlice(actual, expected) {
|
|
return nil
|
|
}
|
|
// 统计聚合表必须同时以国家和区域做主键；否则区域筛选和国家筛选会写入同一行，导致阿富汗这类历史错位国家继续污染榜单。
|
|
_, err = r.db.ExecContext(ctx, "ALTER TABLE "+table+" DROP PRIMARY KEY, ADD PRIMARY KEY ("+strings.Join(expected, ", ")+")")
|
|
return err
|
|
}
|
|
|
|
func sameStringSlice(left, right []string) bool {
|
|
if len(left) != len(right) {
|
|
return false
|
|
}
|
|
for index := range left {
|
|
if left[index] != right[index] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
type UserRegisteredEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
UserID int64
|
|
CountryID int64
|
|
RegionID int64
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type RechargeEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
EventType string
|
|
UserID int64
|
|
USDMinor int64
|
|
CoinAmount int64
|
|
RechargeSequence int64
|
|
TargetCountryID int64
|
|
TargetRegionID int64
|
|
RechargeType string
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type CoinSellerStockEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
SellerUserID int64
|
|
USDMinor int64
|
|
CoinAmount int64
|
|
CountryID int64
|
|
RegionID int64
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type RoomGiftEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
SenderUserID int64
|
|
CountryID int64
|
|
VisibleRegionID int64
|
|
GiftValue int64
|
|
CoinSpent int64
|
|
PoolID string
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type LuckyGiftRewardEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
EventType string
|
|
UserID int64
|
|
CountryID int64
|
|
RegionID int64
|
|
PoolID string
|
|
Amount int64
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type UserActiveEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
EventType string
|
|
UserID int64
|
|
CountryID int64
|
|
RegionID int64
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
type GameOrderEvent struct {
|
|
AppCode string
|
|
EventID string
|
|
UserID int64
|
|
CountryID int64
|
|
RegionID int64
|
|
PlatformCode string
|
|
GameID string
|
|
OpType string
|
|
CoinAmount int64
|
|
OccurredAtMS int64
|
|
}
|
|
|
|
func (r *Repository) ConsumeUserRegistered(ctx context.Context, event UserRegisteredEvent) error {
|
|
return r.withEvent(ctx, SourceUser, event.EventID, "UserRegistered", func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.RegionID)
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
INSERT IGNORE INTO stat_user_registration (app_code, user_id, registered_day, country_id, region_id, registered_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, appcode.Normalize(event.AppCode), event.UserID, day, countryID, regionID, event.OccurredAtMS); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET new_users = new_users + 1, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeRecharge(ctx context.Context, event RechargeEvent) error {
|
|
return r.withEvent(ctx, SourceWallet, event.EventID, event.EventType, func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.TargetCountryID, event.TargetRegionID)
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
paidUsers, err := insertUnique(ctx, tx, `
|
|
INSERT IGNORE INTO stat_recharge_day_payers (app_code, stat_day, country_id, region_id, user_id, first_paid_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, appcode.Normalize(event.AppCode), day, countryID, regionID, event.UserID, event.OccurredAtMS)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
newUserUSD := int64(0)
|
|
if event.RechargeSequence == 1 {
|
|
newUserUSD = event.USDMinor
|
|
}
|
|
coinSellerUSD, mifapayUSD, googleUSD, coinSellerTransferCoin := int64(0), int64(0), int64(0), int64(0)
|
|
switch strings.ToLower(strings.TrimSpace(event.RechargeType)) {
|
|
case "google", "google_play":
|
|
googleUSD = event.USDMinor
|
|
case "mifapay":
|
|
mifapayUSD = event.USDMinor
|
|
case "coin_seller_transfer", "coin_seller":
|
|
coinSellerTransferCoin = event.CoinAmount
|
|
default:
|
|
coinSellerUSD = event.USDMinor
|
|
}
|
|
_, err = tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET recharge_usd_minor = recharge_usd_minor + ?,
|
|
new_user_recharge_usd_minor = new_user_recharge_usd_minor + ?,
|
|
coin_seller_recharge_usd_minor = coin_seller_recharge_usd_minor + ?,
|
|
mifapay_recharge_usd_minor = mifapay_recharge_usd_minor + ?,
|
|
google_recharge_usd_minor = google_recharge_usd_minor + ?,
|
|
coin_seller_transfer_coin = coin_seller_transfer_coin + ?,
|
|
paid_users = paid_users + ?,
|
|
updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, event.USDMinor, newUserUSD, coinSellerUSD, mifapayUSD, googleUSD, coinSellerTransferCoin, paidUsers, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeCoinSellerStock(ctx context.Context, event CoinSellerStockEvent) error {
|
|
return r.withEvent(ctx, SourceWallet, event.EventID, "WalletCoinSellerStockPurchased", func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.RegionID)
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
// 币商进货是后台 USDT 入金事实，只进入总充值和币商充值列；它不是普通用户到账，所以不增加用户 USDT 首充和付费用户。
|
|
_, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET recharge_usd_minor = recharge_usd_minor + ?,
|
|
coin_seller_recharge_usd_minor = coin_seller_recharge_usd_minor + ?,
|
|
updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, event.USDMinor, event.USDMinor, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeRoomGift(ctx context.Context, event RoomGiftEvent) error {
|
|
return r.withEvent(ctx, SourceRoom, event.EventID, "RoomGiftSent", func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.VisibleRegionID)
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
luckyTurnover, luckyPayers := int64(0), int64(0)
|
|
poolID := strings.TrimSpace(event.PoolID)
|
|
if poolID != "" {
|
|
luckyTurnover = event.CoinSpent
|
|
affected, err := insertUnique(ctx, tx, `
|
|
INSERT IGNORE INTO stat_lucky_gift_day_payers (app_code, stat_day, country_id, region_id, user_id, first_paid_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, appcode.Normalize(event.AppCode), day, countryID, regionID, event.SenderUserID, event.OccurredAtMS)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
luckyPayers = affected
|
|
// Pool 明细是 Databi 点击下钻的真实口径：每笔带 pool_id 的幸运礼物送礼先按 UTC 日、国家和奖池累加流水，返奖事件稍后用相同维度补齐 payout。
|
|
if err := ensureLuckyGiftPoolDay(ctx, tx, event.AppCode, day, countryID, regionID, poolID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_lucky_gift_pool_day_country
|
|
SET turnover_coin = turnover_coin + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ? AND pool_id = ?
|
|
`, luckyTurnover, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID, poolID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET gift_coin_spent = gift_coin_spent + ?, lucky_gift_turnover = lucky_gift_turnover + ?,
|
|
lucky_gift_payers = lucky_gift_payers + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, event.CoinSpent, luckyTurnover, luckyPayers, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeLuckyGiftReward(ctx context.Context, event LuckyGiftRewardEvent) error {
|
|
return r.withEvent(ctx, SourceWallet, event.EventID, "WalletLuckyGiftRewardCredited", func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.RegionID)
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
poolID := strings.TrimSpace(event.PoolID)
|
|
if poolID != "" {
|
|
// 钱包返奖事件带回 pool_id 后，按同一 UTC 日和国家写入奖池返奖；利润不落表，查询时用 turnover-payout 实时计算，避免双写漂移。
|
|
if err := ensureLuckyGiftPoolDay(ctx, tx, event.AppCode, day, countryID, regionID, poolID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_lucky_gift_pool_day_country
|
|
SET payout_coin = payout_coin + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ? AND pool_id = ?
|
|
`, event.Amount, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID, poolID); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
_, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET lucky_gift_payout = lucky_gift_payout + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, event.Amount, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeUserActive(ctx context.Context, event UserActiveEvent) error {
|
|
return r.withEvent(ctx, SourceRoom, event.EventID, event.EventType, func(tx *sql.Tx, nowMS int64) error {
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.RegionID)
|
|
return applyActive(ctx, tx, event.AppCode, statDay(event.OccurredAtMS), countryID, regionID, event.UserID, event.OccurredAtMS, nowMS)
|
|
})
|
|
}
|
|
|
|
func (r *Repository) ConsumeGameOrder(ctx context.Context, event GameOrderEvent) error {
|
|
return r.withEvent(ctx, SourceGame, event.EventID, "GameOrderSettled", func(tx *sql.Tx, nowMS int64) error {
|
|
day := statDay(event.OccurredAtMS)
|
|
countryID, regionID := normalizeDimension(event.CountryID, event.RegionID)
|
|
if err := applyActive(ctx, tx, event.AppCode, day, countryID, regionID, event.UserID, event.OccurredAtMS, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if err := ensureAppDay(ctx, tx, event.AppCode, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
turnover, payout, refund := int64(0), int64(0), int64(0)
|
|
switch strings.ToLower(strings.TrimSpace(event.OpType)) {
|
|
case "debit", "bet":
|
|
turnover = event.CoinAmount
|
|
case "credit", "payout":
|
|
payout = event.CoinAmount
|
|
case "refund", "reverse":
|
|
refund = event.CoinAmount
|
|
}
|
|
playerDelta := int64(0)
|
|
if turnover > 0 {
|
|
affected, err := insertUnique(ctx, tx, `
|
|
INSERT IGNORE INTO stat_game_day_players (app_code, stat_day, country_id, region_id, platform_code, game_id, user_id, first_played_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
`, appcode.Normalize(event.AppCode), day, countryID, regionID, event.PlatformCode, event.GameID, event.UserID, event.OccurredAtMS)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
playerDelta = affected
|
|
}
|
|
if err := ensureGameDay(ctx, tx, event.AppCode, day, countryID, regionID, event.PlatformCode, event.GameID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_game_day_country
|
|
SET turnover_coin = turnover_coin + ?, payout_coin = payout_coin + ?, refund_coin = refund_coin + ?,
|
|
player_count = player_count + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ? AND platform_code = ? AND game_id = ?
|
|
`, turnover, payout, refund, playerDelta, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID, event.PlatformCode, event.GameID); err != nil {
|
|
return err
|
|
}
|
|
_, err := tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET game_turnover = game_turnover + ?, game_payout = game_payout + ?, game_refund = game_refund + ?,
|
|
game_players = game_players + ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, turnover, payout, refund, playerDelta, nowMS, appcode.Normalize(event.AppCode), day, countryID, regionID)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (r *Repository) withEvent(ctx context.Context, source string, eventID string, eventType string, apply func(tx *sql.Tx, nowMS int64) error) error {
|
|
var lastErr error
|
|
for attempt := 0; attempt < 5; attempt++ {
|
|
err := r.withEventOnce(ctx, source, eventID, eventType, apply)
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
if !isRetryableMySQLError(err) {
|
|
return err
|
|
}
|
|
lastErr = err
|
|
timer := time.NewTimer(time.Duration(attempt+1) * 50 * time.Millisecond)
|
|
select {
|
|
case <-ctx.Done():
|
|
timer.Stop()
|
|
return ctx.Err()
|
|
case <-timer.C:
|
|
}
|
|
}
|
|
return lastErr
|
|
}
|
|
|
|
func (r *Repository) withEventOnce(ctx context.Context, source string, eventID string, eventType string, apply func(tx *sql.Tx, nowMS int64) error) error {
|
|
if r == nil || r.db == nil {
|
|
return xerr.New(xerr.Unavailable, "mysql repository is not configured")
|
|
}
|
|
app := appcode.FromContext(ctx)
|
|
nowMS := time.Now().UTC().UnixMilli()
|
|
tx, err := r.db.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback() }()
|
|
result, err := tx.ExecContext(ctx, `
|
|
INSERT IGNORE INTO statistics_event_consumption (app_code, source, event_id, event_type, status, consumed_at_ms, created_at_ms, updated_at_ms)
|
|
VALUES (?, ?, ?, ?, 'processing', ?, ?, ?)
|
|
`, app, source, eventID, eventType, nowMS, nowMS, nowMS)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
affected, _ := result.RowsAffected()
|
|
if affected == 0 {
|
|
return tx.Commit()
|
|
}
|
|
if err := apply(tx, nowMS); err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.ExecContext(ctx, `
|
|
UPDATE statistics_event_consumption
|
|
SET status = 'done', consumed_at_ms = ?, updated_at_ms = ?
|
|
WHERE app_code = ? AND source = ? AND event_id = ?
|
|
`, nowMS, nowMS, app, source, eventID); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
}
|
|
|
|
func isRetryableMySQLError(err error) bool {
|
|
var mysqlErr *mysqlerr.MySQLError
|
|
if !errors.As(err, &mysqlErr) {
|
|
return false
|
|
}
|
|
return mysqlErr.Number == 1213 || mysqlErr.Number == 1205
|
|
}
|
|
|
|
func isDuplicateSchemaError(err error) bool {
|
|
var mysqlErr *mysqlerr.MySQLError
|
|
return errors.As(err, &mysqlErr) && (mysqlErr.Number == 1060 || mysqlErr.Number == 1061)
|
|
}
|
|
|
|
func isMissingTableError(err error) bool {
|
|
var mysqlErr *mysqlerr.MySQLError
|
|
return errors.As(err, &mysqlErr) && mysqlErr.Number == 1146
|
|
}
|
|
|
|
func applyActive(ctx context.Context, tx *sql.Tx, app string, day string, countryID int64, regionID int64, userID int64, occurredAtMS int64, nowMS int64) error {
|
|
if err := ensureAppDay(ctx, tx, app, day, countryID, regionID, nowMS); err != nil {
|
|
return err
|
|
}
|
|
affected, err := insertUnique(ctx, tx, `
|
|
INSERT IGNORE INTO stat_user_day_activity (app_code, stat_day, country_id, region_id, user_id, first_active_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
`, appcode.Normalize(app), day, countryID, regionID, userID, occurredAtMS)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if affected == 0 {
|
|
return nil
|
|
}
|
|
_, err = tx.ExecContext(ctx, `
|
|
UPDATE stat_app_day_country
|
|
SET active_users = active_users + 1, updated_at_ms = ?
|
|
WHERE app_code = ? AND stat_day = ? AND country_id = ? AND region_id = ?
|
|
`, nowMS, appcode.Normalize(app), day, countryID, regionID)
|
|
return err
|
|
}
|
|
|
|
func ensureAppDay(ctx context.Context, tx *sql.Tx, app string, day string, countryID int64, regionID int64, nowMS int64) error {
|
|
_, err := tx.ExecContext(ctx, `
|
|
INSERT INTO stat_app_day_country (app_code, stat_day, country_id, region_id, updated_at_ms)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
updated_at_ms = VALUES(updated_at_ms)
|
|
`, appcode.Normalize(app), day, countryID, regionID, nowMS)
|
|
return err
|
|
}
|
|
|
|
func ensureGameDay(ctx context.Context, tx *sql.Tx, app string, day string, countryID int64, regionID int64, platformCode string, gameID string, nowMS int64) error {
|
|
_, err := tx.ExecContext(ctx, `
|
|
INSERT INTO stat_game_day_country (app_code, stat_day, country_id, region_id, platform_code, game_id, updated_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
updated_at_ms = VALUES(updated_at_ms)
|
|
`, appcode.Normalize(app), day, countryID, regionID, platformCode, gameID, nowMS)
|
|
return err
|
|
}
|
|
|
|
func ensureLuckyGiftPoolDay(ctx context.Context, tx *sql.Tx, app string, day string, countryID int64, regionID int64, poolID string, nowMS int64) error {
|
|
_, err := tx.ExecContext(ctx, `
|
|
INSERT INTO stat_lucky_gift_pool_day_country (app_code, stat_day, country_id, region_id, pool_id, updated_at_ms)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
ON DUPLICATE KEY UPDATE
|
|
updated_at_ms = VALUES(updated_at_ms)
|
|
`, appcode.Normalize(app), day, countryID, regionID, strings.TrimSpace(poolID), nowMS)
|
|
return err
|
|
}
|
|
|
|
func insertUnique(ctx context.Context, tx *sql.Tx, query string, args ...any) (int64, error) {
|
|
result, err := tx.ExecContext(ctx, query, args...)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
affected, err := result.RowsAffected()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return affected, nil
|
|
}
|
|
|
|
func statDay(ms int64) string {
|
|
return time.UnixMilli(ms).UTC().Format("2006-01-02")
|
|
}
|
|
|
|
func normalizeID(id int64) int64 {
|
|
if id < 0 {
|
|
return 0
|
|
}
|
|
return id
|
|
}
|
|
|
|
func normalizeDimension(countryID int64, regionID int64) (int64, int64) {
|
|
return normalizeID(countryID), normalizeID(regionID)
|
|
}
|
|
|
|
func DecodeJSON(payload string) map[string]any {
|
|
decoded := map[string]any{}
|
|
_ = json.Unmarshal([]byte(payload), &decoded)
|
|
return decoded
|
|
}
|
|
|
|
func Int64(payload map[string]any, key string) int64 {
|
|
switch value := payload[key].(type) {
|
|
case float64:
|
|
return int64(value)
|
|
case int64:
|
|
return value
|
|
case json.Number:
|
|
v, _ := value.Int64()
|
|
return v
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func String(payload map[string]any, key string) string {
|
|
if value, ok := payload[key].(string); ok {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
return ""
|
|
}
|