976 lines
33 KiB
Markdown
976 lines
33 KiB
Markdown
# 代理系统重构方案
|
||
|
||
## 文档概述
|
||
|
||
本文档定义了代理系统的核心规则和实现逻辑，包括：
|
||
- **代理等级体系**：普通、黄金、钻石三个等级
|
||
- **团队结构规则**：上下级关系约束、升级规则、团队统计
|
||
- **业务推广规则**：价格体系、收益分配规则
|
||
- **升级机制**：升级方式、费用规则、返佣规则
|
||
- **核心算法**：团队统计、收益分配、升级流程等业务逻辑伪代码
|
||
|
||
## 一、代理等级体系
|
||
|
||
### 1.1 等级定义
|
||
- **普通代理**（Level 1）：初始等级
|
||
- **黄金代理**（Level 2）：中级等级
|
||
- **钻石代理**（Level 3）：最高等级，团队首领
|
||
|
||
### 1.2 等级数值映射
|
||
```javascript
|
||
代理等级 = {
|
||
普通: 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<br>黄金A → 下级B → 下级C | B和C跟随A |
|
||
| 黄金→钻石 | 上级 → 黄金A → 下级B → 下级C | 上级<br>钻石A（新团队）→ 下级B → 下级C | B和C跟随A到新团队 |
|
||
| 普通→钻石 | 上级 → 普通A → 下级B → 下级C | 上级 → 普通A<br>钻石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 等级加成规则
|
||
```javascript
|
||
等级加成 = {
|
||
钻石: 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元：<br>- 有钻石：4元全部给钻石<br>- 只有黄金：3元给黄金，1元归平台<br>- 都没有：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. **团队统计更新**：所有关系变更后，需要正确更新团队统计范围
|