report_viewer/代理.md

代理系统重构方案

文档概述

本文档定义了代理系统的核心规则和实现逻辑，包括：

• 代理等级体系：普通、黄金、钻石三个等级
• 团队结构规则：上下级关系约束、升级规则、团队统计
• 业务推广规则：价格体系、收益分配规则
• 升级机制：升级方式、费用规则、返佣规则
• 核心算法：团队统计、收益分配、升级流程等业务逻辑伪代码

一、代理等级体系

1.1 等级定义

• 普通代理（Level 1）：初始等级
• 黄金代理（Level 2）：中级等级
• 钻石代理（Level 3）：最高等级，团队首领

1.2 等级数值映射

代理等级 = {
  普通: 1,
  黄金: 2,
  钻石: 3
}

二、团队结构规则

2.1 团队定义

• 团队：由一个钻石代理作为首领，及其所有下级代理组成的层级关系链
• 团队首领：必须是钻石代理，每个团队有且仅有一个首领
• 团队关系：从普通到钻石的完整链路属于同一个团队

2.2 上下级关系规则

2.2.1 直接上下级约束

• 核心原则：
  1. 下级不能比上级等级高：下级等级必须 ≤ 上级等级
  2. 同级不能作为上下级（除了普通代理）：黄金和钻石不能作为同级上下级
• 允许关系：
  • 普通 → 普通 ✓（同级普通允许）
  • 黄金 → 普通 ✓（上级等级高于下级，允许）
  • 钻石 → 普通 ✓（上级等级高于下级，允许）
  • 钻石 → 黄金 ✓（上级等级高于下级，允许）
• 禁止关系：
  • 普通 → 黄金 ✗（下级等级高于上级，禁止）
  • 普通 → 钻石 ✗（下级等级高于上级，禁止）
  • 黄金 → 黄金 ✗（同级不能作为上下级）
  • 钻石 → 钻石 ✗（同级不能作为上下级）
  • 黄金 → 钻石 ✗（下级等级高于上级，禁止）

2.2.2 升级规则

核心规则：代理升级后，其所有下级（直接+间接）会跟随该代理。

1. 普通 → 黄金：

   • 升级后必须脱离直接上级关系（因为黄金等级高于普通，或与黄金同级，或钻石→黄金禁止）
   • 保留团队关系（通过团队首领钻石代理）
   • 仍属于原团队
   • 下级跟随：所有下级（直接+间接）继续跟随该代理

2. 黄金 → 钻石：

   • 独立成为新团队
   • 成为新团队的首领
   • 下级跟随：所有下级（直接+间接）跟随该代理到新团队

3. 普通 → 钻石：

   • 独立成为新团队
   • 成为新团队的首领
   • 下级跟随：所有下级（直接+间接）跟随该代理到新团队

2.2.3 升级方法和费用规则

升级方式：

1. 钻石代理升级下级：

   • 钻石代理可以将下级的普通代理升级为黄金代理
   • 升级方式：钻石代理操作，无需被升级代理付费

2. 代理自主付费升级：

   • 普通代理可以付费升级为黄金代理
   • 普通代理可以付费升级为钻石代理
   • 黄金代理可以付费升级为钻石代理

升级费用和返佣规则：

升级类型	升级费用	直接上级返佣	说明
普通→黄金	199元	139元	付费后立即返佣给直接上级
普通→钻石	980元	680元	付费后立即返佣给直接上级
黄金→钻石	980元	680元	付费后立即返佣给直接上级
钻石升级下级（普通→黄金）	免费	无	钻石代理操作，被升级代理无需付费

重要规则：

• ✅ 返佣给原直接上级：即使升级后脱离直接上下级关系，返佣仍然给原直接上级
• ✅ 返佣时机：付费成功后立即返佣，然后执行升级操作
• ✅ 升级流程：付费 → 返佣给直接上级 → 升级 → 根据情况脱离关系

升级流程示例：

场景1：普通代理付费升级为黄金

