1018 lines
38 KiB
Go
1018 lines
38 KiB
Go
package payment
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"math"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"hyapp-admin-server/internal/appctx"
|
||
"hyapp-admin-server/internal/config"
|
||
"hyapp-admin-server/internal/integration/googleorders"
|
||
"hyapp-admin-server/internal/model"
|
||
"hyapp-admin-server/internal/repository"
|
||
|
||
"go.mongodb.org/mongo-driver/v2/bson"
|
||
"go.mongodb.org/mongo-driver/v2/mongo"
|
||
)
|
||
|
||
// legacyRechargeBillQuery 是 legacy 账单源支持的筛选子集；用户/币商筛选属于 hyapp 语义，legacy 源不适用。
|
||
type legacyRechargeBillQuery struct {
|
||
Keyword string
|
||
// RechargeType 支持 google_play_recharge / third_party 两个口径；legacy 平台没有币商分支。
|
||
RechargeType string
|
||
// PaidState=unsynced 只看谷歌实付未同步的账单。
|
||
PaidState string
|
||
RegionID int64
|
||
StartAtMS int64
|
||
EndAtMS int64
|
||
Page int
|
||
PageSize int
|
||
}
|
||
|
||
// RechargeBillSource 是 legacy App（Yumi 等 likei 平台）充值账单的外部只读来源；
|
||
// 命中 app_code 后，财务充值明细和汇总直接走该来源，不再请求 wallet-service。
|
||
type RechargeBillSource interface {
|
||
AppCode() string
|
||
AppName() string
|
||
ListRechargeBills(ctx context.Context, query legacyRechargeBillQuery) ([]rechargeBillDTO, int64, error)
|
||
SummarizeRechargeBills(ctx context.Context, query legacyRechargeBillQuery) (rechargeBillSummaryDTO, error)
|
||
// SupportsGooglePaidSync 为 true 时，RefreshGooglePaidDetails 用该 App 的 Play Console 服务账号同步实付明细。
|
||
SupportsGooglePaidSync() bool
|
||
RefreshGooglePaidDetails(ctx context.Context, transactionIDs []string) ([]googleRechargePaidDTO, error)
|
||
// Overview 返回财务概览聚合：按日趋势、区域分布与谷歌实付覆盖度。
|
||
Overview(ctx context.Context, query legacyRechargeBillQuery, tzOffsetMinutes int32) (rechargeBillOverviewDTO, error)
|
||
}
|
||
|
||
// legacyRegionCountryResolver 复用财务范围的区域→国家映射（MongoMoneyRegionSource 已实现）。
|
||
type legacyRegionCountryResolver interface {
|
||
CountryCodesForRegion(ctx context.Context, appCode string, regionID int64) ([]string, bool, error)
|
||
}
|
||
|
||
// LegacyGooglePaidStore 缓存 legacy 谷歌账单的 Orders API 实付明细（repository.Store 实现）。
|
||
type LegacyGooglePaidStore interface {
|
||
UpsertLegacyGooglePaidDetail(detail model.LegacyGooglePaidDetail) error
|
||
LegacyGooglePaidDetails(appCode string, transactionIDs []string) (map[string]model.LegacyGooglePaidDetail, error)
|
||
LegacyGooglePaidStatsByBillTime(appCode string, startAtMS int64, endAtMS int64) (repository.LegacyGooglePaidStats, error)
|
||
LegacyGooglePaidTransactionIDs(appCode string) ([]string, error)
|
||
}
|
||
|
||
// legacyGoogleOrdersClient 按 legacy App 各自的 Play Console 服务账号查订单实付。
|
||
type legacyGoogleOrdersClient interface {
|
||
GetOrder(ctx context.Context, orderID string) (googleorders.Order, error)
|
||
}
|
||
|
||
// errLegacyGooglePaidUnsupported 表示该账单源未配置谷歌包名/服务账号或实付缓存存储。
|
||
var errLegacyGooglePaidUnsupported = errors.New("legacy google paid sync is not configured")
|
||
|
||
// MongoRechargeBillSource 读取 likei Mongo 的 in_app_purchase_details 集合作为充值账单事实。
|
||
type MongoRechargeBillSource struct {
|
||
collection *mongo.Collection
|
||
database *mongo.Database
|
||
config config.FinanceBillSourceConfig
|
||
regionResolvers []legacyRegionCountryResolver
|
||
regionSources []MoneyRegionSource
|
||
paidStore LegacyGooglePaidStore
|
||
googleOrders legacyGoogleOrdersClient
|
||
}
|
||
|
||
// NewMongoRechargeBillSource 创建 legacy 账单源；regionSources 用于把后台区域 ID 解析成国家码过滤条件。
|
||
func NewMongoRechargeBillSource(database *mongo.Database, sourceConfig config.FinanceBillSourceConfig, regionSources ...MoneyRegionSource) *MongoRechargeBillSource {
|
||
if database == nil || !sourceConfig.Enabled {
|
||
return nil
|
||
}
|
||
collectionName := strings.TrimSpace(sourceConfig.MongoCollection)
|
||
if collectionName == "" {
|
||
collectionName = "in_app_purchase_details"
|
||
}
|
||
sourceConfig.AppCode = appctx.Normalize(sourceConfig.AppCode)
|
||
sourceConfig.AppName = strings.TrimSpace(sourceConfig.AppName)
|
||
sourceConfig.SysOrigin = strings.ToUpper(strings.TrimSpace(sourceConfig.SysOrigin))
|
||
source := &MongoRechargeBillSource{collection: database.Collection(collectionName), database: database, config: sourceConfig}
|
||
for _, regionSource := range regionSources {
|
||
if regionSource == nil {
|
||
continue
|
||
}
|
||
source.regionSources = append(source.regionSources, regionSource)
|
||
if resolver, ok := regionSource.(legacyRegionCountryResolver); ok {
|
||
source.regionResolvers = append(source.regionResolvers, resolver)
|
||
}
|
||
}
|
||
return source
|
||
}
|
||
|
||
// SetGooglePaidSync 注入实付缓存存储与该 App 的 Google Orders 客户端；未注入时“查询谷歌实付”对该源不可用。
|
||
func (s *MongoRechargeBillSource) SetGooglePaidSync(paidStore LegacyGooglePaidStore, googleOrders legacyGoogleOrdersClient) {
|
||
if s == nil {
|
||
return
|
||
}
|
||
s.paidStore = paidStore
|
||
s.googleOrders = googleOrders
|
||
}
|
||
|
||
// SupportsGooglePaidSync 供 handler 判定该源能否响应谷歌实付刷新。
|
||
func (s *MongoRechargeBillSource) SupportsGooglePaidSync() bool {
|
||
return s != nil && s.paidStore != nil && s.googleOrders != nil
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) AppCode() string {
|
||
return s.config.AppCode
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) AppName() string {
|
||
if s.config.AppName != "" {
|
||
return s.config.AppName
|
||
}
|
||
return s.config.AppCode
|
||
}
|
||
|
||
// legacyPurchaseDocument 对应 chatapp3-java 的 InAppPurchaseDetails Mongo 文档（只取展示需要的字段）。
|
||
type legacyPurchaseDocument struct {
|
||
ID any `bson:"_id"`
|
||
OrderID string `bson:"orderId"`
|
||
AcceptUserID int64 `bson:"acceptUserId"`
|
||
CountryCode string `bson:"countryCode"`
|
||
Currency string `bson:"currency"`
|
||
Amount any `bson:"amount"`
|
||
AmountUSD any `bson:"amountUsd"`
|
||
Status string `bson:"status"`
|
||
Factory legacyPurchaseFactory `bson:"factory"`
|
||
Products []legacyPurchaseProduct `bson:"products"`
|
||
CreateTime time.Time `bson:"createTime"`
|
||
PurchaseDateMS time.Time `bson:"purchaseDateMs"`
|
||
// LegacyBillCountry 由聚合阶段（legacyCountryResolveStages）解析：账单国家码优先，回退付款用户资料。
|
||
LegacyBillCountry string `bson:"legacyBillCountry"`
|
||
}
|
||
|
||
type legacyPurchaseFactory struct {
|
||
Platform string `bson:"platform"`
|
||
FactoryCode string `bson:"factoryCode"`
|
||
}
|
||
|
||
type legacyPurchaseProduct struct {
|
||
Name string `bson:"name"`
|
||
Content string `bson:"content"`
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) ListRechargeBills(ctx context.Context, query legacyRechargeBillQuery) ([]rechargeBillDTO, int64, error) {
|
||
if s == nil || s.collection == nil {
|
||
return nil, 0, fmt.Errorf("legacy bill source is not configured")
|
||
}
|
||
filter, regionCodes, matchable, err := s.billFilter(ctx, query)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
if !matchable {
|
||
return []rechargeBillDTO{}, 0, nil
|
||
}
|
||
page := query.Page
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
pageSize := query.PageSize
|
||
if pageSize < 1 {
|
||
pageSize = 10
|
||
}
|
||
if len(regionCodes) == 0 {
|
||
return s.listBillsByFilter(ctx, filter, page, pageSize)
|
||
}
|
||
return s.listBillsByRegionPipeline(ctx, filter, regionCodes, page, pageSize)
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) listBillsByFilter(ctx context.Context, filter bson.M, page int, pageSize int) ([]rechargeBillDTO, int64, error) {
|
||
total, err := s.collection.CountDocuments(ctx, filter)
|
||
if err != nil {
|
||
return nil, 0, fmt.Errorf("count legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
// 国家解析放在分页之后：每页最多 pageSize 次 $lookup，用于把账单落到区域列展示。
|
||
pipeline := append(mongo.Pipeline{
|
||
bson.D{{Key: "$match", Value: filter}},
|
||
bson.D{{Key: "$sort", Value: bson.D{{Key: "createTime", Value: -1}, {Key: "_id", Value: -1}}}},
|
||
bson.D{{Key: "$skip", Value: int64(page-1) * int64(pageSize)}},
|
||
bson.D{{Key: "$limit", Value: int64(pageSize)}},
|
||
}, legacyCountryResolveStages()...)
|
||
cursor, err := s.collection.Aggregate(ctx, pipeline)
|
||
if err != nil {
|
||
return nil, 0, fmt.Errorf("query legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
items, err := s.decodeBillCursor(ctx, cursor, pageSize)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
return items, total, nil
|
||
}
|
||
|
||
// listBillsByRegionPipeline 处理区域筛选：likei 账单的 countryCode 长期为空，区域归属只能按付款用户
|
||
// user_run_profile.countryCode 反查，因此列表和计数都要走 $lookup 聚合。
|
||
func (s *MongoRechargeBillSource) listBillsByRegionPipeline(ctx context.Context, filter bson.M, regionCodes []string, page int, pageSize int) ([]rechargeBillDTO, int64, error) {
|
||
base := append(mongo.Pipeline{bson.D{{Key: "$match", Value: filter}}}, legacyRegionLookupStages(regionCodes)...)
|
||
|
||
countCursor, err := s.collection.Aggregate(ctx, append(clonePipeline(base), bson.D{{Key: "$count", Value: "n"}}))
|
||
if err != nil {
|
||
return nil, 0, fmt.Errorf("count legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer countCursor.Close(ctx)
|
||
var total int64
|
||
if countCursor.Next(ctx) {
|
||
var row struct {
|
||
N int64 `bson:"n"`
|
||
}
|
||
if err := countCursor.Decode(&row); err != nil {
|
||
return nil, 0, fmt.Errorf("decode legacy recharge bill count for %s: %w", s.config.AppCode, err)
|
||
}
|
||
total = row.N
|
||
}
|
||
if err := countCursor.Err(); err != nil {
|
||
return nil, 0, fmt.Errorf("iterate legacy recharge bill count for %s: %w", s.config.AppCode, err)
|
||
}
|
||
if total == 0 {
|
||
return []rechargeBillDTO{}, 0, nil
|
||
}
|
||
|
||
pagePipeline := append(clonePipeline(base),
|
||
bson.D{{Key: "$sort", Value: bson.D{{Key: "createTime", Value: -1}, {Key: "_id", Value: -1}}}},
|
||
bson.D{{Key: "$skip", Value: int64(page-1) * int64(pageSize)}},
|
||
bson.D{{Key: "$limit", Value: int64(pageSize)}},
|
||
)
|
||
cursor, err := s.collection.Aggregate(ctx, pagePipeline)
|
||
if err != nil {
|
||
return nil, 0, fmt.Errorf("query legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
items, err := s.decodeBillCursor(ctx, cursor, pageSize)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
return items, total, nil
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) decodeBillCursor(ctx context.Context, cursor *mongo.Cursor, pageSize int) ([]rechargeBillDTO, error) {
|
||
countryToRegion := s.legacyCountryRegionIndex(ctx)
|
||
items := make([]rechargeBillDTO, 0, pageSize)
|
||
for cursor.Next(ctx) {
|
||
var document legacyPurchaseDocument
|
||
if err := cursor.Decode(&document); err != nil {
|
||
return nil, fmt.Errorf("decode legacy recharge bill for %s: %w", s.config.AppCode, err)
|
||
}
|
||
item := legacyRechargeBillDTO(s.config, document)
|
||
// likei 账单没有区域 ID；用解析出的国家码映射区域目录，供列表区域列与导出展示。
|
||
if country := strings.ToUpper(strings.TrimSpace(document.LegacyBillCountry)); country != "" {
|
||
if region, ok := countryToRegion[country]; ok {
|
||
item.TargetRegionID = region.RegionID
|
||
}
|
||
}
|
||
items = append(items, item)
|
||
}
|
||
if err := cursor.Err(); err != nil {
|
||
return nil, fmt.Errorf("iterate legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
if err := s.fillGooglePaidDetails(items); err != nil {
|
||
return nil, err
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
// fillGooglePaidDetails 把已同步的 Orders API 实付明细回填到当页谷歌账单：实付币种/总额/税/净收入，
|
||
// 手续费与 Lalu 同口径反推（实付 − 净收入 − 税）。未同步的谷歌账单保持 paidSyncedAtMs=0，前端提示可查询。
|
||
func (s *MongoRechargeBillSource) fillGooglePaidDetails(items []rechargeBillDTO) error {
|
||
if s.paidStore == nil {
|
||
return nil
|
||
}
|
||
googleTxIDs := make([]string, 0, len(items))
|
||
for _, item := range items {
|
||
if item.RechargeType == "google_play_recharge" {
|
||
googleTxIDs = append(googleTxIDs, item.TransactionID)
|
||
}
|
||
}
|
||
if len(googleTxIDs) == 0 {
|
||
return nil
|
||
}
|
||
details, err := s.paidStore.LegacyGooglePaidDetails(s.config.AppCode, googleTxIDs)
|
||
if err != nil {
|
||
return fmt.Errorf("load legacy google paid details for %s: %w", s.config.AppCode, err)
|
||
}
|
||
for index := range items {
|
||
detail, ok := details[items[index].TransactionID]
|
||
if !ok || items[index].RechargeType != "google_play_recharge" {
|
||
continue
|
||
}
|
||
items[index].UserPaidCurrencyCode = detail.PaidCurrencyCode
|
||
items[index].UserPaidAmountMicro = detail.PaidAmountMicro
|
||
items[index].ProviderTaxMicro = detail.PaidTaxMicro
|
||
items[index].ProviderNetMicro = detail.PaidNetMicro
|
||
if detail.PaidAmountMicro > 0 && detail.PaidNetMicro > 0 {
|
||
if fee := detail.PaidAmountMicro - detail.PaidNetMicro - detail.PaidTaxMicro; fee > 0 {
|
||
items[index].ProviderFeeMicro = fee
|
||
}
|
||
}
|
||
items[index].PaidSyncedAtMS = detail.SyncedAtMS
|
||
}
|
||
return nil
|
||
}
|
||
|
||
const maxLegacyGooglePaidRefreshBatch = 100
|
||
|
||
// RefreshGooglePaidDetails 用该 App 的 Play Console 服务账号逐单拉取实付明细并缓存；单笔失败不阻断整批。
|
||
func (s *MongoRechargeBillSource) RefreshGooglePaidDetails(ctx context.Context, transactionIDs []string) ([]googleRechargePaidDTO, error) {
|
||
if !s.SupportsGooglePaidSync() {
|
||
return nil, errLegacyGooglePaidUnsupported
|
||
}
|
||
cleaned := make([]string, 0, len(transactionIDs))
|
||
for _, transactionID := range transactionIDs {
|
||
if transactionID = strings.TrimSpace(transactionID); transactionID != "" {
|
||
cleaned = append(cleaned, transactionID)
|
||
}
|
||
}
|
||
if len(cleaned) == 0 {
|
||
return []googleRechargePaidDTO{}, nil
|
||
}
|
||
if len(cleaned) > maxLegacyGooglePaidRefreshBatch {
|
||
return nil, fmt.Errorf("too many transaction_ids")
|
||
}
|
||
idValues := make(bson.A, 0, len(cleaned))
|
||
for _, transactionID := range cleaned {
|
||
idValues = append(idValues, transactionID)
|
||
}
|
||
cursor, err := s.collection.Find(ctx, bson.M{
|
||
"_id": bson.M{"$in": idValues},
|
||
"sysOrigin": s.config.SysOrigin,
|
||
})
|
||
if err != nil {
|
||
return nil, fmt.Errorf("load legacy bills for google paid refresh: %w", err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
bills := map[string]legacyPurchaseDocument{}
|
||
for cursor.Next(ctx) {
|
||
var document legacyPurchaseDocument
|
||
if err := cursor.Decode(&document); err != nil {
|
||
return nil, fmt.Errorf("decode legacy bill for google paid refresh: %w", err)
|
||
}
|
||
bills[legacyDocumentID(document.ID)] = document
|
||
}
|
||
if err := cursor.Err(); err != nil {
|
||
return nil, fmt.Errorf("iterate legacy bills for google paid refresh: %w", err)
|
||
}
|
||
|
||
results := make([]googleRechargePaidDTO, 0, len(cleaned))
|
||
for _, transactionID := range cleaned {
|
||
results = append(results, s.refreshGooglePaidDetail(ctx, transactionID, bills))
|
||
}
|
||
return results, nil
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) refreshGooglePaidDetail(ctx context.Context, transactionID string, bills map[string]legacyPurchaseDocument) googleRechargePaidDTO {
|
||
result := googleRechargePaidDTO{TransactionID: transactionID}
|
||
document, ok := bills[transactionID]
|
||
if !ok {
|
||
result.Error = "账单不存在"
|
||
return result
|
||
}
|
||
if strings.ToUpper(strings.TrimSpace(document.Factory.FactoryCode)) != "GOOGLE" {
|
||
result.Error = "不是谷歌账单"
|
||
return result
|
||
}
|
||
orderID := strings.TrimSpace(document.OrderID)
|
||
if orderID == "" {
|
||
result.Error = "缺少谷歌订单号"
|
||
return result
|
||
}
|
||
order, err := s.googleOrders.GetOrder(ctx, orderID)
|
||
if err != nil {
|
||
result.Error = err.Error()
|
||
return result
|
||
}
|
||
syncedAt := time.Now().UnixMilli()
|
||
billCreatedAtMS := int64(0)
|
||
if !document.CreateTime.IsZero() {
|
||
billCreatedAtMS = document.CreateTime.UnixMilli()
|
||
} else if !document.PurchaseDateMS.IsZero() {
|
||
billCreatedAtMS = document.PurchaseDateMS.UnixMilli()
|
||
}
|
||
if err := s.paidStore.UpsertLegacyGooglePaidDetail(model.LegacyGooglePaidDetail{
|
||
AppCode: s.config.AppCode,
|
||
TransactionID: transactionID,
|
||
ProviderOrderID: orderID,
|
||
PaidCurrencyCode: strings.ToUpper(strings.TrimSpace(order.CurrencyCode)),
|
||
PaidAmountMicro: order.TotalAmountMicro,
|
||
PaidTaxMicro: order.TaxAmountMicro,
|
||
PaidNetMicro: order.NetAmountMicro,
|
||
BillUSDMinor: legacyDecimalToMinor(document.AmountUSD),
|
||
BillCreatedAtMS: billCreatedAtMS,
|
||
SyncedAtMS: syncedAt,
|
||
}); err != nil {
|
||
result.Error = err.Error()
|
||
return result
|
||
}
|
||
result.CurrencyCode = strings.ToUpper(strings.TrimSpace(order.CurrencyCode))
|
||
result.PaidAmountMicro = order.TotalAmountMicro
|
||
result.TaxMicro = order.TaxAmountMicro
|
||
result.NetMicro = order.NetAmountMicro
|
||
result.SyncedAtMS = syncedAt
|
||
return result
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) SummarizeRechargeBills(ctx context.Context, query legacyRechargeBillQuery) (rechargeBillSummaryDTO, error) {
|
||
if s == nil || s.collection == nil {
|
||
return rechargeBillSummaryDTO{}, fmt.Errorf("legacy bill source is not configured")
|
||
}
|
||
filter, regionCodes, matchable, err := s.billFilter(ctx, query)
|
||
if err != nil {
|
||
return rechargeBillSummaryDTO{}, err
|
||
}
|
||
if !matchable {
|
||
return rechargeBillSummaryDTO{}, nil
|
||
}
|
||
// 金币数只统计 GOLD/CANDY 商品内容，口径对齐 chatapp3 的 firstGoldProduct；content 非数值时按 0 计入。
|
||
coinExpr := bson.M{"$reduce": bson.M{
|
||
"input": bson.M{"$filter": bson.M{
|
||
"input": bson.M{"$ifNull": bson.A{"$products", bson.A{}}},
|
||
"cond": bson.M{"$in": bson.A{"$$this.name", bson.A{"GOLD", "CANDY"}}},
|
||
}},
|
||
"initialValue": 0,
|
||
"in": bson.M{"$add": bson.A{
|
||
"$$value",
|
||
bson.M{"$convert": bson.M{"input": "$$this.content", "to": "long", "onError": 0, "onNull": 0}},
|
||
}},
|
||
}}
|
||
pipeline := append(mongo.Pipeline{bson.D{{Key: "$match", Value: filter}}}, legacyRegionLookupStages(regionCodes)...)
|
||
pipeline = append(pipeline, bson.D{{Key: "$group", Value: bson.M{
|
||
"_id": bson.M{"$cond": bson.A{
|
||
bson.M{"$eq": bson.A{"$factory.factoryCode", "GOOGLE"}},
|
||
"google",
|
||
"third_party",
|
||
}},
|
||
"billCount": bson.M{"$sum": 1},
|
||
"usd": bson.M{"$sum": bson.M{"$ifNull": bson.A{"$amountUsd", 0}}},
|
||
"coin": bson.M{"$sum": coinExpr},
|
||
}}})
|
||
cursor, err := s.collection.Aggregate(ctx, pipeline)
|
||
if err != nil {
|
||
return rechargeBillSummaryDTO{}, fmt.Errorf("summarize legacy recharge bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
|
||
summary := rechargeBillSummaryDTO{}
|
||
for cursor.Next(ctx) {
|
||
var row struct {
|
||
ID string `bson:"_id"`
|
||
BillCount int64 `bson:"billCount"`
|
||
USD any `bson:"usd"`
|
||
Coin int64 `bson:"coin"`
|
||
}
|
||
if err := cursor.Decode(&row); err != nil {
|
||
return rechargeBillSummaryDTO{}, fmt.Errorf("decode legacy recharge summary for %s: %w", s.config.AppCode, err)
|
||
}
|
||
bucket := rechargeBillSummaryBucketDTO{
|
||
BillCount: row.BillCount,
|
||
CoinAmount: row.Coin,
|
||
USDMinorAmount: legacyDecimalToMinor(row.USD),
|
||
}
|
||
if row.ID == "google" {
|
||
summary.GooglePlay = bucket
|
||
} else {
|
||
summary.ThirdParty.BillCount += bucket.BillCount
|
||
summary.ThirdParty.CoinAmount += bucket.CoinAmount
|
||
summary.ThirdParty.USDMinorAmount += bucket.USDMinorAmount
|
||
}
|
||
}
|
||
if err := cursor.Err(); err != nil {
|
||
return rechargeBillSummaryDTO{}, fmt.Errorf("iterate legacy recharge summary for %s: %w", s.config.AppCode, err)
|
||
}
|
||
summary.Total = rechargeBillSummaryBucketDTO{
|
||
BillCount: summary.GooglePlay.BillCount + summary.ThirdParty.BillCount,
|
||
CoinAmount: summary.GooglePlay.CoinAmount + summary.ThirdParty.CoinAmount,
|
||
USDMinorAmount: summary.GooglePlay.USDMinorAmount + summary.ThirdParty.USDMinorAmount,
|
||
}
|
||
return summary, nil
|
||
}
|
||
|
||
// billFilter 构造与 hyapp 账单列表同口径的 Mongo 过滤条件；返回 matchable=false 表示筛选注定无结果。
|
||
// regionCodes 非空时调用方必须叠加 legacyRegionLookupStages：likei 账单不带国家码，区域归属按付款用户资料判定。
|
||
func (s *MongoRechargeBillSource) billFilter(ctx context.Context, query legacyRechargeBillQuery) (bson.M, []string, bool, error) {
|
||
filter := bson.M{
|
||
"sysOrigin": s.config.SysOrigin,
|
||
"status": "SUCCESS",
|
||
// 订阅免费试用不产生真实付款，与 Aslan 大屏充值口径保持一致。
|
||
"trialPeriod": bson.M{"$ne": true},
|
||
}
|
||
timeRange := bson.M{}
|
||
if query.StartAtMS > 0 {
|
||
timeRange["$gte"] = time.UnixMilli(query.StartAtMS)
|
||
}
|
||
if query.EndAtMS > 0 {
|
||
timeRange["$lt"] = time.UnixMilli(query.EndAtMS)
|
||
}
|
||
if len(timeRange) > 0 {
|
||
filter["createTime"] = timeRange
|
||
}
|
||
if keyword := strings.TrimSpace(query.Keyword); keyword != "" {
|
||
// legacy 集合没有 hyapp 交易号；关键词只精确匹配内部订单 ID 和三方订单号，避免大集合正则扫描。
|
||
filter["$or"] = bson.A{
|
||
bson.M{"_id": keyword},
|
||
bson.M{"orderId": keyword},
|
||
}
|
||
}
|
||
switch strings.ToLower(strings.TrimSpace(query.RechargeType)) {
|
||
case "google_play_recharge":
|
||
filter["factory.factoryCode"] = "GOOGLE"
|
||
case "third_party":
|
||
filter["factory.factoryCode"] = bson.M{"$ne": "GOOGLE"}
|
||
case "coin_seller":
|
||
// legacy 平台没有币商进货口径。
|
||
return nil, nil, false, nil
|
||
}
|
||
if strings.ToLower(strings.TrimSpace(query.PaidState)) == "unsynced" {
|
||
filter["factory.factoryCode"] = "GOOGLE"
|
||
if s.paidStore != nil {
|
||
syncedIDs, err := s.paidStore.LegacyGooglePaidTransactionIDs(s.config.AppCode)
|
||
if err != nil {
|
||
return nil, nil, false, fmt.Errorf("load synced legacy google tx ids for %s: %w", s.config.AppCode, err)
|
||
}
|
||
if len(syncedIDs) > 0 {
|
||
idValues := make(bson.A, 0, len(syncedIDs))
|
||
for _, transactionID := range syncedIDs {
|
||
idValues = append(idValues, transactionID)
|
||
}
|
||
filter["_id"] = bson.M{"$nin": idValues}
|
||
}
|
||
}
|
||
}
|
||
if query.RegionID > 0 {
|
||
codes, handled, err := s.regionCountryCodes(ctx, query.RegionID)
|
||
if err != nil {
|
||
return nil, nil, false, err
|
||
}
|
||
if !handled || len(codes) == 0 {
|
||
return nil, nil, false, nil
|
||
}
|
||
return filter, codes, true, nil
|
||
}
|
||
return filter, nil, true, nil
|
||
}
|
||
|
||
const legacyUserProfileCollection = "user_run_profile"
|
||
|
||
// legacyCountryResolveStages 解析账单的区域归属国家：优先账单自身 countryCode（Aslan 的 MifaPay 单会带），
|
||
// 为空时回退付款用户 user_run_profile.countryCode（Yumi/Aslan 的谷歌单都不带国家码）。
|
||
func legacyCountryResolveStages() mongo.Pipeline {
|
||
return mongo.Pipeline{
|
||
bson.D{{Key: "$lookup", Value: bson.M{
|
||
"from": legacyUserProfileCollection,
|
||
"localField": "acceptUserId",
|
||
"foreignField": "_id",
|
||
"as": "legacyBillUser",
|
||
}}},
|
||
bson.D{{Key: "$addFields", Value: bson.M{
|
||
"legacyBillCountry": bson.M{"$toUpper": bson.M{"$cond": bson.A{
|
||
bson.M{"$ne": bson.A{bson.M{"$ifNull": bson.A{"$countryCode", ""}}, ""}},
|
||
"$countryCode",
|
||
bson.M{"$ifNull": bson.A{bson.M{"$first": "$legacyBillUser.countryCode"}, ""}},
|
||
}}},
|
||
}}},
|
||
}
|
||
}
|
||
|
||
// legacyRegionLookupStages 在国家解析的基础上按区域国家清单过滤；codes 为空时不追加任何阶段。
|
||
func legacyRegionLookupStages(codes []string) mongo.Pipeline {
|
||
if len(codes) == 0 {
|
||
return mongo.Pipeline{}
|
||
}
|
||
return append(legacyCountryResolveStages(),
|
||
bson.D{{Key: "$match", Value: bson.M{"legacyBillCountry": bson.M{"$in": codes}}}},
|
||
)
|
||
}
|
||
|
||
// clonePipeline 复制聚合管道，避免 append 复用底层数组导致 count/分页两条管道互相踩踏。
|
||
func clonePipeline(pipeline mongo.Pipeline) mongo.Pipeline {
|
||
cloned := make(mongo.Pipeline, len(pipeline))
|
||
copy(cloned, pipeline)
|
||
return cloned
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) regionCountryCodes(ctx context.Context, regionID int64) ([]string, bool, error) {
|
||
for _, resolver := range s.regionResolvers {
|
||
codes, handled, err := resolver.CountryCodesForRegion(ctx, s.config.AppCode, regionID)
|
||
if err != nil {
|
||
return nil, false, err
|
||
}
|
||
if handled {
|
||
normalized := make([]string, 0, len(codes))
|
||
for _, code := range codes {
|
||
if code = strings.ToUpper(strings.TrimSpace(code)); code != "" {
|
||
normalized = append(normalized, code)
|
||
}
|
||
}
|
||
return normalized, true, nil
|
||
}
|
||
}
|
||
return nil, false, nil
|
||
}
|
||
|
||
// legacyRechargeBillDTO 把 likei 内购明细收敛成财务充值账单 DTO；金额统一按实付币种微单位、美金最小单位表达。
|
||
func legacyRechargeBillDTO(sourceConfig config.FinanceBillSourceConfig, document legacyPurchaseDocument) rechargeBillDTO {
|
||
createdAtMS := int64(0)
|
||
if !document.CreateTime.IsZero() {
|
||
createdAtMS = document.CreateTime.UnixMilli()
|
||
} else if !document.PurchaseDateMS.IsZero() {
|
||
createdAtMS = document.PurchaseDateMS.UnixMilli()
|
||
}
|
||
factoryCode := strings.ToUpper(strings.TrimSpace(document.Factory.FactoryCode))
|
||
dto := rechargeBillDTO{
|
||
AppCode: sourceConfig.AppCode,
|
||
TransactionID: legacyDocumentID(document.ID),
|
||
RechargeType: legacyRechargeType(factoryCode),
|
||
Status: "succeeded",
|
||
ExternalRef: strings.TrimSpace(document.OrderID),
|
||
UserID: document.AcceptUserID,
|
||
CurrencyCode: strings.ToUpper(strings.TrimSpace(document.Currency)),
|
||
CoinAmount: legacyGoldCoinAmount(document.Products),
|
||
USDMinorAmount: legacyDecimalToMinor(document.AmountUSD),
|
||
CreatedAtMS: createdAtMS,
|
||
ProviderCode: legacyProviderCode(factoryCode),
|
||
UserPaidCurrencyCode: strings.ToUpper(strings.TrimSpace(document.Currency)),
|
||
UserPaidAmountMicro: legacyDecimalToMicro(document.Amount),
|
||
// 非谷歌渠道（MifaPay 等）没有可反推的三方扣款数据，标记已同步；
|
||
// 谷歌账单保持未同步（0），由 Orders API 实付缓存回填后才算同步完成。
|
||
PaidSyncedAtMS: createdAtMS,
|
||
}
|
||
if factoryCode == "GOOGLE" {
|
||
dto.PaidSyncedAtMS = 0
|
||
}
|
||
return dto
|
||
}
|
||
|
||
func legacyDocumentID(value any) string {
|
||
if value == nil {
|
||
return ""
|
||
}
|
||
if text, ok := value.(string); ok {
|
||
return text
|
||
}
|
||
if objectID, ok := value.(bson.ObjectID); ok {
|
||
return objectID.Hex()
|
||
}
|
||
return strings.TrimSpace(fmt.Sprint(value))
|
||
}
|
||
|
||
func legacyRechargeType(factoryCode string) string {
|
||
switch factoryCode {
|
||
case "GOOGLE":
|
||
return "google_play_recharge"
|
||
case "APPLE":
|
||
return "apple_recharge"
|
||
case "HUAWEI":
|
||
return "huawei_recharge"
|
||
case "TELEGRAM":
|
||
return "telegram_recharge"
|
||
case "MIFA_PAY":
|
||
// Aslan 的 H5 三方走 MifaPay；复用 hyapp 的 mifapay 展示口径。
|
||
return "mifapay"
|
||
default:
|
||
return "web_recharge"
|
||
}
|
||
}
|
||
|
||
func legacyProviderCode(factoryCode string) string {
|
||
if factoryCode == "" {
|
||
return "legacy"
|
||
}
|
||
return strings.ToLower(factoryCode)
|
||
}
|
||
|
||
// legacyGoldCoinAmount 只统计 GOLD/CANDY 商品内容，口径对齐 chatapp3 的 firstGoldProduct。
|
||
func legacyGoldCoinAmount(products []legacyPurchaseProduct) int64 {
|
||
var total int64
|
||
for _, product := range products {
|
||
if product.Name != "GOLD" && product.Name != "CANDY" {
|
||
continue
|
||
}
|
||
if amount, err := strconv.ParseInt(strings.TrimSpace(product.Content), 10, 64); err == nil {
|
||
total += amount
|
||
}
|
||
}
|
||
return total
|
||
}
|
||
|
||
// Overview 返回 legacy 账单的按日趋势、区域分布与谷歌实付覆盖度；tzOffsetMinutes 决定日边界。
|
||
func (s *MongoRechargeBillSource) Overview(ctx context.Context, query legacyRechargeBillQuery, tzOffsetMinutes int32) (rechargeBillOverviewDTO, error) {
|
||
overview := rechargeBillOverviewDTO{Daily: []rechargeBillDailyBucketDTO{}, Regions: []rechargeBillRegionBucketDTO{}}
|
||
if s == nil || s.collection == nil {
|
||
return overview, fmt.Errorf("legacy bill source is not configured")
|
||
}
|
||
// 用户提现（银行卡余额兑换金币/转货运代理）与充值渠道筛选无关，先于渠道可匹配性判断统计。
|
||
if err := s.overviewWithdrawal(ctx, query, &overview); err != nil {
|
||
return overview, err
|
||
}
|
||
filter, regionCodes, matchable, err := s.billFilter(ctx, query)
|
||
if err != nil {
|
||
return overview, err
|
||
}
|
||
if !matchable {
|
||
return overview, nil
|
||
}
|
||
base := append(mongo.Pipeline{bson.D{{Key: "$match", Value: filter}}}, legacyRegionLookupStages(regionCodes)...)
|
||
|
||
if err := s.overviewDaily(ctx, base, tzOffsetMinutes, &overview); err != nil {
|
||
return overview, err
|
||
}
|
||
if err := s.overviewRegions(ctx, base, &overview); err != nil {
|
||
return overview, err
|
||
}
|
||
if err := s.overviewGooglePaid(ctx, filter, query, &overview); err != nil {
|
||
return overview, err
|
||
}
|
||
return overview, nil
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) overviewDaily(ctx context.Context, base mongo.Pipeline, tzOffsetMinutes int32, overview *rechargeBillOverviewDTO) error {
|
||
coinExpr := bson.M{"$reduce": bson.M{
|
||
"input": bson.M{"$filter": bson.M{
|
||
"input": bson.M{"$ifNull": bson.A{"$products", bson.A{}}},
|
||
"cond": bson.M{"$in": bson.A{"$$this.name", bson.A{"GOLD", "CANDY"}}},
|
||
}},
|
||
"initialValue": 0,
|
||
"in": bson.M{"$add": bson.A{
|
||
"$$value",
|
||
bson.M{"$convert": bson.M{"input": "$$this.content", "to": "long", "onError": 0, "onNull": 0}},
|
||
}},
|
||
}}
|
||
isGoogle := bson.M{"$eq": bson.A{"$factory.factoryCode", "GOOGLE"}}
|
||
pipeline := append(clonePipeline(base),
|
||
bson.D{{Key: "$group", Value: bson.M{
|
||
"_id": bson.M{"$dateToString": bson.M{"format": "%Y-%m-%d", "date": "$createTime", "timezone": legacyTimezoneOffset(tzOffsetMinutes)}},
|
||
"googleUsd": bson.M{"$sum": bson.M{"$cond": bson.A{isGoogle, bson.M{"$ifNull": bson.A{"$amountUsd", 0}}, 0}}},
|
||
"thirdUsd": bson.M{"$sum": bson.M{"$cond": bson.A{isGoogle, 0, bson.M{"$ifNull": bson.A{"$amountUsd", 0}}}}},
|
||
"googleCoin": bson.M{"$sum": bson.M{"$cond": bson.A{isGoogle, coinExpr, 0}}},
|
||
"thirdCoin": bson.M{"$sum": bson.M{"$cond": bson.A{isGoogle, 0, coinExpr}}},
|
||
}}},
|
||
bson.D{{Key: "$sort", Value: bson.M{"_id": 1}}},
|
||
)
|
||
cursor, err := s.collection.Aggregate(ctx, pipeline)
|
||
if err != nil {
|
||
return fmt.Errorf("aggregate legacy daily overview for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
for cursor.Next(ctx) {
|
||
var row struct {
|
||
Date string `bson:"_id"`
|
||
GoogleUSD any `bson:"googleUsd"`
|
||
ThirdUSD any `bson:"thirdUsd"`
|
||
GoogleCoin int64 `bson:"googleCoin"`
|
||
ThirdCoin int64 `bson:"thirdCoin"`
|
||
}
|
||
if err := cursor.Decode(&row); err != nil {
|
||
return fmt.Errorf("decode legacy daily overview for %s: %w", s.config.AppCode, err)
|
||
}
|
||
overview.Daily = append(overview.Daily, rechargeBillDailyBucketDTO{
|
||
Date: row.Date,
|
||
GoogleUsdMinor: legacyDecimalToMinor(row.GoogleUSD),
|
||
ThirdPartyUsdMinor: legacyDecimalToMinor(row.ThirdUSD),
|
||
GoogleCoinAmount: row.GoogleCoin,
|
||
ThirdPartyCoinAmount: row.ThirdCoin,
|
||
})
|
||
}
|
||
return cursor.Err()
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) overviewRegions(ctx context.Context, base mongo.Pipeline, overview *rechargeBillOverviewDTO) error {
|
||
pipeline := clonePipeline(base)
|
||
// 区域分布需要国家解析；若区域筛选未触发 lookup，这里补上（重复 addFields 无害但避免重复 lookup）。
|
||
if len(pipeline) == 1 {
|
||
pipeline = append(pipeline, legacyCountryResolveStages()...)
|
||
}
|
||
pipeline = append(pipeline,
|
||
bson.D{{Key: "$group", Value: bson.M{
|
||
"_id": "$legacyBillCountry",
|
||
"billCount": bson.M{"$sum": 1},
|
||
"usd": bson.M{"$sum": bson.M{"$ifNull": bson.A{"$amountUsd", 0}}},
|
||
}}},
|
||
)
|
||
cursor, err := s.collection.Aggregate(ctx, pipeline)
|
||
if err != nil {
|
||
return fmt.Errorf("aggregate legacy region overview for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
|
||
countryToRegion := s.legacyCountryRegionIndex(ctx)
|
||
buckets := map[int64]*rechargeBillRegionBucketDTO{}
|
||
for cursor.Next(ctx) {
|
||
var row struct {
|
||
Country string `bson:"_id"`
|
||
BillCount int64 `bson:"billCount"`
|
||
USD any `bson:"usd"`
|
||
}
|
||
if err := cursor.Decode(&row); err != nil {
|
||
return fmt.Errorf("decode legacy region overview for %s: %w", s.config.AppCode, err)
|
||
}
|
||
region, ok := countryToRegion[strings.ToUpper(strings.TrimSpace(row.Country))]
|
||
if !ok {
|
||
continue
|
||
}
|
||
bucket, exists := buckets[region.RegionID]
|
||
if !exists {
|
||
bucket = &rechargeBillRegionBucketDTO{RegionID: region.RegionID, Name: region.Name}
|
||
buckets[region.RegionID] = bucket
|
||
}
|
||
bucket.BillCount += row.BillCount
|
||
bucket.UsdMinorAmount += legacyDecimalToMinor(row.USD)
|
||
}
|
||
if err := cursor.Err(); err != nil {
|
||
return err
|
||
}
|
||
for _, bucket := range buckets {
|
||
overview.Regions = append(overview.Regions, *bucket)
|
||
}
|
||
sort.Slice(overview.Regions, func(i, j int) bool {
|
||
return overview.Regions[i].UsdMinorAmount > overview.Regions[j].UsdMinorAmount
|
||
})
|
||
return nil
|
||
}
|
||
|
||
type legacyRegionRef struct {
|
||
RegionID int64
|
||
Name string
|
||
}
|
||
|
||
// legacyCountryRegionIndex 从区域目录构建国家→区域映射；目录读取失败时区域分布降级为空，不阻断概览其他数据。
|
||
func (s *MongoRechargeBillSource) legacyCountryRegionIndex(ctx context.Context) map[string]legacyRegionRef {
|
||
index := map[string]legacyRegionRef{}
|
||
for _, regionSource := range s.regionSources {
|
||
_, regions, _, err := regionSource.ListMoneyMasterData(ctx, repository.MoneyAccess{All: true})
|
||
if err != nil {
|
||
continue
|
||
}
|
||
for _, region := range regions {
|
||
if appctx.Normalize(region.AppCode) != s.config.AppCode {
|
||
continue
|
||
}
|
||
for _, country := range region.Countries {
|
||
country = strings.ToUpper(strings.TrimSpace(country))
|
||
if country == "" {
|
||
continue
|
||
}
|
||
if _, exists := index[country]; !exists {
|
||
index[country] = legacyRegionRef{RegionID: region.RegionID, Name: region.Name}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return index
|
||
}
|
||
|
||
// legacyGoldWithdrawCollection 是 likei 的“银行卡余额兑换金币”申请集合；
|
||
// 该平台的用户工资转币商即此流程（币商在 likei 叫货运代理 FREIGHT），amount 为提交的美元余额。
|
||
const legacyGoldWithdrawCollection = "user_bank_withdraw_gold_apply"
|
||
|
||
func (s *MongoRechargeBillSource) overviewWithdrawal(ctx context.Context, query legacyRechargeBillQuery, overview *rechargeBillOverviewDTO) error {
|
||
if s.database == nil {
|
||
return nil
|
||
}
|
||
match := bson.M{"sysOrigin": s.config.SysOrigin}
|
||
timeRange := bson.M{}
|
||
if query.StartAtMS > 0 {
|
||
timeRange["$gte"] = time.UnixMilli(query.StartAtMS)
|
||
}
|
||
if query.EndAtMS > 0 {
|
||
timeRange["$lt"] = time.UnixMilli(query.EndAtMS)
|
||
}
|
||
if len(timeRange) > 0 {
|
||
match["createTime"] = timeRange
|
||
}
|
||
pipeline := mongo.Pipeline{bson.D{{Key: "$match", Value: match}}}
|
||
if query.RegionID > 0 {
|
||
codes, handled, err := s.regionCountryCodes(ctx, query.RegionID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !handled || len(codes) == 0 {
|
||
return nil
|
||
}
|
||
// 兑换申请没有国家码，按提交用户的资料国家落区域。
|
||
pipeline = append(pipeline,
|
||
bson.D{{Key: "$lookup", Value: bson.M{
|
||
"from": legacyUserProfileCollection,
|
||
"localField": "submitUserId",
|
||
"foreignField": "_id",
|
||
"as": "legacyBillUser",
|
||
}}},
|
||
bson.D{{Key: "$addFields", Value: bson.M{
|
||
"legacyBillCountry": bson.M{"$toUpper": bson.M{"$ifNull": bson.A{
|
||
bson.M{"$first": "$legacyBillUser.countryCode"},
|
||
"",
|
||
}}},
|
||
}}},
|
||
bson.D{{Key: "$match", Value: bson.M{"legacyBillCountry": bson.M{"$in": codes}}}},
|
||
)
|
||
}
|
||
pipeline = append(pipeline, bson.D{{Key: "$group", Value: bson.M{
|
||
"_id": nil,
|
||
"n": bson.M{"$sum": 1},
|
||
"amount": bson.M{"$sum": bson.M{"$ifNull": bson.A{"$amount", 0}}},
|
||
}}})
|
||
cursor, err := s.database.Collection(legacyGoldWithdrawCollection).Aggregate(ctx, pipeline)
|
||
if err != nil {
|
||
return fmt.Errorf("aggregate legacy gold withdraw for %s: %w", s.config.AppCode, err)
|
||
}
|
||
defer cursor.Close(ctx)
|
||
if cursor.Next(ctx) {
|
||
var row struct {
|
||
N int64 `bson:"n"`
|
||
Amount any `bson:"amount"`
|
||
}
|
||
if err := cursor.Decode(&row); err != nil {
|
||
return fmt.Errorf("decode legacy gold withdraw for %s: %w", s.config.AppCode, err)
|
||
}
|
||
overview.Withdrawal.TransferCount = row.N
|
||
overview.Withdrawal.TransferUsdMinor = legacyDecimalToMinor(row.Amount)
|
||
}
|
||
return cursor.Err()
|
||
}
|
||
|
||
func (s *MongoRechargeBillSource) overviewGooglePaid(ctx context.Context, filter bson.M, query legacyRechargeBillQuery, overview *rechargeBillOverviewDTO) error {
|
||
rechargeType := strings.ToLower(strings.TrimSpace(query.RechargeType))
|
||
if rechargeType != "" && rechargeType != "google_play_recharge" {
|
||
return nil
|
||
}
|
||
googleFilter := bson.M{}
|
||
for key, value := range filter {
|
||
googleFilter[key] = value
|
||
}
|
||
googleFilter["factory.factoryCode"] = "GOOGLE"
|
||
googleCount, err := s.collection.CountDocuments(ctx, googleFilter)
|
||
if err != nil {
|
||
return fmt.Errorf("count legacy google bills for %s: %w", s.config.AppCode, err)
|
||
}
|
||
overview.GooglePaid.GoogleBillCount = googleCount
|
||
if s.paidStore == nil {
|
||
overview.GooglePaid.UnsyncedCount = googleCount
|
||
return nil
|
||
}
|
||
stats, err := s.paidStore.LegacyGooglePaidStatsByBillTime(s.config.AppCode, query.StartAtMS, query.EndAtMS)
|
||
if err != nil {
|
||
return fmt.Errorf("load legacy google paid stats for %s: %w", s.config.AppCode, err)
|
||
}
|
||
overview.GooglePaid.SyncedCount = stats.SyncedCount
|
||
if unsynced := googleCount - stats.SyncedCount; unsynced > 0 {
|
||
overview.GooglePaid.UnsyncedCount = unsynced
|
||
}
|
||
overview.GooglePaid.CoveredUsdMinor = stats.CoveredUSDMinor
|
||
overview.GooglePaid.EstFeeUsdMinor = stats.EstFeeUSDMinor
|
||
overview.GooglePaid.EstTaxUsdMinor = stats.EstTaxUSDMinor
|
||
overview.GooglePaid.EstNetUsdMinor = stats.EstNetUSDMinor
|
||
return nil
|
||
}
|
||
|
||
// legacyTimezoneOffset 把分钟偏移转成 Mongo $dateToString 的时区串，如 480 → "+08:00"。
|
||
func legacyTimezoneOffset(tzOffsetMinutes int32) string {
|
||
sign := "+"
|
||
minutes := tzOffsetMinutes
|
||
if minutes < 0 {
|
||
sign = "-"
|
||
minutes = -minutes
|
||
}
|
||
return fmt.Sprintf("%s%02d:%02d", sign, minutes/60, minutes%60)
|
||
}
|
||
|
||
func legacyDecimalToMicro(value any) int64 {
|
||
return legacyDecimalScaled(value, 1_000_000)
|
||
}
|
||
|
||
func legacyDecimalToMinor(value any) int64 {
|
||
return legacyDecimalScaled(value, 100)
|
||
}
|
||
|
||
// legacyDecimalScaled 把 Mongo 里 Decimal128/数值/字符串形式的十进制金额换算成目标最小单位；非法值按 0 处理。
|
||
func legacyDecimalScaled(value any, scale float64) int64 {
|
||
var text string
|
||
switch typed := value.(type) {
|
||
case nil:
|
||
return 0
|
||
case bson.Decimal128:
|
||
text = typed.String()
|
||
case string:
|
||
text = typed
|
||
case int32:
|
||
return int64(typed) * int64(scale)
|
||
case int64:
|
||
return typed * int64(scale)
|
||
case int:
|
||
return int64(typed) * int64(scale)
|
||
case float64:
|
||
text = strconv.FormatFloat(typed, 'f', -1, 64)
|
||
case float32:
|
||
text = strconv.FormatFloat(float64(typed), 'f', -1, 32)
|
||
default:
|
||
text = fmt.Sprint(value)
|
||
}
|
||
parsed, err := strconv.ParseFloat(strings.TrimSpace(text), 64)
|
||
if err != nil || math.IsNaN(parsed) || math.IsInf(parsed, 0) {
|
||
return 0
|
||
}
|
||
return int64(math.Round(parsed * scale))
|
||
}
|