Files
go-sms-V2/internal/service/settle/profit.go
T
Tory bb60d60529
ci / test (push) Canceled after 0s
ci / web-test (push) Canceled after 0s
ci / build (push) Canceled after 0s
ci / deploy-dev (push) Canceled after 0s
S4-D1/D2: C1 回调推送引擎+C2 上行自动拉黑——验收项「死信可查/拒收即拉黑」✅: ①C1=callback_task 队列表(迁移 v21,状态机 pending→sent/dead+attempt/next_retry_at/last_code)+PushWorker(2s 扫/批 100/并发 8/2^n 秒指数退避封顶 10min/10 次耗尽死信/UPDATE CAS 防竞态)+双挂点(report 终态首锁[Consumer+PairService,与 CMPP Deliver 同点同语义]+uplink 消费尾)+URL 门控 account_config.report_url/uplink_url(60s TTL 缓存,未配置零任务)+GET /ops/callback(列表+状态计数面板)/POST /ops/callback/:id/resend(casbin ops callback:read/write v21 所种)+前端回调管理页(ops-callback 路由系统管理组+api/callback.ts+状态面板/筛选/载荷展开/死信重派;matrix+guard 33 菜单显式更)+metrics callback_push_total{type,result}/blacklist_total+openapi v1.4.0;②C2=AutoBlacklister 等值词表(trim+lower 防误伤,默认 R/TD/退订/拒收;SystemConfig uplink.blacklist.keywords 可配 60s 刷新)→policy_blacklist(source=2/账号级/uk 幂等)+Redis Set 即时生效,拉黑不影响上行推送(需求原文);③真机全链六步实证(dev 中间件):回执 DELIVRD→detail 终态→HTTP 回调 JSON 送达(200/sent)+上行 R→拉黑(source=2+Redis=1)+推送送达+坏 URL→attempt10→dead→resend ISC:000→修复重投 sent+status_counts 面板;一次性探针 cmd/cbprobe 用后即删+冒烟数据全清;④单测 +13(callback 6[入队门控/载荷/状态机全链/并发批]+uplink 5[词表/配置覆盖/幂等缓存/消费链]+report 2[首锁一次/nil]);⑤门禁=build/vet/-race 40 包/lint 0/eslint0/vue-tsc0/vitest 148/build 全绿;迁移测试 v15..v21 两遍幂等+dev 实跑 v21;gofmt 存量 8 文件顺手清零(S2 遗留);⑥口径诚实标注:载荷无签名挂账/拦截终态 HTTP 未挂(CMPP 侧已有)/PushWorker 单实例 at-least-once;验收单 s4-d1d2-callback.md+CHANGELOG+memory-bank 回填
2026-11-16 11:19:55 +08:00

344 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
}