升级前：钻石D → 普通A → 普通B
流程：
1. 普通B支付199元
2. 普通A获得139元返佣（原直接上级）
3. 普通B升级为黄金
4. 黄金B脱离普通A的直接关系（因为黄金等级高于普通，下级不能比上级等级高）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 普通A（获得139元返佣）
      → 黄金B（支付199元，脱离A的直接关系）

场景1-2：普通代理付费升级为黄金（直接上级是黄金/钻石）

升级前：钻石D → 黄金A → 普通B
流程：
1. 普通B支付199元
2. 黄金A获得139元返佣（原直接上级）
3. 普通B升级为黄金
4. 黄金B脱离黄金A的直接关系（因为黄金 → 黄金是禁止的，同级不能作为上下级）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 黄金A（获得139元返佣）
      → 黄金B（支付199元，脱离A的直接关系）

场景2：普通代理付费升级为钻石

升级前：钻石D → 普通A → 普通B
流程：
1. 普通B支付980元
2. 普通A获得680元返佣（原直接上级）
3. 普通B升级为钻石
4. 钻石B独立成新团队（脱离普通A的直接关系）
5. 钻石B的下级跟随到新团队
结果：钻石D → 普通A（获得680元返佣）
      钻石B（新团队，支付980元）

场景3：钻石代理升级下级

升级前：钻石D → 普通A → 普通B
流程：
1. 钻石D操作，将普通B升级为黄金
2. 无需付费
3. 普通B升级为黄金
4. 黄金B脱离普通A的直接关系（因为黄金等级高于普通，下级不能比上级等级高）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 普通A
      → 黄金B（免费升级，脱离A的直接关系）

场景3-2：钻石代理升级下级（直接上级是黄金/钻石）

升级前：钻石D → 黄金A → 普通B
流程：
1. 钻石D操作，将普通B升级为黄金
2. 无需付费
3. 普通B升级为黄金
4. 黄金B脱离黄金A的直接关系（因为黄金 → 黄金是禁止的，同级不能作为上下级）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 黄金A
      → 黄金B（免费升级，脱离A的直接关系）

返佣规则总结：

• 返佣金额 = 升级费用 × 返佣比例
  • 普通→黄金：139元 = 199元 × 69.8%
  • 升级为钻石：680元 = 980元 × 69.4%
• 返佣对象：原直接上级（即使升级后脱离关系）
• 返佣时机：付费成功后立即返佣，然后执行升级

2.3 团队结构树状图示例

以下是从钻石代理作为团队首领的各种层级组合情况：

2.3.1 基础层级结构

场景1：钻石 → 普通 → 普通 → 普通

钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C

场景2：钻石 → 黄金 → 普通

钻石D (团队首领)
└── 黄金A
    └── 普通B

场景3：钻石 → 普通 → 钻石（新团队）

钻石D (团队1首领)
└── 普通A
    └── 钻石B (团队2首领，独立新团队)

场景4：钻石 → 黄金 → 普通

钻石D (团队首领)
└── 黄金A
    └── 普通B

场景5：钻石 → 黄金 → 钻石（新团队）

钻石D (团队1首领)
└── 黄金A
    └── 钻石B (团队2首领，独立新团队)

2.3.2 复杂多分支结构

场景6：钻石下多个分支

钻石D (团队首领)
├── 普通A
│   ├── 普通B
│   │   └── 普通C
│   └── 普通D
├── 普通G
│   └── 普通H
├── 黄金E
│   └── 普通F
└── 黄金I
    └── 普通J

场景7：多层级混合结构

钻石D
├── 黄金A
│   ├── 普通A
│   │   ├── 普通E
│   │   └── 普通F
│   │       └── 普通G
│   └── 普通H
│       └── 普通I
└── 黄金B
    ├── 普通C
    │   └── 普通J
    └── 普通D

说明：此结构符合所有关系约束规则

2.3.3 升级后的结构变化

场景8：普通升级为黄金（脱离直接上级）

