343 lines
11 KiB
Go
343 lines
11 KiB
Go
// profit.go S2-D5:利润分析引擎——用户(含下级树/返点)与通道双视角。
|
|
//
|
|
// 口径(与 D4 出账同源、分析性差异如实声明):
|
|
// - revenue(用户)=Σ(日成功条数×PriceAtAccount 时间线价)——与 GenerateCustomerBills
|
|
// 同口径;**阶梯不进分析**(阶梯是月结出账的整月覆写项,分析用时间线价,
|
|
// 启用阶梯的账号利润行与账单金额可能不同,属口径差异非数据错误);
|
|
// - cost(用户)=全平台通道成本×该账号成功条数/全平台通道成功条数——**占比分摊**
|
|
// (billing_consume_log 与 stats_channel_daily 无账号×通道交叉粒度,精确归因
|
|
// 需新增事实粒度,留 S3+;分摊在总量守恒下误差可控);
|
|
// - rebate(R4)=Σ 直线下级窗口结算额×下级 rebate_rate——该账号(作为上级)的
|
|
// 返点收入,等价于平台让利支出;**历史不重算**:返点不落档,每次查询按当前
|
|
// 树(直线下级)+当前 rate×窗口推导,不存在回溯修正动作(换上级只影响未来
|
|
// 窗口的归属);
|
|
// - profit(用户)=revenue-cost+rebate;平台净利(summary)=Σrevenue-Σcost-Σrebate
|
|
// (返点从平台口径流出、计入上级账号口径);
|
|
// - 通道侧:cost=Σ(日成功×PriceAtChannel);revenue=全平台用户收入×通道成功占比
|
|
// (同分摊口径,与用户侧共用同一分母,Σ通道revenue=Σ用户revenue 恒成立)。
|
|
// 单位:金额均=元(R6;条→元换算仍只在 price.go)。
|
|
package settle
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"go-sms/internal/model/entity"
|
|
errs "go-sms/internal/pkg/errors"
|
|
)
|
|
|
|
// dayWindow 分析窗口归一:零值兜底(From=本月 1 号/To=今天),闭区间转 [lo,hi) 半开。
|
|
func dayWindow(from, to time.Time) (time.Time, time.Time) {
|
|
now := time.Now()
|
|
if to.IsZero() {
|
|
to = now
|
|
}
|
|
hi := time.Date(to.Year(), to.Month(), to.Day(), 0, 0, 0, 0, to.Location()).
|
|
AddDate(0, 0, 1) // 含当日
|
|
if from.IsZero() {
|
|
from = time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
|
|
}
|
|
lo := time.Date(from.Year(), from.Month(), from.Day(), 0, 0, 0, 0, from.Location())
|
|
return lo, hi
|
|
}
|
|
|
|
// UserProfitQuery 用户利润查询条件。
|
|
type UserProfitQuery struct {
|
|
From time.Time // 闭区间起(零值=本月 1 号)
|
|
To time.Time // 闭区间止(零值=今天)
|
|
ParentID int64 // >0:仅该账号为根的子树(Path 前缀)
|
|
Page int
|
|
PageSize int
|
|
}
|
|
|
|
// UserProfitRow 单账号利润行。
|
|
type UserProfitRow struct {
|
|
AccountID int64 `json:"account_id"`
|
|
Username string `json:"username"`
|
|
Role string `json:"role"`
|
|
SuccessCount int64 `json:"success_count"`
|
|
Revenue float64 `json:"revenue"` // 应收(元,时间线价)
|
|
Cost float64 `json:"cost"` // 通道成本分摊(元)
|
|
Rebate float64 `json:"rebate"` // 直线下级返点(R4)
|
|
Profit float64 `json:"profit"` // revenue-cost+rebate
|
|
}
|
|
|
|
// UserProfitSummary 汇总(与列表同 scope:parent_id 过滤后)。
|
|
type UserProfitSummary struct {
|
|
Count int `json:"count"`
|
|
TotalRevenue float64 `json:"total_revenue"`
|
|
TotalCost float64 `json:"total_cost"`
|
|
TotalRebate float64 `json:"total_rebate"`
|
|
PlatformProfit float64 `json:"platform_profit"` // Σrevenue-Σcost-Σrebate
|
|
}
|
|
|
|
// UserProfitResult 用户利润结果集。
|
|
type UserProfitResult struct {
|
|
List []UserProfitRow `json:"list"`
|
|
Total int64 `json:"total"`
|
|
Summary UserProfitSummary `json:"summary"`
|
|
}
|
|
|
|
// UserProfit 用户利润分析。行集=窗口内有消耗的账号 ∪ 收到返点的上级
|
|
// (无自身流量但下级活跃的代理也有行);按 revenue 降序分页(内存排序,
|
|
// 账号量级=运营开户数,非明细量级)。
|
|
func (s *Service) UserProfit(ctx context.Context, q UserProfitQuery) (*UserProfitResult, error) {
|
|
lo, hi := dayWindow(q.From, q.To)
|
|
|
|
// ① 消耗事实源(账号×业务×天)→ 逐行业务线时间线计价。
|
|
var consumes []entity.BillingConsumeLog
|
|
if err := s.db.WithContext(ctx).
|
|
Where("stat_date >= ? AND stat_date < ?", lo, hi).
|
|
Order("stat_date").Find(&consumes).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
var accounts []entity.AccountUser
|
|
if err := s.db.WithContext(ctx).Find(&accounts).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
accByID := make(map[int64]*entity.AccountUser, len(accounts))
|
|
for i := range accounts {
|
|
accByID[accounts[i].ID] = &accounts[i]
|
|
}
|
|
byID := make(map[int64]*UserProfitRow)
|
|
order := make([]int64, 0)
|
|
get := func(id int64) *UserProfitRow {
|
|
if r, ok := byID[id]; ok {
|
|
return r
|
|
}
|
|
acc := accByID[id]
|
|
if acc == nil { // 软删/孤儿消耗行:不入行集(分摊分母走通道侧)
|
|
return nil
|
|
}
|
|
r := &UserProfitRow{AccountID: id, Username: acc.Username, Role: acc.Role}
|
|
byID[id] = r
|
|
order = append(order, id)
|
|
return r
|
|
}
|
|
for _, c := range consumes {
|
|
r := get(c.AccountID)
|
|
if r == nil {
|
|
continue
|
|
}
|
|
r.SuccessCount += int64(c.SuccessCount)
|
|
price, _ := s.PriceAtAccount(ctx, c.AccountID, c.Business, c.StatDate)
|
|
r.Revenue += float64(c.SuccessCount) * price
|
|
}
|
|
|
|
// ② 通道成本总额 + 通道侧成功总数(分摊分母,与通道利润同源)。
|
|
channelCost, channelSuccess, err := s.channelCostTotal(ctx, lo, hi)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, id := range order {
|
|
r := byID[id]
|
|
if channelSuccess > 0 {
|
|
r.Cost = channelCost * float64(r.SuccessCount) / float64(channelSuccess)
|
|
}
|
|
}
|
|
|
|
// ③ 返点(R4):直线下级窗口结算额×下级 rebate_rate → 计入上级行。
|
|
for _, id := range order {
|
|
child := byID[id]
|
|
if child.Revenue <= 0 {
|
|
continue
|
|
}
|
|
acc := accByID[id]
|
|
if acc == nil || acc.RebateRate <= 0 || acc.ParentID <= 0 {
|
|
continue
|
|
}
|
|
if parent := get(acc.ParentID); parent != nil {
|
|
parent.Rebate += child.Revenue * acc.RebateRate
|
|
}
|
|
}
|
|
|
|
// ④ 子树过滤(Path 物化路径前缀;path 空兜底 "/<id>/")。
|
|
if q.ParentID > 0 {
|
|
var root entity.AccountUser
|
|
if err := s.db.WithContext(ctx).First(&root, q.ParentID).Error; err != nil {
|
|
return nil, errs.NotFound.WithMsg("parent_id 账号不存在")
|
|
}
|
|
prefix := root.Path
|
|
if prefix == "" {
|
|
prefix = "/" + strconv.FormatInt(root.ID, 10) + "/"
|
|
}
|
|
filtered := make([]int64, 0, len(order))
|
|
for _, id := range order {
|
|
if id == root.ID || strings.HasPrefix(accByID[id].Path, prefix) {
|
|
filtered = append(filtered, id)
|
|
}
|
|
}
|
|
order = filtered
|
|
}
|
|
|
|
rows := make([]UserProfitRow, 0, len(order))
|
|
sum := UserProfitSummary{}
|
|
for _, id := range order {
|
|
r := byID[id]
|
|
r.Profit = r.Revenue - r.Cost + r.Rebate
|
|
sum.Count++
|
|
sum.TotalRevenue += r.Revenue
|
|
sum.TotalCost += r.Cost
|
|
sum.TotalRebate += r.Rebate
|
|
rows = append(rows, *r)
|
|
}
|
|
sum.PlatformProfit = sum.TotalRevenue - sum.TotalCost - sum.TotalRebate
|
|
sort.Slice(rows, func(i, j int) bool {
|
|
if rows[i].Revenue != rows[j].Revenue {
|
|
return rows[i].Revenue > rows[j].Revenue
|
|
}
|
|
return rows[i].AccountID < rows[j].AccountID
|
|
})
|
|
total := int64(len(rows))
|
|
if q.Page <= 0 {
|
|
q.Page = 1
|
|
}
|
|
if q.PageSize <= 0 || q.PageSize > 100 {
|
|
q.PageSize = 20
|
|
}
|
|
start := (q.Page - 1) * q.PageSize
|
|
if start >= len(rows) {
|
|
rows = []UserProfitRow{}
|
|
} else if start+q.PageSize < len(rows) {
|
|
rows = rows[start : start+q.PageSize]
|
|
} else {
|
|
rows = rows[start:]
|
|
}
|
|
return &UserProfitResult{List: rows, Total: total, Summary: sum}, nil
|
|
}
|
|
|
|
// channelCostTotal 窗口内全平台通道成本(Σ日成功×PriceAtChannel)与通道侧
|
|
// 成功总条数(分摊分母)。
|
|
func (s *Service) channelCostTotal(ctx context.Context, lo, hi time.Time) (cost float64, success int64, err error) {
|
|
var rows []entity.StatsChannelDaily
|
|
if err = s.db.WithContext(ctx).
|
|
Where("stat_date >= ? AND stat_date < ?", lo, hi).
|
|
Order("stat_date").Find(&rows).Error; err != nil {
|
|
return 0, 0, err
|
|
}
|
|
for _, r := range rows {
|
|
success += int64(r.SuccessCount)
|
|
price, _ := s.PriceAtChannel(ctx, r.ChannelID, r.StatDate)
|
|
cost += float64(r.SuccessCount) * price
|
|
}
|
|
return cost, success, nil
|
|
}
|
|
|
|
// ChannelProfitQuery 通道利润查询条件。
|
|
type ChannelProfitQuery struct {
|
|
From time.Time
|
|
To time.Time
|
|
ChannelID int64 // 0=全部
|
|
Page int
|
|
PageSize int
|
|
}
|
|
|
|
// ChannelProfitRow 单通道利润行。
|
|
type ChannelProfitRow struct {
|
|
ChannelID int64 `json:"channel_id"`
|
|
Name string `json:"name"`
|
|
UpstreamID int64 `json:"upstream_id"`
|
|
SuccessCount int64 `json:"success_count"`
|
|
Revenue float64 `json:"revenue"` // 全平台用户收入×成功占比(分摊)
|
|
Cost float64 `json:"cost"` // Σ日成功×通道时间线价
|
|
Profit float64 `json:"profit"`
|
|
}
|
|
|
|
// ChannelProfitResult 通道利润结果集。
|
|
type ChannelProfitResult struct {
|
|
List []ChannelProfitRow `json:"list"`
|
|
Total int64 `json:"total"`
|
|
}
|
|
|
|
// ChannelProfit 通道利润分析:成本=通道价直算;收入=占比分摊(无账号×通道
|
|
// 交叉粒度事实源,见文件头注);Σ通道 revenue=Σ用户 revenue 恒成立。
|
|
func (s *Service) ChannelProfit(ctx context.Context, q ChannelProfitQuery) (*ChannelProfitResult, error) {
|
|
lo, hi := dayWindow(q.From, q.To)
|
|
|
|
var stats []entity.StatsChannelDaily
|
|
db := s.db.WithContext(ctx).
|
|
Where("stat_date >= ? AND stat_date < ?", lo, hi).
|
|
Order("stat_date")
|
|
if q.ChannelID > 0 {
|
|
db = db.Where("channel_id = ?", q.ChannelID)
|
|
}
|
|
if err := db.Find(&stats).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
var channels []entity.ChannelChannel
|
|
if err := s.db.WithContext(ctx).Find(&channels).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
chByID := make(map[int64]*entity.ChannelChannel, len(channels))
|
|
for i := range channels {
|
|
chByID[channels[i].ID] = &channels[i]
|
|
}
|
|
|
|
// 全平台用户收入与通道侧成功总数(收入分摊分母;不随 channel_id 过滤,保证守恒)。
|
|
var totalRevenue float64
|
|
var consumes []entity.BillingConsumeLog
|
|
if err := s.db.WithContext(ctx).
|
|
Where("stat_date >= ? AND stat_date < ?", lo, hi).Find(&consumes).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
for _, c := range consumes {
|
|
price, _ := s.PriceAtAccount(ctx, c.AccountID, c.Business, c.StatDate)
|
|
totalRevenue += float64(c.SuccessCount) * price
|
|
}
|
|
_, channelSuccess, err := s.channelCostTotal(ctx, lo, hi)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
byID := map[int64]*ChannelProfitRow{}
|
|
order := make([]int64, 0)
|
|
for _, r := range stats {
|
|
row := byID[r.ChannelID]
|
|
if row == nil {
|
|
row = &ChannelProfitRow{ChannelID: r.ChannelID}
|
|
if ch := chByID[r.ChannelID]; ch != nil {
|
|
row.Name, row.UpstreamID = ch.Name, ch.UpstreamID
|
|
}
|
|
byID[r.ChannelID] = row
|
|
order = append(order, r.ChannelID)
|
|
}
|
|
row.SuccessCount += int64(r.SuccessCount)
|
|
price, _ := s.PriceAtChannel(ctx, r.ChannelID, r.StatDate)
|
|
row.Cost += float64(r.SuccessCount) * price
|
|
}
|
|
rows := make([]ChannelProfitRow, 0, len(order))
|
|
for _, id := range order {
|
|
r := byID[id]
|
|
if channelSuccess > 0 {
|
|
r.Revenue = totalRevenue * float64(r.SuccessCount) / float64(channelSuccess)
|
|
}
|
|
r.Profit = r.Revenue - r.Cost
|
|
rows = append(rows, *r)
|
|
}
|
|
sort.Slice(rows, func(i, j int) bool {
|
|
if rows[i].SuccessCount != rows[j].SuccessCount {
|
|
return rows[i].SuccessCount > rows[j].SuccessCount
|
|
}
|
|
return rows[i].ChannelID < rows[j].ChannelID
|
|
})
|
|
total := int64(len(rows))
|
|
if q.Page <= 0 {
|
|
q.Page = 1
|
|
}
|
|
if q.PageSize <= 0 || q.PageSize > 100 {
|
|
q.PageSize = 20
|
|
}
|
|
start := (q.Page - 1) * q.PageSize
|
|
if start >= len(rows) {
|
|
rows = []ChannelProfitRow{}
|
|
} else if start+q.PageSize < len(rows) {
|
|
rows = rows[start : start+q.PageSize]
|
|
} else {
|
|
rows = rows[start:]
|
|
}
|
|
return &ChannelProfitResult{List: rows, Total: total}, nil
|
|
}
|