升级前：
钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B升级为黄金，黄金等级高于普通，必须脱离A的直接关系）：
钻石D (团队首领)
├── 普通A
│   └── (B已脱离直接关系)
└── 黄金B (仍属于D的团队，但脱离A的直接关系)
    └── 普通C

场景8-2：普通升级为黄金（直接上级是黄金/钻石，脱离关系）

升级前：
钻石D (团队首领)
└── 黄金A
    └── 普通B
        └── 普通C

升级后（B升级为黄金，黄金 → 黄金是禁止关系，需脱离）：
钻石D (团队首领)
├── 黄金A
│   └── (B已脱离直接关系)
└── 黄金B (仍属于D的团队，但脱离A的直接关系)
    └── 普通C

场景9：普通升级为钻石（独立新团队）

升级前：
钻石D (团队1首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B升级为钻石）：
钻石D (团队1首领)
└── 普通A
    └── (B已独立成新团队)

钻石B (团队2首领，新团队)
└── 普通C (跟随B到新团队)

场景10：黄金升级为钻石（独立新团队）

升级前：
钻石D (团队1首领)
└── 黄金A
    ├── 普通B
    └── 普通C

升级后（A升级为钻石）：
钻石D (团队1首领)
└── (A已独立成新团队)

钻石A (团队2首领，新团队)
├── 普通B (跟随A到新团队)
└── 普通C (跟随A到新团队)

2.3.4 特殊边界情况

场景11：普通直接升级为钻石（跳过黄金）

升级前：
钻石D (团队1首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B直接升级为钻石）：
钻石D (团队1首领)
└── 普通A
    └── (B已独立成新团队)

钻石B (团队2首领，新团队)
└── 普通C (跟随B到新团队)

场景12：多级普通代理链

钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C
            └── 普通D
                └── 普通E

场景13：黄金代理下多级普通代理

钻石D (团队首领)
└── 黄金A
    └── 普通B
        └── 普通C
            └── 普通D

2.3.5 图例说明

• 钻石D：团队首领，等级3
• 黄金A：中级代理，等级2
• 普通A：初始代理，等级1
• →：直接上下级关系
• └──：树状图分支线
• ├──：树状图分支线（有后续分支）
• 团队1/团队2：不同团队的标识

2.3.6 关键规则总结

1. 团队首领：必须是钻石代理
2. 直接关系约束：黄金/钻石不能直接管理黄金/钻石
3. 升级影响：
   • 普通→黄金：脱离直接上级，保留团队关系
   • 黄金→钻石：独立成新团队，下级跟随
   • 普通→钻石：独立成新团队，下级跟随
4. 团队归属：通过向上查找钻石代理确定团队归属

2.4 团队查找算法

function findTeamLeader(agent):
  current = agent
  while current.parent exists:
    if current.level == 钻石:
      return current
    current = current.parent
  return null  // 无上级则自己就是首领

2.5 团队统计规则

2.5.1 核心规则定义

团队统计的基本概念：

• 团队定义：每个代理的团队 = 自己 + 所有下级（直接+间接，递归）
• 统计范围：以代理自己为起点，向下递归包含所有下级代理
• 团队独立性：不同代理的团队是不同的，互不干扰
• 权限统一：所有代理（普通、黄金、钻石）的权限范围相同，都只能查看自己团队范围内的数据

关键规则：

1. ✅ 团队范围统一：无论代理等级如何，团队统计范围都是"自己 + 所有下级"
2. ✅ 权限范围统一：所有代理只能查看自己团队的数据，无法查看其他代理的团队数据
3. ✅ 升级后下级跟随：代理升级后，其所有下级（直接+间接）会跟随该代理
4. ✅ 团队归属不变：下级升级脱离直接关系后，不影响上级的团队归属，上级的团队归属保持不变
5. ✅ 单一上级原则：每个代理只可能有一个上级，不可能有多个上级

2.5.2 不同等级代理的团队统计

统一规则：所有等级的代理（普通、黄金、钻石）的团队统计规则完全相同。

代理等级	团队统计范围	权限范围	说明
钻石	自己 + 所有下级	只能查看自己团队	下级可以是普通、黄金（钻石下级会独立成新团队）
黄金	自己 + 所有下级	只能查看自己团队	下级只能是普通（黄金下级会脱离关系）
普通	自己 + 所有下级	只能查看自己团队	下级只能是普通（普通不能作为黄金或钻石的上级）

重要说明：

• 同一代理可能出现在多个上级的团队统计中（这是正常的）
• 例如：A的下级是B，B的下级是C，那么C会同时出现在A和B的团队统计中
• 每个代理的团队统计是独立计算的，互不影响

2.5.3 升级后下级跟随规则

核心规则：代理升级后，其所有下级（直接+间接）会跟随该代理。

升级类型	升级前结构	升级后结构	下级跟随情况
普通→黄金	上级 → 普通A → 下级B → 下级C	上级 → 普通A 黄金A → 下级B → 下级C	B和C跟随A
黄金→钻石	上级 → 黄金A → 下级B → 下级C	上级 钻石A（新团队）→ 下级B → 下级C	B和C跟随A到新团队
普通→钻石	上级 → 普通A → 下级B → 下级C	上级 → 普通A 钻石A（新团队）→ 下级B → 下级C	B和C跟随A到新团队

重要说明：

• 升级后脱离直接关系的代理，其下级会跟随该代理
• 如果升级为钻石，会独立成新团队，下级跟随到新团队
• 升级不影响上级的团队归属，上级的团队归属保持不变

2.5.4 团队统计算法

function getTeamMembers(agent):
  // 获取代理的团队成员（包括自己和所有下级）
  team_members = [agent]  // 包括自己
  
  function collectChildren(agent):
    // 递归收集所有下级
    for each child in agent.children:  // 直接下级
      team_members.append(child)
      collectChildren(child)  // 递归收集间接下级
  
  collectChildren(agent)
  return team_members

function getTeamStatistics(agent):
  // 获取代理的团队统计数据
  team_members = getTeamMembers(agent)
  
  statistics = {
    total_count: team_members的数量,  // 团队总人数（包括自己）
    self: agent,  // 自己
    members: team_members,  // 所有成员（自己+所有下级）
    by_level: {
      钻石: 从team_members中筛选出等级为钻石的,
      黄金: 从team_members中筛选出等级为黄金的,
      普通: 从team_members中筛选出等级为普通的
    },
    direct_children: agent.children,  // 直接下级
    indirect_children: team_members中排除自己和直接下级的  // 间接下级
  }
  
  return statistics

function hasPermissionToView(agent, target_agent):
  // 检查代理是否有权限查看目标代理的数据
  if agent.id == target_agent.id:
    return true  // 可以查看自己
  
  // 检查目标代理是否是当前代理的下级
  team_members = getTeamMembers(agent)
  return target_agent是否在team_members中

2.5.5 团队统计示例

示例1：不同代理的团队统计范围

整体结构：
钻石D
├── 普通A
│   ├── 普通B
│   └── 普通C
├── 黄金E
│   └── 普通F
└── 黄金G
    └── 普通H

各代理的团队统计：

代理	团队统计范围	总计	说明
钻石D	自己 + A + B + C + E + F + G + H	8人	包含所有下级
黄金E	自己 + F	2人	只包含自己的下级
黄金G	自己 + H	2人	只包含自己的下级
普通A	自己 + B + C	3人	只包含自己的下级（普通代理的下级只能是普通代理）

权限说明：

• 钻石D只能查看自己团队（8人）的数据
• 黄金E只能查看自己团队（2人）的数据，看不到D、A、B、C、G、H的数据
• 黄金G只能查看自己团队（2人）的数据，看不到D、A、B、C、E、F的数据
• 普通A只能查看自己团队（3人）的数据，看不到D、E、F、G、H的数据

示例2：升级后团队统计变化

升级前：
钻石D → 黄金A → 普通B → 普通C

升级后（A升级为钻石，独立成新团队）：
钻石D
钻石A（新团队）→ 普通B → 普通C（B和C跟随A）

升级后的团队统计：

代理	升级前统计	升级后统计	变化说明
钻石A	自己 + B + C（3人）	自己 + B + C（3人）	下级跟随，统计不变
钻石D	自己 + A + B + C（4人）	自己（1人）	A独立后，不再包含A及其下级

关键点：

• A升级后，B和C跟随A到新团队
• D的团队统计不再包含A、B、C（因为A已独立）
• A的团队统计仍然包含B和C（因为下级跟随）

三、业务推广规则

3.1 价格体系

3.1.1 基础底价

• 系统基础底价：BasePrice（系统配置）

3.1.2 等级加成规则

等级加成 = {
  钻石: 0,
  黄金: 3,
  普通: 6
}

3.1.3 实际底价计算

实际底价 = 基础底价 + 等级加成[代理等级]

3.1.4 价格设定范围

• 最低价：实际底价
• 最高价：系统设定上限（SystemMaxPrice）
• 代理设定价格：必须在最低价和最高价之间（包含两端），即：实际底价 ≤ 设定价格 ≤ SystemMaxPrice

3.2 收益分配规则

3.2.1 核心分配原则

重要规则：

• 平台固定收入：无论哪个等级的代理推广，平台固定收到 基础底价（BasePrice）
• 等级加成部分：作为返佣分配给上级链
  • 钻石代理：等级加成 = 0，无返佣分配
  • 黄金代理：等级加成 = 3，全部作为返佣给钻石上级
  • 普通代理：等级加成 = 6，按规则分配给上级链

分配结构：

用户支付金额 = 代理设定价格
├── 代理收益 = 设定价格 - 实际底价 - 提价成本
├── 实际底价 = 基础底价 + 等级加成
    ├── 基础底价 → 平台（固定）
    └── 等级加成 → 上级链返佣（按规则分配）

3.2.2 代理收益计算

提价成本 = 0
if (设定价格 > 提价标准阈值):
  提价成本 = (设定价格 - 提价标准阈值) × 提价手续费比例

代理收益 = 设定价格 - 实际底价 - 提价成本

3.2.3 等级加成返佣分配规则

分配算法：

function distributeLevelBonus(agent):
  // 分配等级加成返佣
  levelBonus = LevelBonus[agent.level]
  
  // 钻石代理：等级加成为0，无返佣分配
  if agent.level == 钻石:
    return { platform: 0 }  // 无返佣，平台也不收这部分（因为加成本身就是0）
  
  // 黄金代理：等级加成3元，全部给钻石上级
  if agent.level == 黄金:
    diamondParent = findDiamondParent(agent)
    if diamondParent存在:
      return { [diamondParent.id]: levelBonus }  // 3元给钻石上级
    // 找不到钻石上级，返佣归平台（异常情况）
    return { platform: levelBonus }
  
  // 普通代理：等级加成6元，按规则分配给上级链
  if agent.level == 普通:
    return distributeNormalAgentBonus(agent, levelBonus)
  
  return { platform: levelBonus }

function distributeNormalAgentBonus(agent, amount):
  // 普通代理的等级加成返佣分配（6元）
  // 核心规则：
  // 1. 根据直接上级等级分配固定金额给直接上级
  // 2. 剩余金额按优先级分配给上级链：钻石优先（全部），黄金次之（最多3元），平台兜底
  
  parent = agent.parent
  if parent不存在:
    return { platform: amount }  // 无上级，全部归平台
  
  // 步骤1：给直接上级分配固定金额
  // 直接上级分配规则：钻石6元，黄金3元，普通2元
  directParentAmount = {
    钻石: 6,
    黄金: 3,
    普通: 2
  }[parent.level]
  
  result = { [parent.id]: directParentAmount }
  remaining = amount - directParentAmount  // 剩余金额
  
  // 步骤2：分配剩余金额（如果直接上级是钻石，则无剩余）
  if remaining > 0:
    // 确定查找起点：直接上级是普通时从直接上级开始查找，否则从直接上级的上级开始查找
    searchStart = parent if parent.level == 普通 else parent.parent
    
    if searchStart存在:
      // 查找上级链中的钻石和黄金
      diamondParent = findDiamondParent(searchStart)
      goldParent = findGoldParent(searchStart)
      
      // 按优先级分配剩余金额
      if diamondParent存在:
        // 优先级1：有钻石，剩余金额全部给钻石
        result[diamondParent.id] = remaining
      else if goldParent存在:
        // 优先级2：只有黄金，最多3元给黄金，剩余归平台
        goldAmount = min(remaining, 3)  // 黄金最多3元
        result[goldParent.id] = goldAmount
        if remaining > goldAmount:
          result.platform = remaining - goldAmount
      else:
        // 优先级3：都没有，剩余金额归平台
        result.platform = remaining
    else:
      // 无法查找上级链，剩余金额归平台
      result.platform = remaining
  
  return result

function findDiamondParent(agent):
  // 向上查找钻石上级
  current = agent.parent
  while current存在:
    if current.level == 钻石:
      return current
    current = current.parent
  return null

function findGoldParent(agent):
  // 向上查找黄金上级
  current = agent.parent
  while current存在:
    if current.level == 黄金:
      return current
    current = current.parent
  return null

3.2.4 分配规则总结表

核心原则：

• 基础底价（BasePrice）：无论哪个等级，全部归平台（固定收入）
• 等级加成部分：作为返佣分配给上级链

代理等级	等级加成	直接上级	等级加成返佣分配规则
钻石	0元	无	无返佣分配（加成为0）
黄金	3元	钻石	3元全部给钻石上级
普通	6元	钻石	6元全部给钻石上级
普通	6元	黄金	3元给黄金上级，3元给钻石上级（上上级）
普通	6元	普通	2元给直接上级普通，剩余4元： - 有钻石：4元全部给钻石 - 只有黄金：3元给黄金，1元归平台 - 都没有：4元归平台

收益分配示例：

• 钻石代理推广：用户支付 = 基础底价，平台收入 = 基础底价，返佣 = 0
• 黄金代理推广：用户支付 = 基础底价 + 3，平台收入 = 基础底价，返佣 = 3元给钻石
• 普通代理推广：用户支付 = 基础底价 + 6，平台收入 = 基础底价，返佣 = 6元按规则分配

四、系统配置参数

4.1 价格相关

• BasePrice: 基础底价
• SystemMaxPrice: 系统价格上限
• PriceThreshold: 提价标准阈值
• PriceFeeRate: 提价手续费比例

4.2 分配相关

• BasePrice: 基础底价（固定归平台）
• LevelBonus: 等级加成配置
  • 钻石: 0元
  • 黄金: 3元（全部给钻石上级）
  • 普通: 6元（按规则分配给上级链）
• DirectParentAmount: 直接上级分配金额配置
  • 普通→钻石: 6元
  • 普通→黄金: 3元
  • 普通→普通: 2元
• MaxGoldAmount: 黄金代理最大分配金额（3元）
• GoldToDiamondAmount: 黄金→钻石分配金额（3元）

4.3 等级加成

• LevelBonus: { 钻石: 0, 黄金: 3, 普通: 6 }

4.4 升级费用和返佣

• UpgradeFee: 升级费用配置
  • NormalToGold: 199元（普通→黄金）
  • NormalToDiamond: 980元（普通→钻石）
  • GoldToDiamond: 980元（黄金→钻石）
• UpgradeRebate: 升级返佣配置
  • NormalToGoldRebate: 139元（普通→黄金，给直接上级）
  • ToDiamondRebate: 680元（升级为钻石，给直接上级）
• UpgradeRebateRate: 升级返佣比例
  • NormalToGoldRate: 69.8%（139/199）
  • ToDiamondRate: 69.4%（680/980）

五、核心算法伪代码

6.1 计算实际底价

function calculateActualBasePrice(agentLevel, basePrice):
  levelBonus = LevelBonus[agentLevel]
  return basePrice + levelBonus

6.2 计算代理收益

function calculateAgentProfit(setPrice, actualBasePrice, priceThreshold, feeRate):
  priceCost = 0
  if setPrice > priceThreshold:
    priceCost = (setPrice - priceThreshold) × feeRate
  return setPrice - actualBasePrice - priceCost

6.3 收益分配主流程

function distributeRevenue(agent, setPrice, basePrice):
  // 1. 计算实际底价
  levelBonus = LevelBonus[agent.level]
  actualBasePrice = basePrice + levelBonus
  
  // 2. 计算代理收益
  priceCost = calculatePriceCost(setPrice)
  agentProfit = setPrice - actualBasePrice - priceCost
  
  // 3. 基础底价部分：全部归平台（固定）
  platformRevenue = basePrice
  
  // 4. 等级加成部分：按规则分配给上级链
  levelBonusDistribution = distributeLevelBonus(agent)
  
  // 5. 汇总分配结果
  return {
    agentProfit: agentProfit,
    platformRevenue: platformRevenue,
    levelBonusDistribution: levelBonusDistribution
  }

6.4 等级加成返佣分配流程

function distributeLevelBonus(agent):
  levelBonus = LevelBonus[agent.level]
  
  if agent.level == 钻石:
    return {}  // 无返佣（加成为0）
  
  if agent.level == 黄金:
    diamondParent = findDiamondParent(agent)
    return { [diamondParent.id]: levelBonus }  // 3元给钻石
  
  if agent.level == 普通:
    return distributeNormalAgentBonus(agent, levelBonus)  // 6元按规则分配

6.5 代理升级流程

function upgradeAgent(agent, targetLevel, upgradeType):
  // 参数说明：
  // agent: 被升级的代理
  // targetLevel: 目标等级（2=黄金, 3=钻石）
  // upgradeType: 'self_paid'（自主付费）or 'diamond_upgrade'（钻石升级）
  
  // 1. 验证升级条件
  if not canUpgrade(agent, targetLevel, upgradeType):
    return { error: '升级条件不满足' }
  
  // 2. 如果是自主付费升级，处理付费
  if upgradeType == 'self_paid':
    upgradeFee = getUpgradeFee(agent.level, targetLevel)
    rebateAmount = getUpgradeRebate(agent.level, targetLevel)
    originalParent = agent.parent
    
    // 2.1 代理付费
    paymentResult = processPayment(agent, upgradeFee)
    if not paymentResult.success:
      return { error: '付费失败' }
    
    // 2.2 返佣给原直接上级（即使升级后脱离关系）
    if originalParent:
      rebateResult = processRebate(originalParent, rebateAmount)
      if not rebateResult.success:
        // 如果返佣失败，需要退款
        refundPayment(agent, upgradeFee)
        return { error: '返佣失败，已退款' }
  
  // 3. 执行升级操作
  agent.level = targetLevel
  
  // 4. 检查是否需要脱离直接上级关系
  if needDetachFromParent(agent, agent.parent):
    agent.parent = null  // 脱离直接关系
    // 但保留团队关系（通过钻石首领）
  
  // 5. 如果升级为钻石，独立成新团队
  if targetLevel == 钻石:
    agent.teamLeaderId = agent.id  // 成为新团队首领
    // 下级会跟随（已在升级规则中定义）
  
  return { success: true, agent: agent }

function canUpgrade(agent, targetLevel, upgradeType):
  // 检查升级条件
  if upgradeType == 'diamond_upgrade':
    // 钻石升级下级：必须是钻石操作，且下级是普通代理
    return agent.level == 普通 and targetLevel == 黄金
  else if upgradeType == 'self_paid':
    // 自主付费：普通可以升级为黄金或钻石，黄金可以升级为钻石
    if agent.level == 普通:
      return targetLevel == 黄金 or targetLevel == 钻石
    else if agent.level == 黄金:
      return targetLevel == 钻石
  return false

function getUpgradeFee(fromLevel, toLevel):
  if fromLevel == 普通 and toLevel == 黄金:
    return 199
  else if toLevel == 钻石:
    return 980
  return 0

function getUpgradeRebate(fromLevel, toLevel):
  if fromLevel == 普通 and toLevel == 黄金:
    return 139
  else if toLevel == 钻石:
    return 680
  return 0

function needDetachFromParent(agent, parent):
  // 检查是否需要脱离直接上级关系
  // 规则1：下级不能比上级等级高
  // 规则2：同级不能作为上下级（除了普通代理）
  if not parent:
    return false
  
  // 如果代理等级高于上级等级，必须脱离
  if agent.level > parent.level:
    return true
  
  // 同级不能作为上下级（除了普通代理）
  if agent.level == parent.level:
    if agent.level == 黄金 or agent.level == 钻石:
      return true  // 黄金 → 黄金、钻石 → 钻石禁止
  
  // 钻石 → 黄金禁止（虽然钻石等级高于黄金，但这是特殊禁止规则）
  if agent.level == 黄金 and parent.level == 钻石:
    return true
  
  return false

六、业务流程图

7.1 代理升级流程

7.1.1 自主付费升级流程

代理发起升级请求
  ↓
检查升级条件（等级、权限等）
  ↓
计算升级费用和返佣金额
  ↓
代理支付升级费用
  ↓
付费成功后，立即返佣给原直接上级
  ↓
执行升级操作（更新代理等级）
  ↓
检查是否需要脱离直接上级关系
  ↓
如果升级为钻石
  → 独立成新团队
  → 成为团队首领
  → 下级跟随到新团队
  ↓
完成升级

7.1.2 钻石升级下级流程

钻石代理操作升级下级
  ↓
检查升级条件（必须是普通代理升级为黄金）
  ↓
无需付费，直接执行升级操作
  ↓
检查是否需要脱离直接上级关系
  ↓
完成升级

7.1.3 升级费用和返佣流程

升级费用表：
- 普通→黄金：199元，返佣139元给直接上级
- 普通→钻石：980元，返佣680元给直接上级
- 黄金→钻石：980元，返佣680元给直接上级

返佣规则：
- 返佣对象：原直接上级（即使升级后脱离关系）
- 返佣时机：付费成功后立即返佣
- 返佣金额：固定金额，不随升级后关系变化而改变

7.2 业务推广收益分配流程

用户付费查询（支付代理设定价格）
  ↓
计算实际底价 = 基础底价 + 等级加成
  ↓
计算代理收益 = 设定价格 - 实际底价 - 提价成本
  ↓
收益分配：
  ├── 基础底价部分 → 平台（固定收入）
  └── 等级加成部分 → 按规则分配给上级链
      ├── 钻石代理：加成=0，无返佣
      ├── 黄金代理：加成=3，全部给钻石上级
      └── 普通代理：加成=6，按规则分配给上级链

七、边界情况处理

1. 钻石代理有上级：理论上不应存在，但系统需处理异常情况
2. 团队链断裂：如果上级链中找不到钻石代理，剩余金额归平台
3. 价格异常：设定价格低于实际底价时，拒绝交易
4. 升级冲突：升级时检查是否违反直接上下级约束规则
5. 升级关系判断：
   • 普通 → 黄金升级时，必须脱离直接上级关系
   • 原因：黄金等级高于普通（下级不能比上级等级高），或与黄金同级（同级不能作为上下级），或钻石→黄金禁止
   • 普通/黄金 → 钻石升级时，独立成新团队，脱离所有上级关系
6. 返佣处理：返佣给原直接上级，即使升级后脱离关系，返佣不受影响
7. 团队统计更新：所有关系变更后，需要正确更新团队统计范围