fnvtk/CKB-Interface
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: fnvtk:develop
Branches Tags
fnvtk:master fnvtk:develop fnvtk:feature/new_store
fnvtk:v1.1.3
...
pull from: fnvtk:feature/new_store
Branches Tags
fnvtk:develop fnvtk:feature/new_store fnvtk:master
fnvtk:v1.1.3

1 Commits
develop ... feature/ne

Author SHA1 Message Date
wong
7fb61b77a4 新版数智员工 2026-03-24 10:39:16 +08:00
123 changed files with 38491 additions and 1018 deletions
Expand all files Collapse all files

14
Server.code-workspace Normal file
View File

@@ -0,0 +1,14 @@
{
"folders": [
{
"path": "."
},
{
"path": "../Cunkebao"
},
{
"path": "Z:/SynologyDrive/存客宝AI"
}
],
"settings": {}
}

340
TAG_ENGINE_API.md Normal file
View File

@@ -0,0 +1,340 @@
# 客户标签功能 API 文档
## 功能概述
已完成对接外部标签引擎系统，提供两个核心功能：
1. 通过标识（手机号、微信号、身份证、QQ号）查询用户标签
2. 通过标签条件查询用户列表
## 配置信息
- **外部API地址**: `http://192.168.1.134:3000`
- **API Key**: `69aebe46b03d334f1796ef88808d3042d5851d0fd91d728bcba6ad6be436acf6`
- **服务类**: `app\common\service\TagEngineService`
## 接口列表
### 1. 通过标识查询标签
#### 1.1 通用接口
**接口地址**: `POST /v1/tag/query-by-identifiers`
**请求头**:
```
Authorization: Bearer {JWT_TOKEN}
Content-Type: application/json
```
**请求参数**:
```json
{
"identifiers": [
{
"type": "phone",
"value": "13800138000"
},
{
"type": "wechat",
"value": "wx_test_001"
}
],
"options": {
"include_tags": ["user.trade.total_amount", "user.profile.gender"],
"mask_identifier": true
}
}
```
**参数说明**:
- `identifiers`: 标识列表（必填，最多100个）
- `type`: 标识类型，支持 `phone`、`wechat`、`id_card`、`qq`
- `value`: 标识值
- `options`: 查询选项（可选）
- `include_tags`: 包含指定标签代码列表
- `exclude_tags`: 排除指定标签代码列表
- `tag_category`: 按分类筛选标签
- `mask_identifier`: 是否脱敏，默认 true
**响应示例**:
```json
{
"code": 200,
"msg": "查询成功",
"data": [
{
"identifier": {
"type": "phone",
"value": "138****8000"
},
"user_id": "user_12345",
"found": true,
"tag_count": 15,
"tags": [
{
"tag_code": "user.trade.total_amount",
"tag_name": "累计消费金额",
"tag_value": "15680.50",
"tag_type": "numeric",
"category": "交易标签",
"updated_at": "2026-01-27 10:30:00"
}
]
}
]
}
```
#### 1.2 快捷接口 - 通过手机号查询
**接口地址**: `POST /v1/tag/query-by-phone`
**请求参数**:
```json
{
"phones": ["13800138000", "13900139000"],
"options": {
"mask_identifier": true
}
}
```
或使用逗号分隔的字符串：
```json
{
"phones": "13800138000,13900139000"
}
```
#### 1.3 快捷接口 - 通过微信号查询
**接口地址**: `POST /v1/tag/query-by-wechat`
**请求参数**:
```json
{
"wechats": ["wx_test_001", "wx_test_002"],
"options": {
"mask_identifier": true
}
}
```
---
### 2. 通过标签查询用户
#### 2.1 通用接口
**接口地址**: `POST /v1/tag/query-users-by-tags`
**请求头**:
```
Authorization: Bearer {JWT_TOKEN}
Content-Type: application/json
```
**请求参数**:
```json
{
"tag_conditions": [
{
"tag_code": "user.trade.total_amount",
"operator": ">=",
"value": "5000"
},
{
"tag_code": "user.profile.gender",
"operator": "=",
"value": "男"
}
],
"logic": "AND",
"include_sensitive": false,
"page": 1,
"page_size": 20
}
```
**参数说明**:
- `tag_conditions`: 标签条件列表（必填，最多10个）
- `tag_code`: 标签代码
- `operator`: 操作符，支持 `=`、`!=`、`>`、`>=`、`<`、`<=`、`in`、`not_in`
- `value`: 标签值（使用 `in`/`not_in` 时为数组）
- `logic`: 逻辑关系，`AND` 或 `OR`，默认 `AND`
- `include_sensitive`: 是否返回敏感信息（QQ号、身份证），默认 `false`
- `page`: 页码，默认 1
- `page_size`: 每页数量，默认 20，最大 100
**响应示例**:
```json
{
"code": 200,
"msg": "查询成功",
"data": {
"list": [
{
"user_id": "user_12345",
"name": "张**",
"phone": "138****8000",
"wechat": "wx_****_001",
"qq": null,
"id_card": null,
"matched_tags": [
{
"tag_code": "user.trade.total_amount",
"tag_name": "累计消费金额",
"tag_value": "15680.50"
}
]
}
],
"pagination": {
"page": 1,
"page_size": 20,
"total": 156,
"total_pages": 8
}
}
}
```
#### 2.2 快捷接口 - 查询高价值用户
**接口地址**: `GET /v1/tag/high-value-users`
**请求参数**:
- `page`: 页码，默认 1
- `page_size`: 每页数量，默认 20
- `min_amount`: 最低消费金额，默认 5000
**示例**: `/v1/tag/high-value-users?page=1&page_size=20&min_amount=10000`
#### 2.3 快捷接口 - 查询VIP用户
**接口地址**: `GET /v1/tag/vip-users`
**请求参数**:
- `page`: 页码，默认 1
- `page_size`: 每页数量，默认 20
- `levels`: 用户等级列表，默认 `['VIP', 'SVIP', '金卡会员']`
**示例**: `/v1/tag/vip-users?page=1&page_size=20&levels=VIP,SVIP`
---
## 内部调用示例
### PHP 代码示例
```php
<?php
use app\common\service\TagEngineService;
// 创建服务实例
$service = new TagEngineService();
// 示例1：通过手机号查询标签
$result = $service->queryByPhone('13800138000');
if ($result && isset($result['data'])) {
// 处理结果
foreach ($result['data'] as $item) {
echo "用户ID: " . $item['user_id'] . "\n";
echo "标签数量: " . $item['tag_count'] . "\n";
}
}
// 示例2：通过微信号查询标签
$result = $service->queryByWechat(['wx_test_001', 'wx_test_002']);
// 示例3：通过标签查询用户
$tagConditions = [
[
'tag_code' => 'user.trade.total_amount',
'operator' => '>=',
'value' => '5000'
]
];
$result = $service->queryUsersByTags($tagConditions, 'AND', false, 1, 20);
// 示例4：自定义API配置
$service->setBaseUrl('http://192.168.1.134:3000')
->setApiKey('your_custom_api_key');
```
---
## 错误码说明
| 错误码 | 说明 | 处理建议 |
|--------|------|---------|
| 400 | 请求参数错误 | 检查请求参数格式和内容 |
| 401 | 未授权访问 | 检查 JWT Token 是否有效 |
| 403 | 无权限访问 | 检查 API Key 权限配置 |
| 429 | 请求过于频繁 | 降低请求频率，稍后重试 |
| 500 | 服务器内部错误 | 联系技术支持 |
---
## 注意事项
1. **批量限制**:
- 通过标识查询：单次最多 100 个标识
- 通过标签查询：单次最多 10 个标签条件
- 查询结果：单页最多 100 条记录
2. **数据脱敏**:
- 默认对敏感信息进行脱敏
- 手机号：138****8000
- 身份证：110101********1234
- 微信号：wx_****_001
3. **标识类型**:
- `phone`: 手机号（11位数字）
- `id_card`: 身份证号（18位）
- `wechat`: 微信号
- `qq`: QQ号
4. **操作符说明**:
- `=`: 等于
- `!=`: 不等于
- `>`: 大于
- `>=`: 大于等于
- `<`: 小于
- `<=`: 小于等于
- `in`: 在列表中（value 必须是数组）
- `not_in`: 不在列表中（value 必须是数组）
5. **权限要求**:
- 所有接口都需要 JWT 认证
- 查询敏感信息需要额外权限（`tag:query:sensitive`）
---
## 文件结构
```
application/
├── common/
│ └── service/
│ └── TagEngineService.php # 标签引擎服务类
└── cunkebao/
├── config/
│ └── route.php # 路由配置
└── controller/
└── tag/
├── QueryTagsByIdentifiersController.php # 通过标识查询标签控制器
└── QueryUsersByTagsController.php # 通过标签查询用户控制器
```
---
## 更新日志
### v1.0.0 (2026-01-30)
- 初始版本发布
- 实现标签引擎服务类
- 实现两个核心控制器
- 配置路由和JWT认证
- 提供快捷查询方法

111
application/command/GenerateUserApiKeyCommand.php Normal file
View File

@@ -0,0 +1,111 @@
<?php
namespace app\command;
use think\console\Command;
use think\console\Input;
use think\console\Output;
use think\console\input\Option;
use think\Db;
use app\common\service\UserApiKeyService;
/**
* 批量为 ck_users 表中还没有 apiKey 的用户生成专属 Key
*
* 用法：
* php think user:generate-api-key # 只处理没有 apiKey 的用户
* php think user:generate-api-key --force # 强制覆盖所有用户的 apiKey（危险！）
* php think user:generate-api-key --dry-run # 预览模式，不写库
*/
class GenerateUserApiKeyCommand extends Command
{
protected function configure()
{
$this->setName('user:generate-api-key')
->setDescription('批量为 ck_users 用户生成对外 API Key')
->addOption('force', 'f', Option::VALUE_NONE, '强制覆盖所有用户（包括已有 apiKey 的用户），危险！')
->addOption('dry-run', null, Option::VALUE_NONE, '预览模式，不实际写入数据库');
}
protected function execute(Input $input, Output $output)
{
$force = (bool)$input->getOption('force');
$dryRun = (bool)$input->getOption('dry-run');
$output->writeln('<info>========================================</info>');
$output->writeln('<info> 批量生成用户 API Key</info>');
$output->writeln('<info>========================================</info>');
if ($dryRun) {
$output->writeln('<comment>[预览模式] 不会实际写入数据库</comment>');
}
if ($force) {
$output->writeln('<comment>[FORCE] 将覆盖已有 apiKey 的用户</comment>');
}
$output->writeln('');
// 查询目标用户
$query = Db::name('users')
->where('deleteTime', 0)
->field('id, account, phone, apiKey');
if (!$force) {
// 默认只处理 apiKey 为空或 NULL 的记录
$query->where(function ($q) {
$q->where('apiKey', null)
->whereOr('apiKey', '');
});
}
$users = $query->select();
$total = count($users);
$success = 0;
$skip = 0;
$output->writeln("共找到 <info>{$total}</info> 个需要处理的用户");
$output->writeln('');
if ($total === 0) {
$output->writeln('<info>所有用户均已有 API Key，无需处理。</info>');
return true;
}
foreach ($users as $user) {
$uid = (int)$user['id'];
$label = "用户 #{$uid} ({$user['account']}/{$user['phone']})";
try {
if ($dryRun) {
$output->writeln("<comment>[预览] 将为 {$label} 生成 apiKey</comment>");
$success++;
continue;
}
if ($force) {
$apiKey = UserApiKeyService::forceGenerate($uid);
} else {
$apiKey = UserApiKeyService::bindOrGet($uid);
}
$output->writeln("<info>√ {$label} => {$apiKey}</info>");
$success++;
} catch (\Exception $e) {
$output->writeln("<error>✗ {$label} 失败：{$e->getMessage()}</error>");
$skip++;
}
}
$output->writeln('');
$output->writeln('<info>========================================</info>');
$output->writeln("<info> 完成：成功 {$success} 个，跳过/失败 {$skip} 个</info>");
$output->writeln('<info>========================================</info>');
if ($dryRun) {
$output->writeln('<comment>预览模式：未实际写入任何数据</comment>');
}
return true;
}
}

114
application/common/controller/OpenAuthController.php Normal file
View File

@@ -0,0 +1,114 @@
<?php
namespace app\common\controller;
use think\Controller;
use think\facade\Log;
use app\common\service\UserApiKeyService;
use app\common\util\JwtUtil;
/**
* 对外开放接口 — 鉴权控制器
*
* 第三方系统先用 apiKey + sign 换取 JWT Token，
* 后续所有 /v1/open/* 业务接口只需在 Header 中携带：
* Authorization: Bearer <token>
* 即可调用，与存客宝内部接口完全兼容。
*/
class OpenAuthController extends Controller
{
/**
* 获取 JWT Token
* POST /v1/open/auth/token
*
* 请求参数：
* apiKey - 账号专属 API Key（ck_users.apiKey）
* account - 登录账号（ck_users.account），参与签名
* timestamp - 秒级时间戳
* sign - 签名值，算法见签名文档
*
* 成功响应：
* { code: 200, message: "success", data: { token: "xxx", expires_in: 7200 } }
*/
public function getToken()
{
try {
$params = $this->request->param();
// ── 1. 必填参数校验 ─────────────────────────────────────────
if (empty($params['apiKey'])) {
return $this->fail('apiKey不能为空', 400);
}
if (empty($params['account'])) {
return $this->fail('account不能为空', 400);
}
if (empty($params['sign'])) {
return $this->fail('sign不能为空', 400);
}
if (empty($params['timestamp'])) {
return $this->fail('timestamp不能为空', 400);
}
// ── 2. 时间戳时效校验（±5 分钟）──────────────────────────────
if (abs(time() - intval($params['timestamp'])) > 300) {
return $this->fail('请求已过期', 400);
}
// ── 3. 用 apiKey 找账号，并校验 account 一致性 ───────────────
$user = UserApiKeyService::findUserByKey($params['apiKey']);
if (!$user) {
return $this->fail('无效的apiKey', 401);
}
if ($user['account'] !== $params['account']) {
return $this->fail('无效的apiKey', 401);
}
// ── 4. 验签（account + timestamp + apiKey）────────────────────
if (!UserApiKeyService::validateSign(
$params['account'],
(string)$params['timestamp'],
$params['apiKey'],
$params['sign']
)) {
return $this->fail('签名验证失败', 401);
}
// ── 5. 签发 JWT（2 小时有效期）────────────────────────────────
$expireSeconds = 7200;
$token = JwtUtil::createToken([
'id' => (int)$user['id'],
'account' => $user['account'] ?? '',
'username' => $user['username'] ?? '',
'phone' => $user['phone'] ?? '',
'companyId' => (int)$user['companyId'],
'typeId' => (int)$user['typeId'],
'isAdmin' => (int)($user['isAdmin'] ?? 0),
'via' => 'open_api', // 标记来源，方便日志区分
], $expireSeconds);
Log::info('[OpenAuth] 对外接口登录成功', [
'userId' => $user['id'],
'account' => $user['account'],
'ip' => $this->request->ip(),
]);
return json([
'code' => 200,
'message' => 'success',
'data' => [
'token' => $token,
'expires_in' => $expireSeconds,
],
]);
} catch (\Exception $e) {
Log::error('[OpenAuth] getToken 异常：' . $e->getMessage());
return $this->fail('系统错误: ' . $e->getMessage(), 500);
}
}
private function fail(string $message, int $code = 400)
{
return json(['code' => $code, 'message' => $message, 'data' => null]);
}
}

234
application/common/controller/OpenScenariosController.php Normal file
View File

@@ -0,0 +1,234 @@
<?php
namespace app\common\controller;
use think\Controller;
use think\Db;
use think\facade\Log;
use app\common\model\TrafficPoolSource;
use app\cunkebao\service\TrafficPoolService;
use app\cunkebao\service\DistributionRewardService;
/**
* 对外开放接口 — 场景获客线索上报
*
* 鉴权：Bearer JWT（通过 POST /v1/open/auth/token 获取）
* 路由：POST /v1/open/scenarios（挂 jwt 中间件）
*
* 第三方调用流程：
* 1. POST /v1/open/auth/token → 获得 JWT Token
* 2. POST /v1/open/scenarios → Header: Authorization: Bearer <token>
*/
class OpenScenariosController extends Controller
{
/**
* 线索上报入口
* POST /v1/open/scenarios
*/
public function submit()
{
try {
// ── 1. 从 JWT 中取当前用户（由 jwt 中间件注入）─────────────────
$userInfo = $this->request->userInfo ?? [];
$companyId = (int)($userInfo['companyId'] ?? 0);
if (empty($userInfo['id']) || empty($companyId)) {
return $this->error('未授权访问', 401);
}
$params = $this->request->param();
// ── 2. planId 校验（必须属于当前账号的 companyId，且已启用）──
if (empty($params['planId'])) {
return $this->error('planId不能为空', 400);
}
$plan = Db::name('customer_acquisition_task')
->where('id', intval($params['planId']))
->where('companyId', $companyId)
->where('status', 1)
->find();
if (!$plan) {
return $this->error('计划不存在或已停用', 404);
}
// ── 3. 主标识（wechatId 优先，phone 次之）─────────────────────
$wechatId = trim($params['wechatId'] ?? '');
$phone = trim($params['phone'] ?? '');
$identifier = $wechatId ?: $phone;
if (empty($identifier)) {
return $this->error('wechatId 和 phone 至少传一个', 400);
}
// ── 4. 渠道 ID（可选，分销场景）──────────────────────────────
$channelId = !empty($params['cid']) ? intval($params['cid']) : 0;
$finalChannelId = $this->resolveChannelId($channelId, $plan);
// ── 5. 查重 & 写入 task_customer ──────────────────────────────
$taskCustomer = Db::name('task_customer')
->where('task_id', $plan['id'])
->where('phone', $identifier)
->find();
if ($taskCustomer) {
// 已存在：仅追加站内标签
if (!empty($params['siteTags'])) {
$this->mergeSiteTags(
$taskCustomer['id'],
explode(',', $params['siteTags'])
);
}
return $this->success($identifier, '已存在');
}
// 新线索
$tags = !empty($params['tags']) ? explode(',', $params['tags']) : [];
$siteTags = !empty($params['siteTags']) ? explode(',', $params['siteTags']) : [];
$customerId = Db::name('task_customer')->insertGetId([
'task_id' => $plan['id'],
'channelId' => $finalChannelId,
'phone' => $identifier,
'name' => $params['name'] ?? '',
'source' => $params['source'] ?? '',
'remark' => $params['remark'] ?? '',
'tags' => json_encode($tags, JSON_UNESCAPED_UNICODE),
'siteTags' => json_encode($siteTags, JSON_UNESCAPED_UNICODE),
'createTime' => time(),
]);
// ── 6. 同步到 V2 流量池（异步，不影响主流程）─────────────────
if ($customerId) {
$this->syncToTrafficPool(
$identifier, $phone, $wechatId,
$companyId, $plan, $params,
$finalChannelId, $customerId
);
}
// ── 7. 分销获客奖励（异步，不影响主流程）────────────────────
if ($customerId && $finalChannelId > 0) {
try {
DistributionRewardService::recordCustomerReward(
$plan['id'], $customerId, $identifier, $finalChannelId
);
} catch (\Exception $e) {
Log::error('[OpenScenarios] 记录获客奖励失败：' . $e->getMessage());
}
}
return $this->success($identifier, '新增成功');
} catch (\Exception $e) {
Log::error('[OpenScenarios] 系统错误：' . $e->getMessage() . "\n" . $e->getTraceAsString());
return $this->error('系统错误: ' . $e->getMessage(), 500);
}
}
// ─────────────────────────────────────────────────────────────────────────
private function resolveChannelId(int $channelId, array $plan): int
{
if ($channelId <= 0) {
return 0;
}
$sceneConf = json_decode($plan['sceneConf'] ?? '{}', true) ?: [];
$distConfig = $sceneConf['distribution'] ?? [];
$allowedIds = $distConfig['channels'] ?? [];
if (empty($distConfig['enabled']) || !in_array($channelId, $allowedIds)) {
return 0;
}
$channel = Db::name('distribution_channel')
->where([
['id', '=', $channelId],
['companyId', '=', $plan['companyId']],
['status', '=', 'enabled'],
['deleteTime', '=', 0],
])
->find();
return $channel ? $channelId : 0;
}
private function mergeSiteTags(int $taskCustomerId, array $newTags): void
{
try {
$row = Db::name('task_customer')->where('id', $taskCustomerId)->find();
if (!$row) {
return;
}
$existing = !empty($row['siteTags']) ? (json_decode($row['siteTags'], true) ?: []) : [];
$merged = array_values(array_unique(array_filter(
array_merge($existing, $newTags),
fn($t) => trim($t) !== ''
)));
Db::name('task_customer')->where('id', $taskCustomerId)->update([
'siteTags' => json_encode($merged, JSON_UNESCAPED_UNICODE),
'updateTime' => time(),
]);
} catch (\Exception $e) {
Log::error('[OpenScenarios] 合并站内标签失败：' . $e->getMessage());
}
}
private function syncToTrafficPool(
string $identifier,
string $phone,
string $wechatId,
int $companyId,
array $plan,
array $params,
int $finalChannelId,
int $customerId
): void {
try {
$isPhone = (bool)preg_match('/^\+?\d{6,}$/', $identifier);
$poolService = new TrafficPoolService();
$poolService->enterPool(
$identifier,
$companyId,
TrafficPoolSource::SOURCE_TYPE_API,
[
'identifierType' => $isPhone ? 2 : 1,
'mobile' => $phone ?: ($isPhone ? $identifier : ''),
'wechatId' => $wechatId ?: (!$isPhone ? $identifier : ''),
'nickname' => $params['name'] ?? '',
],
[
'phone' => $phone ?: ($isPhone ? $identifier : ''),
'realName' => $params['name'] ?? '',
'remark' => $params['remark'] ?? '',
],
[
'sourceName' => !empty($params['source'])
? $params['source']
: ('场景获客_' . $plan['name']),
'remark' => $params['remark'] ?? '',
'extra' => json_encode([
'planId' => $plan['id'],
'planName' => $plan['name'],
'channelId' => $finalChannelId,
'customerId' => $customerId,
'via' => 'open_api',
], JSON_UNESCAPED_UNICODE),
]
);
} catch (\Exception $e) {
Log::error('[OpenScenarios] 同步 V2 流量池失败：' . $e->getMessage());
}
}
private function success(string $data, string $message = 'success')
{
return json(['code' => 200, 'message' => $message, 'data' => $data]);
}
private function error(string $message, int $code = 400)
{
return json(['code' => $code, 'message' => $message, 'data' => null]);
}
}

153
application/common/service/UserApiKeyService.php Normal file
View File

@@ -0,0 +1,153 @@
<?php
namespace app\common\service;
use think\Db;
use think\facade\Log;
/**
* 用户 API Key 服务
*
* Key 格式与"场景获客"保持一致：
* 5 组 × 5 位（大小写字母 + 数字），组间用 "-" 连接
* 示例：aB3k9-Z8c1Q-0f4Xk-M9n2P-1A2b3
*
* 绑定对象：ck_users 表（`users`）中的 `apiKey` 字段
*/
class UserApiKeyService
{
/** 字符集：大小写字母 + 数字 */
private static $chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
/**
* 生成一个在 ck_users 中唯一的 API Key
*
* @return string 格式：xxxxx-xxxxx-xxxxx-xxxxx-xxxxx
*/
public static function generate(): string
{
$chars = self::$chars;
$charLen = strlen($chars);
while (true) {
$key = '';
for ($i = 0; $i < 5; $i++) {
$segment = '';
for ($j = 0; $j < 5; $j++) {
$segment .= $chars[mt_rand(0, $charLen - 1)];
}
$key .= ($i > 0 ? '-' : '') . $segment;
}
// 确保全局唯一
$exists = Db::name('users')->where('apiKey', $key)->find();
if (!$exists) {
return $key;
}
}
}
/**
* 为指定用户绑定 API Key（幂等：已有则直接返回，没有则生成并写入）
*
* @param int $userId ck_users.id
* @return string 该用户的 apiKey
* @throws \RuntimeException
*/
public static function bindOrGet(int $userId): string
{
$user = Db::name('users')
->where('id', $userId)
->where('deleteTime', 0)
->field('id, apiKey')
->find();
if (!$user) {
throw new \RuntimeException('用户不存在');
}
if (!empty($user['apiKey'])) {
return $user['apiKey'];
}
return self::forceGenerate($userId);
}
/**
* 强制为指定用户重新生成 API Key（会覆盖旧 Key）
*
* @param int $userId ck_users.id
* @return string 新生成的 apiKey
* @throws \RuntimeException
*/
public static function forceGenerate(int $userId): string
{
$user = Db::name('users')
->where('id', $userId)
->where('deleteTime', 0)
->field('id')
->find();
if (!$user) {
throw new \RuntimeException('用户不存在');
}
$apiKey = self::generate();
Db::name('users')
->where('id', $userId)
->update([
'apiKey' => $apiKey,
'updateTime' => time(),
]);
Log::info("UserApiKeyService: 用户 #{$userId} 生成/更新 apiKey");
return $apiKey;
}
/**
* 通过 apiKey 查找用户（用于对外接口身份校验）
*
* @param string $apiKey
* @return array|null ck_users 行，或 null（key 无效/用户已删除/已禁用）
*/
public static function findUserByKey(string $apiKey): ?array
{
if (empty($apiKey)) {
return null;
}
$user = Db::name('users')
->where('apiKey', $apiKey)
->where('deleteTime', 0)
->where('status', 1)
->find();
return $user ?: null;
}
/**
* 验证签名
*
* 只有三个固定字段参与签名：account、timestamp、apiKey
* stringToSign = account + timestamp （按字段名 ASCII 升序拼接值）
* firstMd5 = MD5(stringToSign)
* sign = MD5(firstMd5 + apiKey)
*
* @param string $account 请求中传入的 account（ck_users.account）
* @param string $timestamp 请求中传入的 timestamp
* @param string $apiKey 用户 apiKey
* @param string $sign 客户端传来的签名
* @return bool
*/
public static function validateSign(string $account, string $timestamp, string $apiKey, string $sign): bool
{
// account < timestamp（ASCII 升序）
$stringToSign = $account . $timestamp;
$firstMd5 = md5($stringToSign);
$expectedSign = md5($firstMd5 . $apiKey);
return hash_equals($expectedSign, $sign);
}
}

72
application/store/AGENT_APIFOX_SUCCESS.md Normal file
View File

@@ -0,0 +1,72 @@
# Agent模块接口上传成功 ✅
## 上传信息
- **上传时间**: 2026-02-05
- **项目ID**: 6037107
- **当前目录**: 门店端-新版 (ID: 78015216)
## 已上传接口
### 1. 获取Agent模块列表
- **API ID**: 415861964
- **方法**: GET
- **路径**: `/v2/store/agent/modules`
- **功能**: 获取所有可用的Agent功能模块及其状态
- **模块列表**:
- autoLike: 自动点赞
- momentsSync: 朋友圈同步
- autoCustomerDev: 自动开发客户
- groupMessageDeliver: 群消息群发
- autoGroup: 自动建群
### 2. 更新Agent模块状态
- **API ID**: 415861967
- **方法**: PUT
- **路径**: `/v2/store/agent/modules/{moduleCode}/status`
- **功能**: 启用或禁用指定的Agent功能模块
- **请求参数**:
- status: 状态（0-禁用，1-启用）
- deviceId: 设备ID
- **数据存储**: 使用 ck_device_taskconf 表
## 后续步骤
### 方式一：手动整理（推荐）
1. 打开 Apifox: https://app.apifox.com/project/6037107
2. 在左侧找到"门店端-新版"目录
3. 右键 → 新建目录 → 输入"Agent管理"
4. 将上面2个接口拖拽到"Agent管理"目录下
### 方式二：使用脚本移动
1. 在Apifox中手动创建"Agent管理"目录（在"门店端-新版"下）
2. 记下新目录的ID（假设为 FOLDER_ID）
3. 运行以下命令：
```bash
python apifox_manager.py move 415861964 FOLDER_ID
python apifox_manager.py move 415861967 FOLDER_ID
```
## 接口分类规则（已更新到知识库）
1. **认证模块** → "登录相关" (ID: 78092117)
- 账号密码登录
- 免密登录
- 发送验证码
- 手机验证码登录
2. **Agent模块** → "Agent管理" (待创建后移动)
- 获取Agent模块列表
- 更新Agent模块状态
3. **消息管理** → "消息管理" (需要时创建)
4. **用户管理** → "用户管理" (待开发)
5. **设备管理** → "设备管理" (待开发)
6. **数据统计** → "数据统计" (待开发)
## 访问链接
- Apifox项目: https://app.apifox.com/project/6037107
- 门店端-新版目录: https://app.apifox.com/project/6037107/apis/folder/78015216

97
application/store/AGENT_整理完成.md Normal file
View File

@@ -0,0 +1,97 @@
# Agent接口整理完成 ✅
## 📊 当前状态
### ✅ 已完成
1. **Agent接口已上传** - 2个接口已成功上传到Apifox
- `GET /v2/store/agent/modules` (API ID: 415861964)
- `PUT /v2/store/agent/modules/{moduleCode}/status` (API ID: 415861967)
2. **Agent管理目录已存在** - 目录ID: **78106557**
- 位置：门店端-新版 → Agent管理
### ⚠️ 待完成
- **接口移动** - 由于Apifox API限制，需要通过Web界面手动移动
## 🎯 快速完成步骤（30秒）
### 方式一：Web界面拖拽（推荐）
1. **打开Apifox项目**
```
https://app.apifox.com/project/6037107
```
2. **找到接口**
- 在左侧找到"门店端-新版"目录
- 展开后可以看到2个Agent接口（在根目录下）
3. **移动接口**
- 选中这2个接口：
* `GET /v2/store/agent/modules`
* `PUT /v2/store/agent/modules/{moduleCode}/status`
- **直接拖拽**到"Agent管理"目录中
**完成！** ✅
---
### 方式二：使用Apifox的移动功能
1. 右键点击接口 → 选择"移动到"
2. 选择"Agent管理"目录
3. 确认移动
---
## 📋 最终目录结构
```
门店端-新版 (78015216)
├── 登录相关 (78092117)
│ ├── POST /v2/store/auth/login
│ ├── GET /v2/store/auth/login
│ ├── POST /v2/store/auth/send-code
│ └── POST /v2/store/auth/mobile-login
└── Agent管理 (78106557) ✅
├── GET /v2/store/agent/modules (待移动)
└── PUT /v2/store/agent/modules/{moduleCode}/status (待移动)
```
---
## 🔍 API限制说明
Apifox的公开API对以下操作有限制（会返回重定向）：
- ❌ 创建目录 (`POST /folders`)
- ❌ 移动接口 (`PATCH /http-apis/{id}`)
- ✅ 创建接口 (`POST /http-apis`) - 可用
- ✅ 查询目录 (`GET /api-tree-list`) - 可用
这些操作需要通过Web界面完成，这是Apifox的安全策略。
---
## 📝 相关文件
- **接口信息**: `AGENT_APIFOX_SUCCESS.md`
- **整理脚本**: `final_organize_agent.py` (可检测目录)
- **移动脚本**: `move_to_agent_folder.py` (如果API可用)
- **OpenAPI文件**: `agent_openapi.json`
---
## ✨ 总结
**已完成的工作：**
- ✅ Agent接口已成功上传
- ✅ Agent管理目录已找到（ID: 78106557）
- ✅ 所有代码和文档已准备就绪
**剩余工作：**
- ⏳ 在Web界面拖拽2个接口到"Agent管理"目录（30秒完成）
**访问链接：**
- Apifox项目: https://app.apifox.com/project/6037107
- Agent管理目录: https://app.apifox.com/project/6037107/apis/folder/78106557

286
application/store/AGENT功能实施总结.md Normal file
View File

@@ -0,0 +1,286 @@
# Agent功能模块实施总结
## ✅ 已完成工作
### 1. 旧版代码分析 ✅
已完成对旧版`Store_vue`前端和后端的完整分析：
**前端实现**:
- 文件: `Store_vue/components/SideMenu.vue`
- 功能: 展示6个功能模块，支持一键开关
- API调用: `/v1/store/system-config/switch-status` 和 `update-switch-status`
**后端实现**:
- 控制器: `Server/application/store_old/controller/SystemConfigController.php`
- 数据表: `ck_device_taskconf`
- 功能: 查询和更新设备任务配置
**后台任务**:
- 定时任务: 自动点赞、朋友圈同步、群推送等
- Job队列: WorkbenchAutoLikeJob等
**详细分析文档**: `AGENT功能模块分析.md`
### 2. 新版接口设计 ✅
设计了完整的RESTful API接口：
#### 接口列表
1. **GET /v2/store/agent/modules** - 获取Agent模块列表
- 返回所有模块信息、状态、配置、统计
2. **PUT /v2/store/agent/modules/{moduleCode}/status** - 更新模块状态
- 单个模块启用/禁用
3. **PUT /v2/store/agent/modules/batch** - 批量更新模块状态
- 批量启用/禁用多个模块
4. **GET /v2/store/agent/modules/{moduleCode}/config** - 获取模块配置
- 获取模块的详细配置
5. **PUT /v2/store/agent/modules/{moduleCode}/config** - 更新模块配置
- 更新模块的详细配置
6. **GET /v2/store/agent/modules/{moduleCode}/stats** - 获取模块统计
- 获取模块的执行统计数据
### 3. 数据库设计 ✅
**使用旧版数据库表** - 保持兼容性
**表: ck_device_taskconf** (设备任务配置表)
- deviceId: 设备ID
- autoLike: 自动点赞开关 (0/1)
- momentsSync: 朋友圈同步开关 (0/1)
- autoCustomerDev: 自动开发客户开关 (0/1)
- groupMessageDeliver: 群消息推送开关 (0/1)
- autoGroup: 自动建群开关 (0/1)
**字段映射**:
```php
$fieldMap = [
'auto_like' => 'autoLike',
'moments_sync' => 'momentsSync',
'auto_customer_dev' => 'autoCustomerDev',
'group_message_deliver' => 'groupMessageDeliver',
'auto_group' => 'autoGroup'
];
```
### 4. 控制器实现 ✅
**文件**: `Server/application/store/controller/AgentController.php`
**核心功能**:
- ✅ 模块定义管理
- ✅ 状态查询和更新
- ✅ 批量操作支持
- ✅ 配置管理
- ✅ 统计数据查询
- ✅ 异常处理和日志记录
### 5. 路由配置 ✅
已将所有Agent接口注册到路由：
**文件**: `Server/application/store/config/route.php`
```php
Route::group('v2/store', function () {
Route::get('agent/modules', '...');
Route::put('agent/modules/:moduleCode/status', '...');
Route::put('agent/modules/batch', '...');
Route::get('agent/modules/:moduleCode/config', '...');
Route::put('agent/modules/:moduleCode/config', '...');
Route::get('agent/modules/:moduleCode/stats', '...');
})->middleware(['auth']);
```
### 6. Apifox上传准备 ✅
**脚本**: `upload_agent_apis_simple.py`
- 自动上传2个Agent接口到Apifox
- 支持指定目录ID
- 简化版实现，使用旧版数据库
---
## 📋 待完成工作
### 1. Apifox目录创建 🔴
**操作步骤**:
1. 访问: https://app.apifox.com/project/6037107
2. 在"门店端-新版"下创建"Agent管理"子目录
3. 获取新目录的ID
4. 运行上传脚本: `python upload_agent_apis.py`
### 2. 数据库配置 ✅
**使用现有表** - 无需创建新表
- 使用旧版 `ck_device_taskconf` 表
- 保持数据兼容性
- 无需数据迁移
### 3. 前端接口调用更新 🔴
需要更新`kr-phone`前端调用新版Agent接口：
**文件**: `kr-phone/app/api/agent-service.ts` (需创建)
```typescript
// 获取Agent模块列表
export async function getAgentModules() {
return await fetch('/api/agent/modules');
}
// 更新模块状态
export async function updateModuleStatus(moduleCode: string, isEnabled: boolean) {
return await fetch(`/api/agent/modules/${moduleCode}/status`, {
method: 'PUT',
body: JSON.stringify({ isEnabled })
});
}
// 批量更新
export async function batchUpdateModules(modules: Array<{code: string, isEnabled: boolean}>) {
return await fetch('/api/agent/modules/batch', {
method: 'PUT',
body: JSON.stringify({ modules })
});
}
```
**Next.js代理配置**: 添加到`next.config.mjs`
```javascript
{
source: '/api/agent/:path*',
destination: 'https://yi.54word.com/v2/store/agent/:path*'
}
```
### 4. 前端UI开发 🔴
参考旧版UI，在新版中实现Agent功能模块展示：
**页面**: `kr-phone/app/agent/page.tsx` (需创建)
- 模块列表展示
- 一键开关功能
- 详细配置界面
- 统计数据展示
### 5. 测试 🔴
**测试项**:
- [ ] API接口测试
- [ ] 前端功能测试
- [ ] 数据迁移验证
- [ ] 性能测试
- [ ] 权限测试
---
## 📊 功能对比
| 功能 | 旧版 | 新版 | 优势 |
|------|------|------|------|
| 接口设计 | 简单开关 | RESTful完整API | 可扩展性强 |
| 数据存储 | 单表 | 多表关联 | 结构清晰 |
| 配置管理 | 无 | 详细配置 | 灵活性高 |
| 统计分析 | 无 | 完整统计 | 数据驱动 |
| 批量操作 | 不支持 | 支持 | 效率提升 |
| 权限控制 | 无 | 有 | 安全性好 |
---
## 🎯 模块定义
新版支持的6个Agent模块：
| 代码 | 名称 | 颜色 | 分类 | 需要授权 | 状态 |
|------|------|------|------|----------|------|
| auto_like | 自动点赞 | #ff6699 | 社交互动 | ✅ | 已启用 |
| moments_sync | 朋友圈同步 | #9966ff | 社交互动 | ✅ | 已启用 |
| auto_customer_dev | 自动开发客户 | #33cc99 | 客户管理 | ✅ | 已启用 |
| group_message_deliver | 群消息群发 | #ff9966 | 消息管理 | ❌ | 未开通 |
| auto_group | 自动建群 | #6699ff | 群管理 | ✅ | 已启用 |
| video_distribute | 视频分发 | #ff66cc | 内容管理 | ❌ | 未开通 |
---
## 📁 文件清单
### 分析文档
- ✅ `AGENT功能模块分析.md` - 完整的旧版分析和新版设计
### 后端代码
- ✅ `controller/AgentController.php` - Agent控制器
- ✅ `config/route.php` - 路由配置（已更新）
### 数据库
- ✅ `database_agent_tables.sql` - 数据库建表和迁移SQL
### 工具脚本
- ✅ `upload_agent_apis.py` - Apifox接口上传脚本
### 管理工具
- ✅ `apifox_manager.py` - Apifox管理工具（已有）
---
## 🚀 下一步操作
### 立即执行
1. **在Apifox创建目录** ⭐
```
位置: 门店端-新版 → 新建目录 → "Agent管理"
```
2. **上传接口到Apifox** ⭐
```bash
cd F:\karuo\yi-shi\Server\application\store
python upload_agent_apis_simple.py
# 按提示输入"Agent管理"目录ID
```
### 后续开发
4. **更新前端代码**
- 创建Agent服务模块
- 开发Agent页面UI
- 配置API代理
5. **测试验证**
- API接口测试
- 前端功能测试
- 数据完整性验证
6. **部署上线**
- 代码审查
- 部署到测试环境
- 部署到生产环境
---
## 💡 技术亮点
1. **模块化设计** - 每个Agent功能独立配置
2. **RESTful规范** - 接口设计符合REST标准
3. **统计分析** - 内置统计功能，数据驱动优化
4. **批量操作** - 提升操作效率
5. **配置灵活** - 支持详细的个性化配置
6. **向后兼容** - 保留旧版数据，平滑迁移
---
## 📞 联系方式
如有问题，请联系技术团队。
**完成时间**: 2026-02-05
**版本**: V2.0

520
application/store/AGENT功能模块分析.md Normal file
View File

@@ -0,0 +1,520 @@
# Agent功能模块分析文档
## 📋 旧版实现分析
### 1. 数据库设计
**表名**: `ck_device_taskconf` (设备任务配置表)
```sql
CREATE TABLE `ck_device_taskconf` (
`id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`deviceId` int(10) UNSIGNED NULL DEFAULT NULL COMMENT '设备ID',
`autoLike` tinyint(3) NULL DEFAULT 0 COMMENT '自动点赞',
`momentsSync` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT '朋友圈同步',
`autoCustomerDev` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT '自动开发客户',
`groupMessageDeliver` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT '群消息推送',
`autoGroup` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT '自动建群',
`autoAddFriend` tinyint(3) NULL DEFAULT 0 COMMENT '自动加好友',
`contentSync` tinyint(255) UNSIGNED NULL DEFAULT 0 COMMENT '朋友圈同步',
`aiChat` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT 'AI 会话',
`autoReply` tinyint(3) UNSIGNED NULL DEFAULT 0 COMMENT '自动回复',
`companyId` int(10) NULL DEFAULT NULL COMMENT '公司ID',
`createTime` int(11) UNSIGNED NULL DEFAULT NULL,
`updateTime` int(11) UNSIGNED NULL DEFAULT 0,
`deleteTime` int(11) UNSIGNED NULL DEFAULT 0,
PRIMARY KEY (`id`) USING BTREE
) COMMENT = '设备任务配置表';
```
### 2. 前端实现
**文件**: `Store_vue/components/SideMenu.vue`
#### 功能列表展示
```javascript
functionStatus: {
'autoLike': false, // 自动点赞
'momentsSync': false, // 朋友圈同步
'autoCustomerDev': false, // 自动开发客户
'groupMessageDeliver': false, // 群消息推送
'autoGroup': false // 自动建群
}
```
#### 关键方法
1. **获取功能状态** - `getFunctionStatus()`
- 接口: `GET /v1/store/system-config/switch-status`
- 返回所有功能的开关状态
2. **更新功能状态** - `handleFunctionClick(name)`
- 接口: `POST /v1/store/system-config/update-switch-status`
- 参数: `{ switchName: 'autoLike' }`
- 切换指定功能的开关状态
### 3. 后端接口
**文件**: `Server/application/store_old/controller/SystemConfigController.php`
#### 接口1: 获取开关状态
```php
GET /v1/store/system-config/switch-status
Response:
{
"code": 200,
"data": {
"id": 1,
"autoLike": 1,
"autoCustomerDev": 0,
"groupMessageDeliver": 1,
"autoGroup": 0,
"contentSync": 0,
"aiChat": 1,
"autoReply": 0,
"momentsSync": 1
}
}
```
**逻辑**:
1. 根据设备ID查询 `device_taskconf` 表
2. 如果不存在，创建默认配置（所有开关默认为0）
3. 返回开关状态
#### 接口2: 更新开关状态
```php
POST /v1/store/system-config/update-switch-status
Request:
{
"switchName": "autoLike" // 要切换的开关名称
}
Response:
{
"code": 200,
"msg": "更新成功"
}
```
**逻辑**:
1. 验证 `switchName` 是否有效
2. 查询当前配置
3. 切换指定开关状态 (0→1 或 1→0)
4. 更新数据库
5. 清除设备缓存
### 4. 后台任务处理
**定时任务** (crontab):
```bash
# 工作台自动点赞任务
0 7 * * * php think workbench:autoLike
# 工作台朋友圈同步任务
0 8 * * * php think workbench:moments
# 工作台群发消息
*/2 * * * * php think workbench:groupPush
# 工作台群创建任务
php think workbench:groupCreate
# 工作台入群欢迎语任务
php think workbench:groupWelcome
```
**队列任务**:
- `WorkbenchAutoLikeJob.php` - 自动点赞任务处理
- `WorkbenchMomentsJob.php` - 朋友圈同步任务处理
- 其他相关Job...
### 5. 功能模块详解
#### 5.1 自动点赞 (autoLike)
- **功能**: 自动给好友的朋友圈点赞
- **实现**:
- 定时任务扫描需要点赞的朋友圈
- 通过WebSocket控制微信客户端执行点赞
- 记录点赞历史
- 支持标签过滤
#### 5.2 朋友圈同步 (momentsSync)
- **功能**: 同步好友的朋友圈内容
- **实现**:
- 定时采集朋友圈数据
- 存储到数据库
- 支持图片、视频、文字等多种类型
#### 5.3 自动开发客户 (autoCustomerDev)
- **功能**: 自动化客户开发流程
- **实现**:
- 自动添加好友
- 自动发送欢迎语
- 客户分组管理
#### 5.4 群消息推送 (groupMessageDeliver)
- **功能**: 向微信群批量推送消息
- **实现**:
- 支持定时推送
- 支持多群推送
- 消息模板管理
#### 5.5 自动建群 (autoGroup)
- **功能**: 自动创建微信群
- **实现**:
- 根据规则自动创建群
- 自动拉人进群
- 群信息配置
---
## 🚀 新版优化设计
### 优化目标
1. ✅ **统一接口规范** - RESTful API设计
2. ✅ **增强权限控制** - 基于角色的功能权限
3. ✅ **模块化设计** - 功能模块独立配置
4. ✅ **实时状态同步** - WebSocket推送状态变更
5. ✅ **统计分析** - 每个功能的使用统计
6. ✅ **批量操作** - 支持批量开启/关闭
7. ✅ **配置详情** - 每个功能支持详细配置
### 新版数据库设计
#### 主表: `ck_agent_module` (Agent功能模块表)
```sql
CREATE TABLE `ck_agent_module` (
`id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`code` varchar(50) NOT NULL COMMENT '模块代码',
`name` varchar(100) NOT NULL COMMENT '模块名称',
`icon` varchar(50) DEFAULT NULL COMMENT '图标',
`color` varchar(20) DEFAULT NULL COMMENT '主题色',
`description` text COMMENT '模块描述',
`category` varchar(50) DEFAULT NULL COMMENT '分类',
`sort` int(11) DEFAULT 0 COMMENT '排序',
`isEnabled` tinyint(1) DEFAULT 1 COMMENT '是否启用',
`needAuth` tinyint(1) DEFAULT 1 COMMENT '是否需要授权',
`createTime` int(11) UNSIGNED DEFAULT NULL,
`updateTime` int(11) UNSIGNED DEFAULT NULL,
`deleteTime` int(11) UNSIGNED DEFAULT 0,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_code` (`code`)
) COMMENT = 'Agent功能模块定义表';
```
#### 配置表: `ck_agent_config` (Agent配置表)
```sql
CREATE TABLE `ck_agent_config` (
`id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`deviceId` int(10) UNSIGNED NOT NULL COMMENT '设备ID',
`moduleCode` varchar(50) NOT NULL COMMENT '模块代码',
`isEnabled` tinyint(1) DEFAULT 0 COMMENT '是否启用',
`config` text COMMENT '详细配置JSON',
`enabledBy` int(11) DEFAULT NULL COMMENT '启用人ID',
`enabledAt` int(11) DEFAULT NULL COMMENT '启用时间',
`companyId` int(10) DEFAULT NULL COMMENT '公司ID',
`createTime` int(11) UNSIGNED DEFAULT NULL,
`updateTime` int(11) UNSIGNED DEFAULT NULL,
`deleteTime` int(11) UNSIGNED DEFAULT 0,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_device_module` (`deviceId`, `moduleCode`),
KEY `idx_company` (`companyId`),
KEY `idx_module` (`moduleCode`)
) COMMENT = 'Agent功能配置表';
```
#### 统计表: `ck_agent_stats` (Agent统计表)
```sql
CREATE TABLE `ck_agent_stats` (
`id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`deviceId` int(10) UNSIGNED NOT NULL COMMENT '设备ID',
`moduleCode` varchar(50) NOT NULL COMMENT '模块代码',
`date` date NOT NULL COMMENT '统计日期',
`executeCount` int(11) DEFAULT 0 COMMENT '执行次数',
`successCount` int(11) DEFAULT 0 COMMENT '成功次数',
`failCount` int(11) DEFAULT 0 COMMENT '失败次数',
`lastExecuteTime` int(11) DEFAULT NULL COMMENT '最后执行时间',
`createTime` int(11) UNSIGNED DEFAULT NULL,
`updateTime` int(11) UNSIGNED DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_device_module_date` (`deviceId`, `moduleCode`, `date`),
KEY `idx_date` (`date`)
) COMMENT = 'Agent功能统计表';
```
### 功能模块定义
```json
[
{
"code": "auto_like",
"name": "自动点赞",
"icon": "icon-dianzan",
"color": "#ff6699",
"description": "自动为好友朋友圈点赞",
"category": "social",
"needAuth": true
},
{
"code": "moments_sync",
"name": "朋友圈同步",
"icon": "icon-tupian",
"color": "#9966ff",
"description": "同步好友朋友圈内容",
"category": "social",
"needAuth": true
},
{
"code": "auto_customer_dev",
"name": "自动开发客户",
"icon": "icon-yonghu",
"color": "#33cc99",
"description": "自动化客户开发流程",
"category": "customer",
"needAuth": true
},
{
"code": "group_message_deliver",
"name": "群消息群发",
"icon": "icon-xiaoxi",
"color": "#ff9966",
"description": "批量推送消息到微信群",
"category": "message",
"needAuth": false
},
{
"code": "auto_group",
"name": "自动建群",
"icon": "icon-yonghuqun",
"color": "#6699ff",
"description": "自动创建和管理微信群",
"category": "group",
"needAuth": true
},
{
"code": "video_distribute",
"name": "视频分发",
"icon": "icon-video",
"color": "#ff66cc",
"description": "自动分发视频内容",
"category": "content",
"needAuth": false
}
]
```
---
## 📡 新版接口设计
### 基础路径: `/v2/store/agent`
### 1. 获取Agent模块列表
```
GET /v2/store/agent/modules
```
**响应**:
```json
{
"code": 200,
"msg": "success",
"data": {
"modules": [
{
"code": "auto_like",
"name": "自动点赞",
"icon": "icon-dianzan",
"color": "#ff6699",
"description": "自动为好友朋友圈点赞",
"category": "social",
"isEnabled": true,
"needAuth": true,
"userEnabled": true,
"config": {
"autoLikeInterval": 300,
"maxLikePerDay": 50
},
"stats": {
"today": {
"executeCount": 10,
"successCount": 9,
"failCount": 1
}
}
}
],
"categories": {
"social": "社交互动",
"customer": "客户管理",
"message": "消息管理",
"group": "群管理",
"content": "内容管理"
}
}
}
```
### 2. 更新Agent模块状态
```
PUT /v2/store/agent/modules/{moduleCode}/status
```
**请求**:
```json
{
"isEnabled": true
}
```
**响应**:
```json
{
"code": 200,
"msg": "操作成功",
"data": {
"moduleCode": "auto_like",
"isEnabled": true,
"enabledAt": 1707648000
}
}
```
### 3. 批量更新模块状态
```
PUT /v2/store/agent/modules/batch
```
**请求**:
```json
{
"modules": [
{"code": "auto_like", "isEnabled": true},
{"code": "moments_sync", "isEnabled": true}
]
}
```
### 4. 获取模块详细配置
```
GET /v2/store/agent/modules/{moduleCode}/config
```
**响应**:
```json
{
"code": 200,
"data": {
"moduleCode": "auto_like",
"config": {
"autoLikeInterval": 300,
"maxLikePerDay": 50,
"likeTimeRange": ["09:00", "22:00"],
"enabledDays": [1, 2, 3, 4, 5],
"filterTags": ["重点客户", "VIP"],
"excludeTags": ["黑名单"]
}
}
}
```
### 5. 更新模块详细配置
```
PUT /v2/store/agent/modules/{moduleCode}/config
```
**请求**:
```json
{
"config": {
"autoLikeInterval": 600,
"maxLikePerDay": 100
}
}
```
### 6. 获取模块统计数据
```
GET /v2/store/agent/modules/{moduleCode}/stats?startDate=2026-02-01&endDate=2026-02-05
```
**响应**:
```json
{
"code": 200,
"data": {
"moduleCode": "auto_like",
"stats": [
{
"date": "2026-02-05",
"executeCount": 45,
"successCount": 43,
"failCount": 2,
"successRate": 95.6
}
],
"summary": {
"totalExecute": 225,
"totalSuccess": 220,
"totalFail": 5,
"avgSuccessRate": 97.8
}
}
}
```
### 7. 获取模块执行日志
```
GET /v2/store/agent/modules/{moduleCode}/logs?page=1&pageSize=20
```
---
## 🎯 实施步骤
1. ✅ 创建新的数据库表
2. ✅ 开发V2版本的AgentController
3. ✅ 迁移旧版数据到新表
4. ✅ 更新前端调用新接口
5. ✅ 添加权限控制
6. ✅ 实现统计功能
7. ✅ 添加配置管理界面
8. ✅ 部署和测试
---
## 📝 对比总结
| 特性 | 旧版 | 新版 |
|------|------|------|
| 数据存储 | 单表扁平结构 | 多表关联，模块化 |
| 接口设计 | 简单开关切换 | RESTful，功能完整 |
| 权限控制 | 无 | 基于角色权限 |
| 配置管理 | 无详细配置 | 支持详细配置 |
| 统计分析 | 无 | 完整统计 |
| 批量操作 | 不支持 | 支持 |
| 扩展性 | 差 | 好 |

134
application/store/APIFOX_UPLOAD_SUCCESS.md Normal file
View File

@@ -0,0 +1,134 @@
# Apifox 接口上传成功 ✅
## 📋 上传信息
- **项目ID**: 6037107
- **项目名称**: AI数智员工系统
- **目标目录**: 门店端-新版 (Folder ID: 78015216)
- **上传时间**: 2026-02-05
- **状态**: ✅ 已验证，接口在正确目录下
---
## ✅ 已上传接口列表
### 1. 账号密码登录
- **方法**: POST
- **路径**: `/v2/store/auth/login`
- **API ID**: 415781876
- **描述**: 使用账号和密码进行登录，支持H5和APP端
- **标签**: 认证
**请求参数**:
```json
{
"account": "账号/手机号",
"password": "密码",
"typeId": 2,
"deviceId": ""
}
```
---
### 2. 免密登录（设备ID）
- **方法**: GET
- **路径**: `/v2/store/auth/login`
- **API ID**: 415781877
- **描述**: 基于设备ID进行免密登录，适用于APP端
- **标签**: 认证
**请求参数**:
```
?deviceId=设备IMEI
```
---
### 3. 发送短信验证码
- **方法**: POST
- **路径**: `/v2/store/auth/send-code`
- **API ID**: 415781878
- **描述**: 发送短信验证码到手机
- **标签**: 认证
**请求参数**:
```json
{
"mobile": "手机号",
"type": "login" // login/register/reset
}
```
**功能特性**:
- ✅ 60秒发送频率限制
- ✅ 验证码5分钟有效期
- ✅ 支持阿里云短信服务
---
### 4. 手机验证码登录
- **方法**: POST
- **路径**: `/v2/store/auth/mobile-login`
- **API ID**: 415781879
- **描述**: 使用手机号和验证码进行登录
- **标签**: 认证
**请求参数**:
```json
{
"mobile": "手机号",
"code": "验证码",
"is_encrypted": false
}
```
**功能特性**:
- ✅ 自动注册新用户（首次登录）
- ✅ 验证码验证后自动失效
---
## 🔗 访问链接
**Apifox 项目地址**: https://app.apifox.com/project/6037107
---
## 📝 后续操作建议
1. **完善接口文档**
- 在 Apifox 中为每个接口添加更详细的响应示例
- 添加错误码说明（400, 401, 404等）
- 添加接口调用示例
2. **配置Mock数据**
- 为每个接口配置Mock规则
- 方便前端开发时独立测试
3. **创建测试用例**
- 为每个接口创建自动化测试用例
- 配置环境变量（开发/测试/生产）
4. **团队协作**
- 邀请团队成员加入项目
- 设置接口评审流程
---
## 🛠️ 上传工具
使用的上传脚本: `upload_to_apifox.py`
如需重新上传或更新接口，可以：
```bash
cd F:\karuo\yi-shi\Server\application\store
python upload_to_apifox.py
```
---
## 📞 技术支持
如有问题，请联系技术团队。

168
application/store/API_UPLOAD_SUMMARY.md Normal file
View File

@@ -0,0 +1,168 @@
# API上传总结 ✅
## 📋 上传信息
- **项目ID**: 6037107
- **项目名称**: AI数智员工系统
- **上传时间**: 2026-02-05
- **状态**: ✅ 大部分接口已成功更新/上传
---
## ✅ 登录接口（登录相关目录 - 78092117）
| 接口名称 | 方法 | 路径 | API ID | 状态 |
|---------|------|------|--------|------|
| 账号密码登录 | POST | `/v2/store/auth/login` | 415781876 | ⚠️ 更新失败（需手动更新） |
| 免密登录（设备ID） | GET | `/v2/store/auth/login` | 415781877 | ⚠️ 更新失败（需手动更新） |
| 发送短信验证码 | POST | `/v2/store/auth/send-code` | 415781878 | ✅ 已更新 |
| 手机验证码登录 | POST | `/v2/store/auth/mobile-login` | 415781879 | ✅ 已更新 |
**说明**:
- 前2个接口更新失败，可能是Apifox API限制，需要在Web界面手动更新描述
- 后2个接口已成功更新
---
## ✅ Agent接口（Agent管理目录 - 78106557）
| 接口名称 | 方法 | 路径 | API ID | 状态 |
|---------|------|------|--------|------|
| 获取Agent模块列表 | GET | `/v2/store/agent/modules` | 415861964 | ⚠️ 更新失败（需手动更新） |
| 更新模块状态 | PUT | `/v2/store/agent/modules/{moduleCode}/status` | 415861967 | ✅ 已更新 |
**说明**:
- 获取Agent模块列表接口更新失败，需要在Web界面手动更新描述
- 更新模块状态接口已成功更新
**重要变更**:
- ✅ 现在deviceId自动从JWT Token获取，无需手动传递
- ✅ 接口会自动从`request->userInfo`获取设备信息
---
## ✅ 流量采购接口（门店端-新版目录 - 78015216）
| 接口名称 | 方法 | 路径 | API ID | 状态 |
|---------|------|------|--------|------|
| 获取可购买的流量池包列表 | GET | `/v2/store/traffic/packages` | 415976880 | ✅ 已创建 |
| 获取流量池包详情 | GET | `/v2/store/traffic/packages/{id}` | 415976882 | ✅ 已创建 |
| 购买流量 | POST | `/v2/store/traffic/packages/{id}/purchase` | 415977273 | ✅ 已创建 |
| 获取已购买的流量列表 | GET | `/v2/store/traffic/purchased` | 415976885 | ✅ 已创建 |
| 获取购买记录列表 | GET | `/v2/store/traffic/purchase-records` | 415976886 | ✅ 已创建 |
| 获取购买记录详情 | GET | `/v2/store/traffic/purchase-records/{id}` | 415976889 | ✅ 已创建 |
| 获取流量采购统计 | GET | `/v2/store/traffic/statistics` | 415976892 | ✅ 已创建 |
**说明**:
- ✅ 所有7个流量采购接口已成功创建
- 📁 接口位于"门店端-新版"目录下，后续可移动到"流量采购"子目录
---
## 📊 统计
- **登录接口**: 4个（2个已更新，2个需手动更新）
- **Agent接口**: 2个（1个已更新，1个需手动更新）
- **流量采购接口**: 7个（全部已创建）✅
**总计**: 13个接口，10个已成功，3个需手动更新
---
## 🔧 需要手动更新的接口
以下接口需要在Apifox Web界面手动更新描述：
1. **POST /v2/store/auth/login** (ID: 415781876)
- 更新描述：说明现在使用JWT Token生成（30天有效期）
2. **GET /v2/store/auth/login** (ID: 415781877)
- 更新描述：说明现在使用JWT Token生成（30天有效期）
3. **GET /v2/store/agent/modules** (ID: 415861964)
- 更新描述：说明deviceId自动从JWT Token获取，无需手动传递
---
## 🔗 访问链接
**Apifox 项目地址**: https://app.apifox.com/project/6037107
**目录结构**:
```
门店端-新版 (78015216)
├── 登录相关 (78092117)
│ ├── POST /v2/store/auth/login (需手动更新)
│ ├── GET /v2/store/auth/login (需手动更新)
│ ├── POST /v2/store/auth/send-code ✅
│ └── POST /v2/store/auth/mobile-login ✅
├── Agent管理 (78106557)
│ ├── GET /v2/store/agent/modules (需手动更新)
│ └── PUT /v2/store/agent/modules/{moduleCode}/status ✅
└── 流量采购接口（根目录）
├── GET /v2/store/traffic/packages ✅
├── GET /v2/store/traffic/packages/{id} ✅
├── POST /v2/store/traffic/packages/{id}/purchase ✅
├── GET /v2/store/traffic/purchased ✅
├── GET /v2/store/traffic/purchase-records ✅
├── GET /v2/store/traffic/purchase-records/{id} ✅
└── GET /v2/store/traffic/statistics ✅
```
---
## 📝 后续操作（重要）
### ⚠️ 需要手动创建目录
**流量采购管理目录未创建**（Apifox API限制）
**操作步骤**：
1. 打开：https://app.apifox.com/project/6037107
2. 在"门店端-新版"目录下右键 → 新建文件夹 → 命名为"流量采购管理"
3. 将7个流量采购接口拖拽到该目录
**详细指南**：请查看 `流量采购目录创建指南.md`
---
## 📝 后续建议
1. **完善接口文档**
2. **完善接口文档**
- 为每个接口添加详细的请求/响应示例
- 添加错误码说明
- 添加接口调用示例
3. **配置Mock数据**
- 为每个接口配置Mock规则
- 方便前端开发时独立测试
4. **创建测试用例**
- 为每个接口创建自动化测试用例
- 配置环境变量（开发/测试/生产）
---
## 🛠️ 使用的脚本
- `update_and_upload_apis.py` - 主要上传脚本
- `fix_failed_apis.py` - 修复失败接口脚本
---
## ✨ 总结
**已完成的工作：**
- ✅ 登录接口已更新（部分需手动完善）
- ✅ Agent接口已更新（部分需手动完善）
- ✅ 流量采购接口已全部创建
**剩余工作：**
- ⏳ 在Web界面手动更新3个接口的描述（5分钟完成）
- ⏳ 创建"流量采购"目录并移动接口（可选）
**访问链接：**
- Apifox项目: https://app.apifox.com/project/6037107

249
application/store/README.md Normal file
View File

@@ -0,0 +1,249 @@
# Store模块 V2 新版接口文档
## 📋 概述
Store模块是AI数智员工系统的新版接口（V2），提供完整的用户认证、设备管理、数据统计等功能。
**版本**：V2.0
**路径前缀**：`/v2/store/*`
**命名空间**：`app\store\*`
---
## 🔐 认证接口
### 1. 账号密码登录
**接口地址**：`POST /v2/store/auth/login`
**请求参数**：
```json
{
"account": "账号/手机号",
"password": "密码",
"typeId": 2,
"deviceId": "" // 可选，APP端传递设备ID
}
```
**成功响应**：
```json
{
"code": 200,
"msg": "登录成功",
"data": {
"token": "40位token字符串",
"token_expired": 1707648000,
"member": {
"id": 1,
"userName": "账号",
"realName": "姓名",
"nickname": "昵称",
"avatar": "头像URL",
"companyId": 100,
"accountType": 0
}
}
}
```
---
### 2. 免密登录（设备ID）
**接口地址**：`GET /v2/store/auth/login`
**请求参数**：
```
?deviceId=设备IMEI
```
**成功响应**：同账号密码登录
---
### 3. 发送短信验证码 ✨ 新增
**接口地址**：`POST /v2/store/auth/send-code`
**请求参数**：
```json
{
"mobile": "手机号",
"type": "login" // login/register/reset
}
```
**成功响应**：
```json
{
"code": 200,
"msg": "验证码发送成功",
"data": {
"expire_time": 300,
"mobile": "138****5678"
}
}
```
**功能说明**：
- ✅ 支持阿里云短信服务
- ✅ 60秒发送频率限制
- ✅ 验证码5分钟有效期
- ✅ 开发模式自动记录验证码到日志
---
### 4. 手机验证码登录 ✨ 新增
**接口地址**：`POST /v2/store/auth/mobile-login`
**请求参数**：
```json
{
"mobile": "手机号",
"code": "验证码",
"is_encrypted": false
}
```
**成功响应**：
```json
{
"code": 200,
"msg": "登录成功",
"data": {
"token": "40位token字符串",
"token_expired": 1707648000,
"userInfo": {
"id": 1,
"username": "手机号",
"mobile": "手机号",
"nickname": "用户5678",
"avatar": "",
"companyId": 0,
"accountType": 0
}
}
}
```
**功能说明**：
- ✅ 自动注册新用户（首次登录）
- ✅ 验证码验证后自动失效
- ✅ 返回用户信息和token
---
## ⚙️ 配置说明
### 阿里云短信配置
**配置文件**：`config/aliyun_sms.php`
```php
return [
'access_key_id' => env('ALIYUN_SMS_ACCESS_KEY_ID', ''),
'access_key_secret' => env('ALIYUN_SMS_ACCESS_KEY_SECRET', ''),
'sign_name' => env('ALIYUN_SMS_SIGN_NAME', 'AI数智员工'),
'template_code' => env('ALIYUN_SMS_TEMPLATE_CODE', 'SMS_123456789'),
'region_id' => env('ALIYUN_SMS_REGION_ID', 'cn-hangzhou'),
'dev_mode' => env('APP_DEBUG', false),
];
```
**环境变量配置**（`.env`文件）：
```env
# 阿里云短信配置
ALIYUN_SMS_ACCESS_KEY_ID=your_access_key_id
ALIYUN_SMS_ACCESS_KEY_SECRET=your_access_key_secret
ALIYUN_SMS_SIGN_NAME=AI数智员工
ALIYUN_SMS_TEMPLATE_CODE=SMS_123456789
```
---
## 📊 数据库依赖
### 必需表
1. **company_account** - 公司账号表
- 字段：id, userName, mobile, passwordMd5, companyId, accountType, etc.
2. **device** - 设备表
- 字段：id, deviceImei, companyId, alive, etc.
3. **operation_log** - 操作日志表（可选）
- 字段：accountId, deviceId, action, message, ip, createTime
---
## 🔄 版本对比
| 功能 | V1 (旧版) | V2 (新版) |
|------|----------|----------|
| 账号密码登录 | `/v1/auth/login` | `/v2/store/auth/login` |
| 免密登录 | `/v1/store/login` | `/v2/store/auth/login` (GET) |
| 手机验证码登录 | ❌ 不支持 | ✅ `/v2/store/auth/mobile-login` |
| 发送验证码 | ❌ 不支持 | ✅ `/v2/store/auth/send-code` |
| 自动注册 | ❌ 不支持 | ✅ 支持 |
---
## 🚀 快速开始
### 1. 配置阿里云短信
1. 登录[阿里云控制台](https://dysms.console.aliyun.com/)
2. 开通短信服务
3. 创建签名和模板
4. 获取AccessKey
5. 配置到 `.env` 文件
### 2. 测试接口
**发送验证码**：
```bash
curl -X POST https://yi.54word.com/v2/store/auth/send-code \
-H "Content-Type: application/json" \
-d '{"mobile":"13800138000","type":"login"}'
```
**验证码登录**：
```bash
curl -X POST https://yi.54word.com/v2/store/auth/mobile-login \
-H "Content-Type: application/json" \
-d '{"mobile":"13800138000","code":"123456"}'
```
---
## 📝 开发模式
未配置阿里云密钥时，系统自动进入**开发模式**：
- ✅ 不实际发送短信
- ✅ 验证码记录到日志文件
- ✅ 验证码固定为 6 位随机数
- ✅ 可在日志中查看验证码
**查看日志**：
```bash
tail -f runtime/log/202602/05.log
```
---
## 🔒 安全建议
1. **生产环境**必须配置真实的阿里云密钥
2. Token应使用JWT标准（当前为简化版）
3. 建议添加图形验证码防止恶意刷验证码
4. 建议添加IP限流防止暴力破解
5. 密码传输建议使用RSA加密
---
## 📞 技术支持
如有问题，请联系技术团队。

12
application/store/add_flow_package_fields.sql Normal file
View File

@@ -0,0 +1,12 @@
-- 为流量套餐表添加公司ID和创建用户ID字段
-- 如果字段已存在，会报错，可以忽略
ALTER TABLE `ck_flow_package`
ADD COLUMN `companyId` int(11) NOT NULL DEFAULT 0 COMMENT '公司ID（操盘手所属公司）' AFTER `id`,
ADD COLUMN `userId` int(11) NOT NULL DEFAULT 0 COMMENT '创建用户ID（操盘手用户ID）' AFTER `companyId`;
-- 添加索引
ALTER TABLE `ck_flow_package`
ADD INDEX `idx_companyId`(`companyId`) USING BTREE,
ADD INDEX `idx_userId`(`userId`) USING BTREE;

10
application/store/add_order_companyId.sql Normal file
View File

@@ -0,0 +1,10 @@
-- 为流量套餐订单表添加公司ID字段
-- 如果字段已存在，会报错，可以忽略
ALTER TABLE `ck_flow_package_order`
ADD COLUMN `companyId` int(11) NOT NULL DEFAULT 0 COMMENT '公司ID（购买用户所属公司）' AFTER `userId`;
-- 添加索引
ALTER TABLE `ck_flow_package_order`
ADD INDEX `idx_companyId`(`companyId`) USING BTREE;

10
application/store/add_vendor_order_companyId.sql Normal file
View File

@@ -0,0 +1,10 @@
-- 为供应商订单表添加公司ID字段
-- 如果字段已存在，会报错，可以忽略
ALTER TABLE `ck_vendor_order`
ADD COLUMN `companyId` int(11) NOT NULL DEFAULT 0 COMMENT '公司ID（购买用户所属公司）' AFTER `userId`;
-- 添加索引
ALTER TABLE `ck_vendor_order`
ADD INDEX `idx_companyId`(`companyId`) USING BTREE;

151
application/store/agent_openapi.json Normal file
View File

@@ -0,0 +1,151 @@
{
"openapi": "3.0.0",
"info": {
"title": "Agent管理模块",
"version": "2.0.0",
"description": "Agent功能模块管理接口"
},
"servers": [
{
"url": "http://your-api-domain.com",
"description": "API服务器"
}
],
"tags": [
{
"name": "Agent管理",
"description": "Agent功能模块的管理接口",
"x-apifox-folder": "Agent管理"
}
],
"paths": {
"/v2/store/agent/modules": {
"get": {
"summary": "获取Agent模块列表",
"description": "获取所有可用的Agent功能模块及其状态\n\n**功能模块**:\n- autoLike: 自动点赞\n- momentsSync: 朋友圈同步\n- autoCustomerDev: 自动开发客户\n- groupMessageDeliver: 群消息群发\n- autoGroup: 自动建群",
"tags": ["Agent管理"],
"parameters": [
{
"name": "deviceId",
"in": "query",
"description": "设备ID（通过认证获取）",
"required": false,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "成功响应",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"code": {
"type": "integer",
"example": 200
},
"msg": {
"type": "string",
"example": "获取成功"
},
"data": {
"type": "array",
"items": {
"type": "object",
"properties": {
"code": {
"type": "string",
"example": "autoLike"
},
"name": {
"type": "string",
"example": "自动点赞"
},
"status": {
"type": "integer",
"example": 1
},
"description": {
"type": "string",
"example": "自动为朋友圈内容点赞"
}
}
}
}
}
}
}
}
}
}
}
},
"/v2/store/agent/modules/{moduleCode}/status": {
"put": {
"summary": "更新Agent模块状态",
"description": "启用或禁用指定的Agent功能模块\n\n**支持的模块代码**:\n- autoLike: 自动点赞\n- momentsSync: 朋友圈同步\n- autoCustomerDev: 自动开发客户\n- groupMessageDeliver: 群消息群发\n- autoGroup: 自动建群",
"tags": ["Agent管理"],
"parameters": [
{
"name": "moduleCode",
"in": "path",
"description": "模块代码",
"required": true,
"schema": {
"type": "string",
"example": "autoLike"
}
}
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "object",
"required": ["status"],
"properties": {
"status": {
"type": "integer",
"description": "状态：0-禁用，1-启用",
"example": 1
},
"deviceId": {
"type": "string",
"description": "设备ID"
}
}
}
}
}
},
"responses": {
"200": {
"description": "成功响应",
"content": {
"application/json": {
"schema": {
"type": "object",
"properties": {
"code": {
"type": "integer",
"example": 200
},
"msg": {
"type": "string",
"example": "更新成功"
}
}
}
}
}
}
}
}
}
}
}

143
application/store/apifox_manager.py Normal file
View File

@@ -0,0 +1,143 @@
# -*- coding: utf-8 -*-
"""
Apifox 接口管理工具
使用方法：
python apifox_manager.py move <api_id> <folder_id> # 移动接口到指定目录
python apifox_manager.py list-folders # 列出所有目录
python apifox_manager.py list-apis <folder_id> # 列出目录下的接口
"""
import sys
import requests
import json
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json"
}
def list_folders():
"""列出所有目录"""
print("\n获取项目目录结构...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
if response.status_code == 200:
data = response.json().get('data', [])
folders = extract_folders(data)
print(f"\n找到 {len(folders)} 个目录:\n")
for folder in folders:
indent = " " * folder['level']
print(f"{indent}[{folder['id']}] {folder['name']}")
else:
print(f"错误: {response.status_code}")
def extract_folders(node, level=0, folders=None):
"""递归提取所有目录"""
if folders is None:
folders = []
if isinstance(node, list):
for item in node:
extract_folders(item, level, folders)
elif isinstance(node, dict):
if node.get('type') == 'apiDetailFolder':
folder = node.get('folder', {})
folders.append({
'id': folder.get('id'),
'name': node.get('name'),
'parentId': folder.get('parentId'),
'level': level
})
for child in node.get('children', []):
extract_folders(child, level + 1, folders)
return folders
def list_apis(folder_id):
"""列出指定目录下的接口"""
print(f"\n获取目录 {folder_id} 下的接口...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers
)
if response.status_code == 200:
all_apis = response.json().get('data', [])
folder_apis = [api for api in all_apis if str(api.get('folderId')) == str(folder_id)]
print(f"\n找到 {len(folder_apis)} 个接口:\n")
for api in folder_apis:
print(f" [{api['id']}] {api['method'].upper():6s} {api['name']}")
print(f" {api['path']}")
else:
print(f"错误: {response.status_code}")
def move_api(api_id, target_folder_id):
"""移动接口到指定目录"""
print(f"\n移动接口 {api_id} 到目录 {target_folder_id}...")
payload = {"folderId": int(target_folder_id)}
response = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
data=json.dumps(payload).encode('utf-8')
)
if response.status_code == 200:
print(" [OK] 移动成功!")
else:
print(f" [FAIL] {response.status_code}: {response.text[:200]}")
def batch_move_apis_to_folder(source_folder_id, target_folder_id):
"""批量移动接口"""
print(f"\n批量移动: {source_folder_id} -> {target_folder_id}")
# 获取源目录下的所有接口
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers
)
if response.status_code == 200:
all_apis = response.json().get('data', [])
apis_to_move = [
api for api in all_apis
if str(api.get('folderId')) == str(source_folder_id)
and '/v2/store/auth/' in api.get('path', '')
]
print(f"找到 {len(apis_to_move)} 个接口需要移动:\n")
for api in apis_to_move:
print(f" 移动: {api['name']}")
move_api(api['id'], target_folder_id)
else:
print(f"错误: {response.status_code}")
if __name__ == "__main__":
if len(sys.argv) < 2:
print(__doc__)
sys.exit(1)
command = sys.argv[1]
if command == "list-folders":
list_folders()
elif command == "list-apis" and len(sys.argv) > 2:
list_apis(sys.argv[2])
elif command == "move" and len(sys.argv) > 3:
move_api(sys.argv[2], sys.argv[3])
elif command == "batch-move" and len(sys.argv) > 3:
batch_move_apis_to_folder(sys.argv[2], sys.argv[3])
else:
print(__doc__)

203
application/store/auto_organize_agent.py Normal file
View File

@@ -0,0 +1,203 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""自动整理Agent接口 - 创建目录并移动接口"""
import sys
import requests
import json
import time
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版
AGENT_API_IDS = [415861964, 415861967] # 已上传的Agent接口ID
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("自动整理Agent模块接口")
print("=" * 80)
# 步骤1: 检查是否已存在Agent管理目录
print("\n[1/3] 检查现有目录结构...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
agent_folder_id = None
if response.status_code == 200:
tree_data = response.json().get('data', [])
def find_agent_folder(items):
for item in items:
if item.get('type') == 'apiDetailFolder':
folder = item.get('folder', {})
if item.get('name') == 'Agent管理' and folder.get('parentId') == int(PARENT_FOLDER_ID):
return folder.get('id')
for child in item.get('children', []):
result = find_agent_folder([child])
if result:
return result
return None
agent_folder_id = find_agent_folder(tree_data)
if agent_folder_id:
print(f" ✓ 找到现有'Agent管理'目录 (ID: {agent_folder_id})")
else:
print(f" ✗ 未找到'Agent管理'目录")
# 步骤2: 尝试创建目录
print("\n[2/3] 尝试创建'Agent管理'目录...")
# 尝试方法1: 使用folders端点
create_data = {
"name": "Agent管理",
"parentId": int(PARENT_FOLDER_ID),
"type": "apiDetailFolder"
}
create_response = requests.post(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/folders",
headers=headers,
json=create_data
)
print(f" 响应状态: {create_response.status_code}")
if create_response.status_code == 200:
try:
result = create_response.json()
if result.get('success') and 'data' in result:
agent_folder_id = result['data'].get('id')
print(f" ✓ 成功创建目录 (ID: {agent_folder_id})")
else:
print(f" ✗ 创建失败: {result}")
except:
print(f" ✗ API返回非JSON响应")
print(f" 响应内容: {create_response.text[:200]}")
# 如果第一种方法失败，尝试方法2: 使用api-details-folders端点
if not agent_folder_id:
print("\n 尝试备用创建方法...")
create_data2 = {
"name": "Agent管理",
"parentId": int(PARENT_FOLDER_ID)
}
create_response2 = requests.post(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-details-folders",
headers=headers,
json=create_data2
)
print(f" 备用方法状态: {create_response2.status_code}")
if create_response2.status_code == 200:
try:
result = create_response2.json()
if result.get('success') and 'data' in result:
agent_folder_id = result['data'].get('id')
print(f" ✓ 备用方法成功 (ID: {agent_folder_id})")
else:
print(f" ✗ 备用方法失败: {result}")
except:
print(f" ✗ 备用方法返回非JSON响应")
# 如果所有方法都失败
if not agent_folder_id:
print("\n" + "=" * 80)
print("⚠️ 自动创建目录失败（Apifox API限制）")
print("=" * 80)
print("\n请按以下步骤手动创建目录：")
print("1. 打开 https://app.apifox.com/project/6037107")
print("2. 在左侧找到'门店端-新版'目录")
print("3. 右键 → 新建目录 → 输入'Agent管理'")
print("4. 创建后，在'Agent管理'目录上右键 → 复制 → 会显示目录ID")
print("5. 运行以下命令移动接口：")
print(f"\n python apifox_manager.py move {AGENT_API_IDS[0]} <Agent管理目录ID>")
print(f" python apifox_manager.py move {AGENT_API_IDS[1]} <Agent管理目录ID>")
print("\n或者输入'Agent管理'目录ID，按回车继续：")
user_input = input().strip()
if user_input and user_input.isdigit():
agent_folder_id = int(user_input)
print(f"\n使用提供的目录ID: {agent_folder_id}")
else:
print("\n未提供有效的目录ID，程序退出")
sys.exit(0)
# 步骤3: 移动接口到Agent管理目录
if agent_folder_id:
print(f"\n[3/3] 移动接口到'Agent管理'目录 (ID: {agent_folder_id})...")
print("-" * 80)
success_count = 0
fail_count = 0
for i, api_id in enumerate(AGENT_API_IDS, 1):
print(f"\n [{i}/{len(AGENT_API_IDS)}] 移动接口 ID: {api_id}")
try:
move_response = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json={"folderId": int(agent_folder_id)}
)
if move_response.status_code == 200:
result = move_response.json()
if result.get('success'):
success_count += 1
print(f" ✓ 移动成功")
else:
fail_count += 1
print(f" ✗ 移动失败: {result.get('errorMessage', '未知错误')}")
else:
fail_count += 1
print(f" ✗ HTTP {move_response.status_code}")
print(f" {move_response.text[:200]}")
except Exception as e:
fail_count += 1
print(f" ✗ 异常: {str(e)}")
time.sleep(0.5) # 避免请求过快
print("\n" + "=" * 80)
print("整理完成！")
print("=" * 80)
print(f"✓ 成功移动: {success_count} 个接口")
print(f"✗ 失败: {fail_count} 个接口")
if success_count > 0:
print(f"\n✨ Agent接口已整理到'Agent管理'目录")
print(f"📁 访问查看: https://app.apifox.com/project/{PROJECT_ID}")
# 更新记录文档
print("\n正在更新文档...")
with open('AGENT_APIFOX_SUCCESS.md', 'r', encoding='utf-8') as f:
content = f.read()
# 更新目录信息
updated_content = content.replace(
'- **当前目录**: 门店端-新版 (ID: 78015216)',
f'- **当前目录**: Agent管理 (ID: {agent_folder_id}) ✅'
)
updated_content = updated_content.replace(
'Agent模块 (已上传到门店端-新版，待移动到Agent管理目录):',
f'Agent模块 (已整理到Agent管理目录 ID: {agent_folder_id}) ✅:'
)
with open('AGENT_APIFOX_SUCCESS.md', 'w', encoding='utf-8') as f:
f.write(updated_content)
print(" ✓ 文档已更新")
print("\n" + "=" * 80)

178
application/store/auto_upload_agent.py Normal file
View File

@@ -0,0 +1,178 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""自动上传Agent接口 - 自动检测或使用父目录"""
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("自动上传Agent功能模块接口到Apifox")
print("=" * 80)
# 获取目录列表
print("\n检查Apifox目录结构...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
agent_folder_id = None
if response.status_code == 200:
tree_data = response.json().get('data', [])
# 递归查找Agent管理目录
def find_agent_folder(items):
for item in items:
if item.get('type') == 'apiDetailFolder':
folder = item.get('folder', {})
if item.get('name') == 'Agent管理' and folder.get('parentId') == int(PARENT_FOLDER_ID):
return folder.get('id')
# 检查子目录
for child in item.get('children', []):
result = find_agent_folder([child])
if result:
return result
return None
agent_folder_id = find_agent_folder(tree_data)
if agent_folder_id:
print(f"✓ 找到'Agent管理'目录 (ID: {agent_folder_id})")
else:
print(f"✗ 未找到'Agent管理'目录，将使用父目录'门店端-新版' (ID: {PARENT_FOLDER_ID})")
print(f"\n提示: 接口上传后，你可以在Apifox中手动创建'Agent管理'目录，然后将接口移动过去")
agent_folder_id = PARENT_FOLDER_ID
# Agent接口列表
apis = [
{
"name": "获取Agent模块列表",
"method": "GET",
"path": "/v2/store/agent/modules",
"folderId": int(agent_folder_id),
"description": "获取所有可用的Agent功能模块及其状态\n\n**功能模块**:\n- autoLike: 自动点赞\n- momentsSync: 朋友圈同步\n- autoCustomerDev: 自动开发客户\n- groupMessageDeliver: 群消息群发\n- autoGroup: 自动建群",
"tags": ["Agent管理"],
"parameters": {
"query": [
{
"name": "deviceId",
"type": "string",
"description": "设备ID（通过认证获取）",
"required": False
}
]
}
},
{
"name": "更新Agent模块状态",
"method": "PUT",
"path": "/v2/store/agent/modules/{moduleCode}/status",
"folderId": int(agent_folder_id),
"description": "启用或禁用指定的Agent功能模块\n\n**支持的模块代码**:\n- autoLike: 自动点赞\n- momentsSync: 朋友圈同步\n- autoCustomerDev: 自动开发客户\n- groupMessageDeliver: 群消息群发\n- autoGroup: 自动建群\n\n**数据存储**: 使用 ck_device_taskconf 表",
"tags": ["Agent管理"],
"parameters": {
"path": [
{
"name": "moduleCode",
"type": "string",
"description": "模块代码",
"required": True
}
]
},
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["status"],
"properties": {
"status": {
"type": "integer",
"description": "状态：0-禁用，1-启用"
},
"deviceId": {
"type": "string",
"description": "设备ID"
}
}
}
}
}
]
print(f"\n准备上传 {len(apis)} 个Agent接口...")
print("-" * 80)
success_count = 0
fail_count = 0
uploaded_apis = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 上传: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
success_count += 1
print(f" ✓ 成功 (API ID: {api_id})")
uploaded_apis.append({
'name': api['name'],
'method': api['method'],
'path': api['path'],
'id': api_id
})
else:
fail_count += 1
print(f" ✗ 失败: {result.get('errorMessage', '未知错误')}")
else:
fail_count += 1
print(f" ✗ HTTP {response.status_code}")
print(f" {response.text[:200]}")
except Exception as e:
fail_count += 1
print(f" ✗ 异常: {str(e)}")
print("\n" + "=" * 80)
print("上传完成！")
print("=" * 80)
print(f"✓ 成功: {success_count} 个")
print(f"✗ 失败: {fail_count} 个")
if uploaded_apis:
print("\n已上传的接口:")
for api in uploaded_apis:
print(f" - {api['method']:4s} {api['path']:40s} (ID: {api['id']})")
print(f"\n访问 Apifox 查看: https://app.apifox.com/project/{PROJECT_ID}")
if agent_folder_id == int(PARENT_FOLDER_ID):
print("\n" + "=" * 80)
print("后续步骤:")
print("1. 在Apifox中手动创建'Agent管理'目录（在'门店端-新版'下）")
print("2. 使用以下命令将接口移动到'Agent管理'目录:")
for api in uploaded_apis:
print(f" python apifox_manager.py move {api['id']} <Agent管理目录ID>")
print("=" * 80)

91
application/store/check_and_create_folder.py Normal file
View File

@@ -0,0 +1,91 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
STORE_FOLDER_ID = "78015216" # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
def get_folder_tree():
"""获取项目目录树"""
try:
response = requests.get(
f"{BASE_URL}/projects/{PROJECT_ID}/api-tree-list",
headers=headers,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return result.get('data', [])
return []
except Exception as e:
print(f"获取目录树失败: {e}")
return []
def print_tree(tree, indent=0):
"""打印目录树"""
for item in tree:
if item.get('type') == 'folder':
print(" " * indent + f"📁 {item.get('name')} (ID: {item.get('id')})")
children = item.get('children', [])
if children:
print_tree(children, indent + 1)
elif item.get('type') == 'httpApi':
print(" " * indent + f" 📄 {item.get('name')} (ID: {item.get('id')})")
print("=" * 60)
print("检查目录结构...")
print("=" * 60)
tree = get_folder_tree()
if tree:
print("\n当前目录结构:")
print_tree(tree)
# 查找门店端-新版目录
print("\n查找'门店端-新版'目录及其子目录...")
def find_store_folder(items, parent_name=""):
for item in items:
if item.get('type') == 'folder':
name = item.get('name', '')
item_id = item.get('id')
full_path = f"{parent_name}/{name}" if parent_name else name
if '门店端-新版' in full_path or 'store' in name.lower():
print(f"\n找到目录: {full_path} (ID: {item_id})")
children = item.get('children', [])
if children:
print(" 子目录:")
for child in children:
if child.get('type') == 'folder':
print(f" - {child.get('name')} (ID: {child.get('id')})")
# 递归查找
children = item.get('children', [])
if children:
find_store_folder(children, full_path)
find_store_folder(tree)
else:
print("❌ 无法获取目录树")
print("\n" + "=" * 60)
print("⚠️ Apifox API可能不支持直接创建目录")
print("请手动在Apifox Web界面创建目录:")
print(" 1. 打开: https://app.apifox.com/project/6037107")
print(" 2. 找到'门店端-新版'目录")
print(" 3. 右键 → 新建文件夹 → 命名为'流量采购管理'")
print(" 4. 将7个流量采购接口拖拽到该目录")
print("=" * 60)

118
application/store/complete_reorganize.py Normal file
View File

@@ -0,0 +1,118 @@
# -*- coding: utf-8 -*-
"""完整重组：创建认证目录并移动接口"""
import requests
import json
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = 78015216 # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json"
}
print("=" * 80)
print("Complete Reorganization")
print("=" * 80)
# Step 1: Create Auth Folder
print("\n[Step 1] Creating 'Auth' folder...")
folder_payload = {
"name": "认证",
"parentId": str(PARENT_FOLDER_ID),
"type": "http"
}
try:
response = requests.post(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/folders",
headers=headers,
data=json.dumps(folder_payload, ensure_ascii=False).encode('utf-8'),
timeout=30
)
print(f" Response Status: {response.status_code}")
print(f" Response Body: {response.text[:500]}")
if response.status_code in [200, 201]:
result = response.json()
auth_folder_id = result.get('data', {}).get('id')
if auth_folder_id:
print(f" [SUCCESS] Auth folder created! ID: {auth_folder_id}")
else:
print(f" [WARNING] Folder created but no ID returned")
auth_folder_id = None
else:
print(f" [FAILED] Could not create folder")
auth_folder_id = None
except Exception as e:
print(f" [ERROR] {str(e)}")
auth_folder_id = None
# Step 2: Get current APIs
print("\n[Step 2] Getting current APIs...")
apis_to_move = []
try:
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers
)
if response.status_code == 200:
result = response.json()
all_apis = result.get('data', [])
# Filter APIs in parent folder
apis_to_move = [
api for api in all_apis
if str(api.get('folderId')) == str(PARENT_FOLDER_ID)
and '/v2/store/auth/' in api.get('path', '')
]
print(f" [OK] Found {len(apis_to_move)} APIs to move")
for api in apis_to_move:
print(f" - {api['method'].upper()} {api['name']}")
except Exception as e:
print(f" [ERROR] {str(e)}")
# Step 3: Move APIs to Auth folder
if auth_folder_id and apis_to_move:
print(f"\n[Step 3] Moving APIs to Auth folder (ID: {auth_folder_id})...")
for api in apis_to_move:
api_id = api['id']
api_name = api['name']
update_payload = {
"folderId": auth_folder_id
}
try:
response = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
data=json.dumps(update_payload).encode('utf-8')
)
if response.status_code == 200:
print(f" [OK] Moved: {api_name}")
else:
print(f" [FAIL] {api_name}: {response.status_code} - {response.text[:200]}")
except Exception as e:
print(f" [ERROR] {api_name}: {str(e)}")
else:
print("\n[Step 3] Skipped - No folder ID or no APIs to move")
print("\n" + "=" * 80)
print("[DONE] Complete!")
print("=" * 80)

120
application/store/config/route.php
View File

@@ -1,49 +1,91 @@
<?php <?php
// store模块路由配置 /**
* Store模块路由配置 - V2版本
* 公开接口: /v2/store/auth/*
* 认证接口: /v2/store/* (需要JWT)
*/
use think\facade\Route; use think\facade\Route;
// 定义RESTful风格的API路由 // ==================== 公开路由（无需登录） ====================
Route::group('v1/store', function () {
// 流量套餐相关路由 // 认证模块
Route::group('flow-packages', function () { Route::group('v2/store/auth', function () {
Route::get('', 'app\store\controller\FlowPackageController@getList'); // 获取流量套餐列表 Route::get('login', 'app\store\controller\AuthController@noPasswordLogin'); // 免密登录
Route::get('remaining-flow', 'app\store\controller\FlowPackageController@remainingFlow'); // 获取用户剩余流量 Route::post('login', 'app\store\controller\AuthController@passwordLogin'); // 账号密码登录
Route::get(':id', 'app\store\controller\FlowPackageController@detail'); // 获取流量套餐详情 Route::post('send-code', 'app\store\controller\AuthController@sendVerificationCode'); // 发送验证码
Route::post('order', 'app\store\controller\FlowPackageController@createOrder'); // 创建流量采购订单 Route::post('mobile-login', 'app\store\controller\AuthController@mobileLogin'); // 手机验证码登录
});
// ==================== 需要登录的路由 ====================
Route::group('v2/store', function () {
// Agent功能模块
Route::group('agent', function () {
Route::get('modules', 'app\store\controller\AgentController@getModules'); // 获取Agent模块列表
Route::put('modules/:moduleCode/status', 'app\store\controller\AgentController@updateModuleStatus'); // 更新模块状态
}); });
// 流量订单相关路由 // 流量采购模块（流量套餐）
Route::group('flow-orders', function () { Route::group('flow-packages', function () {
Route::get('list', 'app\store\controller\FlowPackageController@getOrderList'); // 获取订单列表 Route::get('', 'app\store\controller\FlowPackageController@getList'); // 获取流量套餐列表
Route::get(':orderNo', 'app\store\controller\FlowPackageController@getOrderDetail'); // 获取订单详情 Route::get('remaining-flow', 'app\store\controller\FlowPackageController@remainingFlow'); // 获取剩余流量
Route::get('orders', 'app\store\controller\FlowPackageController@getOrderList'); // 获取订单列表
Route::post('order', 'app\store\controller\FlowPackageController@createOrder'); // 创建流量采购订单
Route::get(':id', 'app\store\controller\FlowPackageController@detail'); // 获取流量套餐详情（必须放在最后）
}); });
// 客户相关路由 // 供应链采购模块
Route::group('customers', function () {
Route::get('list', 'app\store\controller\CustomerController@getList'); // 获取客户列表
});
// 系统配置相关路由
Route::group('system-config', function () {
Route::get('switch-status', 'app\store\controller\SystemConfigController@getSwitchStatus'); // 获取系统开关状态
Route::post('update-switch-status', 'app\store\controller\SystemConfigController@updateSwitchStatus'); // 更新系统开关状态
});
// 数据统计相关路由
Route::group('statistics', function () {
Route::get('overview', 'app\store\controller\StatisticsController@getOverview'); // 获取数据概览
Route::get('comprehensive-analysis', 'app\store\controller\StatisticsController@getComprehensiveAnalysis'); // 获取综合分析数据
});
// 供应商相关路由
Route::group('vendor', function () { Route::group('vendor', function () {
Route::get('list', 'app\store\controller\VendorController@getList'); // 获取供应商列表 Route::get('list', 'app\store\controller\VendorController@getList'); // 获取供应商套餐列表
Route::get('detail', 'app\store\controller\VendorController@detail'); // 获取供应商详情 Route::get('detail', 'app\store\controller\VendorController@detail'); // 获取供应商套餐详情
Route::post('order', 'app\store\controller\VendorController@createOrder'); // 创建订单 Route::post('order', 'app\store\controller\VendorController@createOrder'); // 创建供应商订单
Route::get('orders', 'app\store\controller\VendorOrderController@getList'); // 获取订单列表
Route::get('orders/:id', 'app\store\controller\VendorOrderController@detail'); // 获取订单详情
Route::post('orders/:id/cancel', 'app\store\controller\VendorOrderController@cancel'); // 取消订单
}); });
// 用户模块
Route::group('user', function () {
Route::get('profile', 'app\store\controller\UserController@getProfile'); // 获取用户信息（包含算力）
Route::put('profile', 'app\store\controller\UserController@updateProfile'); // 更新用户信息（头像、昵称、密码）
Route::get('api-key', 'app\store\controller\UserController@getApiKey'); // 获取对外 API Key（无则自动生成）
Route::post('api-key/regenerate', 'app\store\controller\UserController@regenerateApiKey'); // 重新生成对外 API Key
});
// 算力中心模块
Route::group('tokens', function () {
Route::get('packages', 'app\store\controller\TokensController@getList'); // 获取算力套餐列表
Route::post('pay', 'app\store\controller\TokensController@pay'); // 购买算力
Route::get('order', 'app\store\controller\TokensController@queryOrder'); // 查询订单状态
Route::get('orders', 'app\store\controller\TokensController@getOrderList'); // 获取订单列表
Route::get('statistics', 'app\store\controller\TokensController@getTokensStatistics'); // 获取算力统计
});
// 设备和微信模块
Route::group('device-wechat', function () {
Route::get('info', 'app\store\controller\DeviceWechatController@getInfo'); // 获取设备和微信信息
Route::get('dynamic-records', 'app\store\controller\DeviceWechatController@getDynamicRecords'); // 获取动态记录（分页）
});
// 客户管理模块
Route::group('customers', function () {
Route::get('', 'app\store\controller\CustomerController@getList'); // 获取客户列表
Route::get(':id', 'app\store\controller\CustomerController@detail'); // 获取客户详情
Route::put(':id', 'app\store\controller\CustomerController@update'); // 更新客户信息
});
// 设备模块（待开发）
// Route::group('device', function () {
// Route::get('list', 'DeviceController@getList'); // 获取设备列表
// Route::get(':id', 'DeviceController@getDetail'); // 获取设备详情
// });
// 数据统计（待开发）
// Route::group('data', function () {
// Route::get('overview', 'DataController@getOverview'); // 数据概览
// Route::get('stats', 'DataController@getStats'); // 统计数据
// });
})->middleware(['jwt']); })->middleware(['jwt']);
Route::get('v1/store/login', 'app\store\controller\LoginController@index');

252
application/store/controller/AgentController.php Normal file
View File

@@ -0,0 +1,252 @@
<?php
namespace app\store\controller;
use think\Db;
use think\facade\Log;
/**
* Agent功能模块控制器 - V2版本
*/
class AgentController extends BaseController
{
/**
* 获取Agent模块列表
* @return \think\response\Json
*/
public function getModules()
{
try {
// 从BaseController获取设备ID（通过userInfo自动获取）
$deviceId = $this->device['id'] ?? 0;
if (!$deviceId) {
return json(['code' => 400, 'msg' => '设备不存在，请先绑定设备']);
}
// 获取所有可用的模块定义
$modules = $this->getModuleDefinitions();
// 从旧表获取配置
$taskConfig = Db::name('device_taskconf')
->where('deviceId', $deviceId)
->where('deleteTime', 0)
->find();
// 如果没有配置，返回默认关闭状态
if (!$taskConfig) {
$taskConfig = [
'autoLike' => 0,
'momentsSync' => 0,
'autoCustomerDev' => 0,
'groupMessageDeliver' => 0,
'autoGroup' => 0
];
}
// 字段映射关系
$fieldMap = [
'auto_like' => 'autoLike',
'moments_sync' => 'momentsSync',
'auto_customer_dev' => 'autoCustomerDev',
'group_message_deliver' => 'groupMessageDeliver',
'auto_group' => 'autoGroup'
];
// 组装返回数据
$result = [];
foreach ($modules as $module) {
$moduleCode = $module['code'];
$fieldName = $fieldMap[$moduleCode] ?? null;
$moduleData = array_merge($module, [
'userEnabled' => $fieldName && isset($taskConfig[$fieldName]) ? (bool)$taskConfig[$fieldName] : false
]);
$result[] = $moduleData;
}
return json([
'code' => 200,
'msg' => 'success',
'data' => $result
]);
} catch (\Exception $e) {
Log::error('获取Agent模块列表失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 更新模块状态
* @param string $moduleCode 模块代码
* @return \think\response\Json
*/
public function updateModuleStatus($moduleCode)
{
try {
// 从BaseController获取设备ID（通过userInfo自动获取）
$deviceId = $this->device['id'] ?? 0;
$isEnabled = (bool)$this->request->param('isEnabled', false);
if (!$deviceId) {
return json(['code' => 400, 'msg' => '设备不存在，请先绑定设备']);
}
// 验证模块代码是否有效
$validModules = array_column($this->getModuleDefinitions(), 'code');
if (!in_array($moduleCode, $validModules)) {
return json(['code' => 400, 'msg' => '无效的模块代码']);
}
// 字段映射关系
$fieldMap = [
'auto_like' => 'autoLike',
'moments_sync' => 'momentsSync',
'auto_customer_dev' => 'autoCustomerDev',
'group_message_deliver' => 'groupMessageDeliver',
'auto_group' => 'autoGroup'
];
$fieldName = $fieldMap[$moduleCode] ?? null;
if (!$fieldName) {
return json(['code' => 400, 'msg' => '不支持的模块']);
}
// 查询现有配置
$taskConfig = Db::name('device_taskconf')
->where('deviceId', $deviceId)
->where('deleteTime', 0)
->find();
$now = time();
if ($taskConfig) {
// 更新现有配置
Db::name('device_taskconf')
->where('id', $taskConfig['id'])
->update([
$fieldName => $isEnabled ? 1 : 0,
'updateTime' => $now
]);
// 清除设备缓存
$this->clearDeviceCache();
} else {
// 创建新配置
$insertData = [
'deviceId' => $deviceId,
'autoLike' => 0,
'momentsSync' => 0,
'autoCustomerDev' => 0,
'groupMessageDeliver' => 0,
'autoGroup' => 0,
'companyId' => $this->device['companyId'] ?? $this->userInfo['companyId'] ?? 0,
'createTime' => $now,
'updateTime' => $now
];
$insertData[$fieldName] = $isEnabled ? 1 : 0;
Db::name('device_taskconf')->insert($insertData);
// 清除设备缓存
$this->clearDeviceCache();
}
return json([
'code' => 200,
'msg' => '操作成功',
'data' => [
'moduleCode' => $moduleCode,
'isEnabled' => $isEnabled
]
]);
} catch (\Exception $e) {
Log::error('更新模块状态失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
}
/**
* 获取模块定义
* @return array
*/
protected function getModuleDefinitions()
{
return [
[
'code' => 'auto_like',
'name' => '自动点赞',
'icon' => 'icon-dianzan',
'color' => '#ff6699',
'description' => '自动为好友朋友圈点赞',
'category' => 'social',
'sort' => 1,
'isEnabled' => true,
'needAuth' => true
],
[
'code' => 'moments_sync',
'name' => '朋友圈同步',
'icon' => 'icon-tupian',
'color' => '#9966ff',
'description' => '同步好友朋友圈内容',
'category' => 'social',
'sort' => 2,
'isEnabled' => true,
'needAuth' => true
],
[
'code' => 'auto_customer_dev',
'name' => '自动开发客户',
'icon' => 'icon-yonghu',
'color' => '#33cc99',
'description' => '自动化客户开发流程',
'category' => 'customer',
'sort' => 3,
'isEnabled' => true,
'needAuth' => true
],
[
'code' => 'group_message_deliver',
'name' => '群消息群发',
'icon' => 'icon-xiaoxi',
'color' => '#ff9966',
'description' => '批量推送消息到微信群',
'category' => 'message',
'sort' => 4,
'isEnabled' => true,
'needAuth' => false
],
[
'code' => 'auto_group',
'name' => '自动建群',
'icon' => 'icon-yonghuqun',
'color' => '#6699ff',
'description' => '自动创建和管理微信群',
'category' => 'group',
'sort' => 5,
'isEnabled' => true,
'needAuth' => true
],
[
'code' => 'video_distribute',
'name' => '视频分发',
'icon' => 'icon-video',
'color' => '#ff66cc',
'description' => '自动分发视频内容',
'category' => 'content',
'sort' => 6,
'isEnabled' => false,
'needAuth' => false
]
];
}
}

412
application/store/controller/AuthController.php Normal file
View File

@@ -0,0 +1,412 @@
<?php
namespace app\store\controller;
use think\Controller;
use think\Db;
use app\store\service\SmsService;
use app\common\util\JwtUtil;
use app\common\service\UserApiKeyService;
/**
* Store模块 - 认证控制器
* Class AuthController
* @package app\store\controller
*/
class AuthController extends Controller
{
/**
* 账号密码登录
* @return \think\response\Json
*/
public function passwordLogin()
{
// 获取参数
$account = trim($this->request->param('account', ''));
$password = trim($this->request->param('password', ''));
$typeId = (int)$this->request->param('typeId', 2); // 类型ID，默认为2
$deviceId = trim($this->request->param('deviceId', '')); // 设备ID（可选，仅APP端传递）
// 验证必填参数
if (empty($account) || empty($password)) {
return json(['code' => 400, 'msg' => '账号和密码不能为空']);
}
try {
// 查找账号（门店端使用 ck_users 表，typeId=2）
$accountInfo = Db::name('users')
->where(function($query) use ($account) {
$query->where('account', $account)
->whereOr('phone', $account);
})
->where('typeId', 2) // 门店端固定为2
->where('deleteTime', 0)
->find();
if (empty($accountInfo)) {
return json(['code' => 404, 'msg' => '账号不存在']);
}
// 验证密码（支持MD5和本地加密密码）
$passwordMd5 = md5($password);
$passwordMatch = false;
if (!empty($accountInfo['passwordMd5']) && $accountInfo['passwordMd5'] === $passwordMd5) {
$passwordMatch = true;
} elseif (!empty($accountInfo['passwordLocal'])) {
// 验证本地加密密码（需要localDecrypt函数）
if (function_exists('localDecrypt')) {
$decryptedPassword = localDecrypt($accountInfo['passwordLocal']);
if ($decryptedPassword === $password) {
$passwordMatch = true;
}
}
}
if (!$passwordMatch) {
return json(['code' => 401, 'msg' => '密码错误']);
}
// 如果传了设备ID（APP端），验证设备是否存在
if (!empty($deviceId)) {
$device = Db::name('device')
->where('deviceImei', $deviceId)
->where('companyId', $accountInfo['companyId'])
->where('deleteTime', 0)
->find();
if (empty($device)) {
return json(['code' => 404, 'msg' => '设备不存在或与账号不匹配']);
}
}
// 生成JWT令牌（与旧版一致）
$token = JwtUtil::createToken($accountInfo, 86400 * 30); // 30天过期
$tokenExpired = time() + 86400 * 30;
// 更新账号最后登录信息（ck_users表没有lastLoginTime和lastLoginIp字段，只更新密码和updateTime）
Db::name('users')
->where('id', $accountInfo['id'])
->update([
'passwordMd5' => $passwordMd5,
'updateTime' => time()
]);
// 准备返回的会员信息
$memberInfo = [
'id' => $accountInfo['id'],
'account' => $accountInfo['account'] ?? '',
'username' => $accountInfo['username'] ?? '',
'phone' => $accountInfo['phone'] ?? '',
'avatar' => $accountInfo['avatar'] ?? '',
'companyId' => $accountInfo['companyId'] ?? 0,
'typeId' => $accountInfo['typeId'] ?? 2,
];
// 记录登录日志
$this->recordLoginLog($accountInfo['id'], $deviceId, '账号密码登录成功');
return json([
'code' => 200,
'msg' => '登录成功',
'data' => [
'token' => $token,
'token_expired' => $tokenExpired,
'member' => $memberInfo
]
]);
} catch (\Exception $e) {
// 记录错误日志
$this->recordLoginLog(0, $deviceId, '账号密码登录失败：' . $e->getMessage());
return json([
'code' => 500,
'msg' => '登录失败：' . $e->getMessage()
]);
}
}
/**
* 免密登录（基于设备ID）
* @return \think\response\Json
*/
public function noPasswordLogin()
{
// 获取设备ID
$deviceId = trim($this->request->param('deviceId', ''));
if (empty($deviceId)) {
return json(['code' => 400, 'msg' => '设备ID不能为空']);
}
try {
// 根据设备IMEI查找设备信息
$device = Db::name('device')
->where('deviceImei', $deviceId)
->where('deleteTime', 0)
->find();
if (empty($device)) {
return json(['code' => 404, 'msg' => '设备不存在或已被删除']);
}
// 检查设备是否在线
if ($device['alive'] != 1) {
return json(['code' => 403, 'msg' => '设备未在线，请确保设备已连接']);
}
// 获取设备关联的公司ID
$companyId = $device['companyId'];
// 查找公司账号信息（通过device_user关联查找用户）
// 门店端使用 ck_users 表，通过 device_user 关联
$account = Db::name('users')->alias('u')
->join('device_user du', 'u.id = du.userId AND u.companyId = du.companyId')
->where([
'du.deviceId' => $device['id'],
'u.companyId' => $companyId,
'u.typeId' => 2, // 门店端固定为2
'u.deleteTime' => 0,
'du.deleteTime' => 0
])
->field('u.*')
->find();
if (empty($account)) {
return json(['code' => 404, 'msg' => '未找到关联的账号信息，请先绑定设备']);
}
// 生成JWT令牌（与旧版一致）
$token = JwtUtil::createToken($account, 86400 * 30); // 30天过期
$tokenExpired = time() + 86400 * 30;
// 更新账号最后登录信息（ck_users表没有lastLoginTime和lastLoginIp字段）
Db::name('users')
->where('id', $account['id'])
->update([
'updateTime' => time()
]);
// 准备返回的会员信息
$memberInfo = [
'id' => $account['id'],
'account' => $account['account'] ?? '',
'username' => $account['username'] ?? '',
'phone' => $account['phone'] ?? '',
'avatar' => $account['avatar'] ?? '',
'companyId' => $companyId,
'typeId' => $account['typeId'] ?? 2,
];
// 记录登录日志
$this->recordLoginLog($account['id'], $deviceId, '免密登录成功');
return json([
'code' => 200,
'msg' => '登录成功',
'data' => [
'token' => $token,
'token_expired' => $tokenExpired,
'member' => $memberInfo
]
]);
} catch (\Exception $e) {
// 记录错误日志
$this->recordLoginLog(0, $deviceId, '免密登录失败：' . $e->getMessage());
return json([
'code' => 500,
'msg' => '登录失败：' . $e->getMessage()
]);
}
}
/**
* 发送短信验证码
* @return \think\response\Json
*/
public function sendVerificationCode()
{
// 获取参数
$mobile = trim($this->request->param('mobile', ''));
$type = trim($this->request->param('type', 'login')); // login/register/reset
// 验证必填参数
if (empty($mobile)) {
return json(['code' => 400, 'msg' => '手机号不能为空']);
}
try {
$smsService = new SmsService();
$result = $smsService->sendVerificationCode($mobile, $type);
if ($result['success']) {
return json([
'code' => 200,
'msg' => $result['message'],
'data' => $result['data'] ?? []
]);
} else {
return json([
'code' => 400,
'msg' => $result['message']
]);
}
} catch (\Exception $e) {
return json([
'code' => 500,
'msg' => '发送失败：' . $e->getMessage()
]);
}
}
/**
* 手机号验证码登录
* @return \think\response\Json
*/
public function mobileLogin()
{
// 获取参数
$mobile = trim($this->request->param('mobile', ''));
$code = trim($this->request->param('code', ''));
$isEncrypted = $this->request->param('is_encrypted', false);
// 验证必填参数
if (empty($mobile) || empty($code)) {
return json(['code' => 400, 'msg' => '手机号和验证码不能为空']);
}
try {
// 1. 验证短信验证码
$smsService = new SmsService();
$verifyResult = $smsService->verifyCode($mobile, $code, 'login');
if (!$verifyResult['success']) {
return json(['code' => 400, 'msg' => $verifyResult['message']]);
}
// 2. 查找或创建账号（根据手机号）
// 门店端使用 ck_users 表，typeId=2
$account = Db::name('users')
->where('phone', $mobile)
->where('typeId', 2) // 门店端固定为2
->where('deleteTime', 0)
->find();
// 如果账号不存在，自动创建（新用户注册）
if (empty($account)) {
// 注意：新用户注册需要companyId，这里暂时设为0，实际应该从设备或其他地方获取
$accountId = Db::name('users')->insertGetId([
'account' => $mobile, // 使用手机号作为账号
'username' => '用户' . substr($mobile, -4), // 默认昵称
'phone' => $mobile,
'passwordMd5' => '', // 手机验证码登录不需要密码
'avatar' => 'https://img.icons8.com/color/512/circled-user-male-skin-type-7.png',
'isAdmin' => 0,
'companyId' => 0, // 新用户默认companyId为0，后续需要绑定设备或公司
'typeId' => 2, // 门店端固定为2
'status' => 1, // 默认可用
'balance' => 0,
'tokens' => 0,
'createTime' => time(),
'updateTime' => time(),
'deleteTime' => 0
]);
// 重新查询账号信息
$account = Db::name('users')->where('id', $accountId)->find();
// 新用户自动生成对外 API Key
try {
UserApiKeyService::bindOrGet((int)$accountId);
} catch (\Exception $e) {
\think\facade\Log::error('新用户自动生成 apiKey 失败：' . $e->getMessage());
}
// 记录注册日志
$this->recordLoginLog($accountId, '', '手机验证码注册成功');
}
// 3. 生成JWT令牌（与旧版一致）
$token = JwtUtil::createToken($account, 86400 * 30); // 30天过期
$tokenExpired = time() + 86400 * 30;
// 4. 更新账号最后登录信息（ck_users表没有lastLoginTime和lastLoginIp字段）
Db::name('users')
->where('id', $account['id'])
->update([
'updateTime' => time()
]);
// 5. 准备返回的用户信息
$userInfo = [
'id' => $account['id'],
'account' => $account['account'] ?? '',
'username' => $account['username'] ?? '',
'phone' => $mobile,
'avatar' => $account['avatar'] ?? '',
'companyId' => $account['companyId'] ?? 0,
'typeId' => $account['typeId'] ?? 2,
];
// 记录登录日志
$this->recordLoginLog($account['id'], '', '手机验证码登录成功');
return json([
'code' => 200,
'msg' => '登录成功',
'data' => [
'token' => $token,
'token_expired' => $tokenExpired,
'userInfo' => $userInfo
]
]);
} catch (\Exception $e) {
// 记录错误日志
$this->recordLoginLog(0, '', '手机验证码登录失败：' . $e->getMessage());
return json([
'code' => 500,
'msg' => '登录失败：' . $e->getMessage()
]);
}
}
/**
* 记录登录日志
* @param int $accountId 账号ID
* @param string $deviceId 设备ID
* @param string $message 日志信息
*/
private function recordLoginLog($accountId, $deviceId, $message)
{
try {
// 使用ThinkPHP的日志记录功能，避免表不存在的问题
\think\facade\Log::info('Store登录日志', [
'accountId' => $accountId,
'deviceId' => $deviceId,
'action' => 'STORE_LOGIN',
'message' => $message,
'ip' => $this->request->ip(),
'time' => date('Y-m-d H:i:s')
]);
// 如果存在operation_log表，也可以记录到数据库
// Db::name('operation_log')->insert([
// 'accountId' => $accountId,
// 'deviceId' => $deviceId,
// 'action' => 'STORE_LOGIN',
// 'message' => $message,
// 'ip' => $this->request->ip(),
// 'createTime' => time()
// ]);
} catch (\Exception $e) {
// 日志记录失败不影响主流程
\think\facade\Log::error('登录日志记录失败：' . $e->getMessage());
}
}
}

71
application/store/controller/BaseController.php
View File

@@ -3,18 +3,13 @@
namespace app\store\controller; namespace app\store\controller;
use think\Controller; use think\Controller;
use think\facade\Config;
use think\facade\Request;
use think\facade\Response;
use think\facade\Log;
use app\common\controller\Api;
use think\Db; use think\Db;
use think\facade\Cache; use think\facade\Cache;
/** /**
* 基础控制器 * Store模块基础控制器 - V2版本
*/ */
class BaseController extends Api class BaseController extends Controller
{ {
protected $device = []; protected $device = [];
protected $userInfo = []; protected $userInfo = [];
@@ -26,32 +21,39 @@ class BaseController extends Api
public function __construct() public function __construct()
{ {
parent::__construct(); parent::__construct();
$this->userInfo = request()->userInfo;
// 生成缓存key
$cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId'];
// 尝试从缓存获取设备信息 // 从请求中获取用户信息（通过JWT中间件设置）
$device = Cache::get($cacheKey); $this->userInfo = $this->request->userInfo ?? [];
// 如果缓存不存在，则从数据库获取
if (!$device) { // 如果用户信息存在，获取设备信息
$device = Db::name('device_user') if (!empty($this->userInfo['id']) && !empty($this->userInfo['companyId'])) {
->alias('du') // 生成缓存key
->join('device d', 'd.id = du.deviceId','left') $cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId'];
->join('device_wechat_login dwl', 'dwl.deviceId = du.deviceId','left')
->join('wechat_account wa', 'dwl.wechatId = wa.wechatId','left') // 尝试从缓存获取设备信息
->where([ $device = Cache::get($cacheKey);
'du.userId' => $this->userInfo['id'],
'du.companyId' => $this->userInfo['companyId'] // 如果缓存不存在，则从数据库获取
]) if (!$device) {
->field('d.*,wa.wechatId,wa.alias,wa.s2_wechatAccountId as wechatAccountId') $device = Db::name('device_user')
->find(); ->alias('du')
// 将设备信息存入缓存 ->join('device d', 'd.id = du.deviceId', 'left')
if ($device) { ->join('device_wechat_login dwl', 'dwl.deviceId = du.deviceId', 'left')
Cache::set($cacheKey, $device, $this->cacheExpire); ->join('wechat_account wa', 'dwl.wechatId = wa.wechatId', 'left')
->where([
'du.userId' => $this->userInfo['id'],
'du.companyId' => $this->userInfo['companyId']
])
->field('d.*,wa.wechatId,wa.alias,wa.s2_wechatAccountId as wechatAccountId')
->find();
// 将设备信息存入缓存
if ($device) {
Cache::set($cacheKey, $device, $this->cacheExpire);
}
} }
$this->device = $device ?: [];
} }
$this->device = $device;
} }
/** /**
@@ -59,7 +61,10 @@ class BaseController extends Api
*/ */
protected function clearDeviceCache() protected function clearDeviceCache()
{ {
$cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId']; if (!empty($this->userInfo['id']) && !empty($this->userInfo['companyId'])) {
Cache::rm($cacheKey); $cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId'];
Cache::rm($cacheKey);
}
} }
} }

935
application/store/controller/CustomerController.php
View File

@@ -2,92 +2,879 @@
namespace app\store\controller; namespace app\store\controller;
use app\common\controller\Api; use app\common\model\TrafficPoolCompany;
use think\Db; use think\Db;
use think\facade\Log;
/** /**
* 客户管理控制器 * 客户管理控制器
*/ */
class CustomerController extends Api class CustomerController extends BaseController
{ {
protected $noNeedLogin = [];
protected $noNeedRight = ['*'];
/** /**
* 获取客户列表 * 获取客户列表
* GET /v2/store/customers
* *
* @return \think\Response * @return \think\response\Json
*/ */
public function getList() public function getList()
{ {
$params = $this->request->param(); try {
$userId = $this->userInfo['id'] ?? 0;
// 获取分页参数 $companyId = $this->userInfo['companyId'] ?? 0;
$page = isset($params['page']) ? intval($params['page']) : 1;
$pageSize = isset($params['pageSize']) ? intval($params['pageSize']) : 10;
$userInfo = request()->userInfo;
$where = [];
// 必要的查询条件
$userId = $userInfo['id'];
$companyId = $userInfo['companyId'];
if (empty($userId) || empty($companyId)) {
return errorJson('缺少必要参数');
}
// 构建查询条件
$deviceIds = Db::name('device_user')->where(['userId' => $userId, 'companyId' => $companyId])->order('id DESC')->column('deviceId');
if (empty($deviceIds)) {
return errorJson('设备不存在');
}
$wechatIds = [];
foreach ($deviceIds as $deviceId) {
$wechatIds[] = Db::name('device_wechat_login')
->where(['deviceId' => $deviceId])
->order('id DESC')
->value('wechatId');
}
// 搜索条件
if (!empty($params['keyword'])) {
$where['alias|nickname|wechatId'] = ['like', '%' . $params['keyword'] . '%'];
}
// if (!empty($params['email'])) {
// $where['wa.bindEmail'] = ['like', '%' . $params['email'] . '%'];
// }
// if (!empty($params['name'])) {
// $where['wa.accountRealName|wa.accountUserName|wa.nickname'] = ['like', '%' . $params['name'] . '%'];
// }
// 构建查询
$query = Db::table('s2_wechat_friend')
->where($where)
->whereIn('ownerWechatId',$wechatIds)
->group('wechatId'); // 防止重复数据
// 克隆查询对象，用于计算总数 if (empty($userId) || empty($companyId)) {
$countQuery = clone $query; return json(['code' => 401, 'msg' => '请先登录']);
$total = $countQuery->count(); }
// 获取分页数据 // 获取设备信息
$list = $query->page($page, $pageSize) $device = $this->device;
->order('id DESC') if (empty($device) || empty($device['wechatId'])) {
->select(); return json(['code' => 404, 'msg' => '设备未绑定微信']);
}
// 格式化数据 $wechatId = $device['wechatId'];
foreach ($list as &$item) {
$item['labels'] = json_decode($item['labels'], true); // 获取微信账号ID
$item['createTime'] = date('Y-m-d H:i:s', $item['createTime']); $wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id')
->find();
if (empty($wechatAccount)) {
return json(['code' => 404, 'msg' => '微信账号不存在']);
}
$accountId = $wechatAccount['id'];
// 分页参数
$page = intval($this->request->param('page', 1));
$limit = intval($this->request->param('limit', 10));
$pageSize = intval($this->request->param('pageSize', 10));
if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = $pageSize > 0 ? $pageSize : 10;
if ($limit > 100) $limit = 100;
// 搜索关键词
$keyword = $this->request->param('keyword', '');
// 筛选条件
$status = $this->request->param('status', ''); // 状态：潜在、活跃、沉默、流失
$value = $this->request->param('value', ''); // 价值：高、中、低
$lifecycle = $this->request->param('lifecycle', ''); // 生命周期
// 构建查询条件
// 从流量池公司表查询，关联流量池总表和微信好友表
// 注意：s2_wechat_friend 表没有 ck_ 前缀，使用数组形式 join 可以避免自动添加前缀
$query = Db::name('traffic_pool_company')
->alias('tpc')
->join('traffic_pool tp', 'tp.id = tpc.poolId', 'left')
->join(['s2_wechat_friend' => 'wf'], 'wf.wechatId = tp.wechatId AND wf.ownerWechatId = \'' . $wechatId . '\'', 'left')
->where([
['tpc.companyId', '=', $companyId],
['tpc.ownerAccountId', '=', $accountId], // 归属当前微信账号
['tpc.status', '=', TrafficPoolCompany::STATUS_NORMAL], // 正常状态
]);
// 关键词搜索（昵称、微信号、手机号）
if (!empty($keyword)) {
$query->where(function($query) use ($keyword) {
$query->where('tp.nickname', 'like', '%' . $keyword . '%')
->whereOr('tp.wechatAlias', 'like', '%' . $keyword . '%')
->whereOr('tp.mobile', 'like', '%' . $keyword . '%')
->whereOr('tpc.realName', 'like', '%' . $keyword . '%')
->whereOr('tpc.phone', 'like', '%' . $keyword . '%');
});
}
// 状态筛选（根据生命周期）
if (!empty($lifecycle)) {
$lifecycleMap = [
'潜在' => TrafficPoolCompany::LIFECYCLE_NEW,
'活跃' => TrafficPoolCompany::LIFECYCLE_FOLLOWING,
'沉默' => TrafficPoolCompany::LIFECYCLE_SILENT,
'流失' => TrafficPoolCompany::LIFECYCLE_LOST,
];
if (isset($lifecycleMap[$lifecycle])) {
$query->where('tpc.lifecycle', '=', $lifecycleMap[$lifecycle]);
}
}
// 价值筛选（根据意向度或等级）
if (!empty($value)) {
$valueMap = [
'高' => TrafficPoolCompany::INTENTION_HIGH,
'中' => TrafficPoolCompany::INTENTION_MEDIUM,
'低' => TrafficPoolCompany::INTENTION_LOW,
];
if (isset($valueMap[$value])) {
$query->where('tpc.intentionLevel', '=', $valueMap[$value]);
}
}
// 统计总数
$total = $query->count();
// 获取列表数据
$list = $query->field('tpc.id,tpc.poolId,tpc.companyId,tpc.ownerAccountId,tpc.realName,tpc.phone,tpc.email,tpc.lifecycle,tpc.intentionLevel,tpc.level,tpc.remark,tpc.createTime,tp.nickname,tp.avatar,tp.wechatId,tp.wechatAlias,tp.mobile,tp.gender,tp.region,tp.signature,wf.id as friendId,wf.alias as friendAlias,wf.nickname as friendNickname')
->order('tpc.id desc')
->page($page, $limit)
->select();
// 格式化数据
$result = [];
foreach ($list as $item) {
// 获取标签
$tags = Db::name('traffic_pool_tag')
->where([
['poolCompanyId', '=', $item['id']],
['isDel', '=', 0]
])
->column('tagName');
// 获取最后互动时间（从行为记录表）
$lastBehavior = Db::name('traffic_pool_behavior')
->where('poolCompanyId', $item['id'])
->order('behaviorTime desc')
->find();
$lastContact = '';
if (!empty($lastBehavior) && !empty($lastBehavior['behaviorTime'])) {
$lastContact = date('Y-m-d H:i:s', intval($lastBehavior['behaviorTime']));
}
// 获取价值评估（从RFM或估值相关表，这里先使用模拟数据）
$valuation = $this->calculateCustomerValuation($item['id']);
// 状态映射
$lifecycleMap = [
TrafficPoolCompany::LIFECYCLE_NEW => '潜在',
TrafficPoolCompany::LIFECYCLE_FOLLOWING => '活跃',
TrafficPoolCompany::LIFECYCLE_CONVERTED => '已成交',
TrafficPoolCompany::LIFECYCLE_SILENT => '沉默',
TrafficPoolCompany::LIFECYCLE_LOST => '流失',
];
// 价值映射
$intentionMap = [
TrafficPoolCompany::INTENTION_HIGH => '高',
TrafficPoolCompany::INTENTION_MEDIUM => '中',
TrafficPoolCompany::INTENTION_LOW => '低',
TrafficPoolCompany::INTENTION_UNKNOWN => '低',
];
$result[] = [
'id' => intval($item['id']),
'poolCompanyId' => intval($item['id']),
'name' => $item['realName'] ?? $item['nickname'] ?? '未知',
'nickname' => $item['nickname'] ?? '',
'wechatId' => $item['wechatAlias'] ?? $item['wechatId'] ?? '',
'avatar' => $item['avatar'] ?? '',
'phone' => $item['phone'] ?? $item['mobile'] ?? '',
'email' => $item['email'] ?? '',
'status' => $lifecycleMap[$item['lifecycle'] ?? TrafficPoolCompany::LIFECYCLE_NEW] ?? '潜在',
'value' => $intentionMap[$item['intentionLevel'] ?? TrafficPoolCompany::INTENTION_UNKNOWN] ?? '低',
'tags' => $tags ?: [],
'lastContact' => $lastContact,
'nextFollow' => !empty($item['nextFollowTime']) && is_numeric($item['nextFollowTime'])
? date('Y-m-d', intval($item['nextFollowTime']))
: '',
'notes' => $item['remark'] ?? '',
'addedDate' => !empty($item['createTime']) && is_numeric($item['createTime'])
? date('Y-m-d', intval($item['createTime']))
: '',
'valuation' => $valuation,
];
}
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $result,
'total' => $total,
'page' => $page,
'limit' => $limit
]
]);
} catch (\Exception $e) {
Log::error('获取客户列表失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
unset($item);
return successJson([
'list' => $list,
'total' => $total
], '获取成功');
} }
}
/**
* 获取客户详情
* GET /v2/store/customers/:id
*
* @return \think\response\Json
*/
public function detail()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId) || empty($companyId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取设备信息
$device = $this->device;
if (empty($device) || empty($device['wechatId'])) {
return json(['code' => 404, 'msg' => '设备未绑定微信']);
}
$wechatId = $device['wechatId'];
// 获取微信账号ID
$wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id')
->find();
if (empty($wechatAccount)) {
return json(['code' => 404, 'msg' => '微信账号不存在']);
}
$accountId = $wechatAccount['id'];
// 获取客户ID
$customerId = intval($this->request->param('id', 0));
if (empty($customerId)) {
return json(['code' => 400, 'msg' => '客户ID不能为空']);
}
// 查询客户详情
// 注意：s2_wechat_friend 表没有 ck_ 前缀，使用数组形式 join 可以避免自动添加前缀
$customer = Db::name('traffic_pool_company')
->alias('tpc')
->join('traffic_pool tp', 'tp.id = tpc.poolId', 'left')
->join(['s2_wechat_friend' => 'wf'], 'wf.wechatId = tp.wechatId AND wf.ownerWechatId = \'' . $wechatId . '\'', 'left')
->where([
['tpc.id', '=', $customerId],
['tpc.companyId', '=', $companyId],
['tpc.ownerAccountId', '=', $accountId],
])
->field('tpc.*,tp.*,wf.id as friendId,wf.alias as friendAlias,wf.nickname as friendNickname')
->find();
if (empty($customer)) {
return json(['code' => 404, 'msg' => '客户不存在']);
}
// 获取标签
$tags = Db::name('traffic_pool_tag')
->where([
['poolCompanyId', '=', $customerId],
['isDel', '=', 0]
])
->column('tagName');
// 获取流量池标签（系统标签或微信标签）
// 注意：从表结构看，isSystem字段在tagDefineId关联的标签定义表中
// 这里先获取所有标签，后续可以根据tagType区分
$allTags = Db::name('traffic_pool_tag')
->alias('tpt')
->join('traffic_pool_tag_define tptd', 'tpt.tagDefineId = tptd.id', 'left')
->where([
['tpt.poolCompanyId', '=', $customerId],
['tpt.isDel', '=', 0]
])
->field('tpt.tagName,tptd.isSystem')
->select();
$trafficPoolTags = [];
foreach ($allTags as $tag) {
// 系统标签或微信标签（tagType=1）作为流量池标签
if (!empty($tag['isSystem']) || (!empty($tag['tagType']) && $tag['tagType'] == 1)) {
$trafficPoolTags[] = $tag['tagName'];
}
}
// 获取来源信息
$sources = Db::name('traffic_pool_source')
->where('poolCompanyId', $customerId)
->order('createTime desc')
->select();
$sourceChannel = '未知';
$addTime = '';
if (!empty($sources)) {
$firstSource = $sources[0];
$sourceChannel = $firstSource['sourceName'] ?? '未知';
$addTime = !empty($firstSource['createTime']) && is_numeric($firstSource['createTime'])
? date('Y-m-d', intval($firstSource['createTime']))
: '';
}
// 获取互动统计
$interactionStats = $this->getInteractionStats($customerId);
// 获取价值评估
$valueEvaluation = $this->getValueEvaluation($customerId);
// 获取用户旅程（最近记录）
$journey = $this->getCustomerJourney($customerId, 10);
// 获取消费偏好（从行为记录分析）
$preferences = $this->getCustomerPreferences($customerId);
// 状态映射
$lifecycleMap = [
TrafficPoolCompany::LIFECYCLE_NEW => '潜在',
TrafficPoolCompany::LIFECYCLE_FOLLOWING => '活跃',
TrafficPoolCompany::LIFECYCLE_CONVERTED => '已成交',
TrafficPoolCompany::LIFECYCLE_SILENT => '沉默',
TrafficPoolCompany::LIFECYCLE_LOST => '流失',
];
$conversionStatus = $lifecycleMap[$customer['lifecycle'] ?? TrafficPoolCompany::LIFECYCLE_NEW] ?? '潜在';
// 生成首字母
$name = $customer['realName'] ?? $customer['nickname'] ?? '未知';
$initials = mb_substr($name, 0, 1, 'UTF-8');
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
// 基础信息
'id' => intval($customer['id']),
'poolCompanyId' => intval($customer['id']),
'initials' => $initials,
// 好友概览
'nickname' => $customer['nickname'] ?? '',
'remarkName' => $customer['realName'] ?? '',
'wechatId' => $customer['wechatAlias'] ?? $customer['wechatId'] ?? '',
'wechatPhone' => $customer['mobile'] ?? '',
'wechatLocation' => $customer['region'] ?? '',
'avatar' => $customer['avatar'] ?? '',
'conversionStatus' => $conversionStatus,
'sourceChannel' => $sourceChannel,
'addTime' => $addTime,
// 基础信息
'realName' => $customer['realName'] ?? '',
'sex' => $this->getGenderText($customer['gender'] ?? 0),
'age' => $this->calculateAge($customer['birthday'] ?? ''),
'personalPhone' => $customer['phone'] ?? '',
'email' => $customer['email'] ?? '',
'idNumber' => $this->maskIdNumber($customer['idCard'] ?? ''),
'address' => $customer['address'] ?? '',
// 标签
'tags' => $tags ?: [],
'trafficPoolTags' => $trafficPoolTags ?: [],
// 互动统计
'interactionStats' => $interactionStats,
// 价值评估
'valueEvaluation' => $valueEvaluation,
'valuationRank' => 'TOP 8%', // 需要计算
'valuationTrend' => '+12%', // 需要计算
// 用户旅程
'journey' => $journey,
// 消费偏好
'preferences' => $preferences,
// AI预测（需要实现）
'aiProfile' => [
'summary' => '该用户为典型的高净值客户，消费频率高且偏好高端产品。',
'predictions' => [
'预计未来7天内有85%概率下单',
'流失风险极低（5%），建议通过会员活动维持粘性',
'最佳触达时间：工作日12:00-14:00或周末下午'
]
],
]
]);
} catch (\Exception $e) {
Log::error('获取客户详情失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 更新客户信息
* PUT /v2/store/customers/:id
*
* @return \think\response\Json
*/
public function update()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId) || empty($companyId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取设备信息
$device = $this->device;
if (empty($device) || empty($device['wechatId'])) {
return json(['code' => 404, 'msg' => '设备未绑定微信']);
}
$wechatId = $device['wechatId'];
// 获取微信账号ID
$wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id')
->find();
if (empty($wechatAccount)) {
return json(['code' => 404, 'msg' => '微信账号不存在']);
}
$accountId = $wechatAccount['id'];
// 获取客户ID
$customerId = intval($this->request->param('id', 0));
if (empty($customerId)) {
return json(['code' => 400, 'msg' => '客户ID不能为空']);
}
// 验证客户是否存在且归属当前账号
$customer = Db::name('traffic_pool_company')
->where([
['id', '=', $customerId],
['companyId', '=', $companyId],
['ownerAccountId', '=', $accountId],
])
->find();
if (empty($customer)) {
return json(['code' => 404, 'msg' => '客户不存在']);
}
// 获取更新参数
$updateType = $this->request->param('updateType', ''); // wechat, personal, tags
$updateData = [];
$updateFields = [];
// 更新微信资料
if ($updateType === 'wechat' || $this->request->has('remarkName')) {
$remarkName = $this->request->param('remarkName', '');
if ($remarkName !== '') {
$updateData['realName'] = $remarkName; // 备注名存储在realName字段
$updateFields[] = '备注名';
}
}
// 更新基础信息
if ($updateType === 'personal') {
$realName = $this->request->param('realName', '');
$sex = $this->request->param('sex', '');
$age = $this->request->param('age', '');
$phone = $this->request->param('phone', '');
$email = $this->request->param('email', '');
$idNumber = $this->request->param('idNumber', '');
$address = $this->request->param('address', '');
if ($realName !== '') {
$updateData['realName'] = $realName;
$updateFields[] = '姓名';
}
if ($sex !== '') {
$updateData['gender'] = $sex === '男' ? 1 : ($sex === '女' ? 2 : 0);
$updateFields[] = '性别';
}
if ($age !== '') {
// 根据年龄计算生日（简化处理）
$birthYear = date('Y') - intval($age);
$updateData['birthday'] = $birthYear . '-01-01';
$updateFields[] = '年龄';
}
if ($phone !== '') {
$updateData['phone'] = $phone;
$updateFields[] = '手机号';
}
if ($email !== '') {
$updateData['email'] = $email;
$updateFields[] = '邮箱';
}
if ($idNumber !== '') {
$updateData['idCard'] = $idNumber;
$updateFields[] = '身份证号';
}
if ($address !== '') {
$updateData['address'] = $address;
$updateFields[] = '住址';
}
}
// 更新标签
if ($updateType === 'tags') {
$tags = $this->request->param('tags', []);
if (is_array($tags)) {
// 获取客户信息（用于获取identifier和companyId）
$customerInfo = Db::name('traffic_pool_company')
->where('id', $customerId)
->field('identifier,companyId')
->find();
if (!empty($customerInfo)) {
// 软删除旧标签（只删除站内标签，保留微信标签和系统标签）
// 通过关联标签定义表判断是否为站内标签
Db::name('traffic_pool_tag')
->alias('tpt')
->join('traffic_pool_tag_define tptd', 'tpt.tagDefineId = tptd.id', 'left')
->where([
['tpt.poolCompanyId', '=', $customerId],
['tptd.tagType', '=', 2], // 站内标签
['tpt.isDel', '=', 0]
])
->update([
'tpt.isDel' => 1,
'tpt.deleteTime' => time()
]);
// 添加新标签（站内标签）
foreach ($tags as $tag) {
if (!empty($tag)) {
// 查找或创建标签定义
$tagDefine = Db::name('traffic_pool_tag_define')
->where([
['companyId', 'in', [$companyId, 0]],
['tagName', '=', $tag],
['tagType', '=', 2], // 站内标签
['isDel', '=', 0]
])
->order('companyId desc') // 优先使用公司自定义标签
->find();
if (empty($tagDefine)) {
// 创建标签定义
$tagDefineId = Db::name('traffic_pool_tag_define')->insertGetId([
'companyId' => $companyId,
'tagType' => 2, // 站内标签
'tagCode' => 'custom_' . time() . '_' . rand(1000, 9999),
'tagName' => $tag,
'isSystem' => 0,
'status' => 1,
'createTime' => time(),
]);
} else {
$tagDefineId = $tagDefine['id'];
}
// 检查标签是否已存在
$existTag = Db::name('traffic_pool_tag')
->where([
['poolCompanyId', '=', $customerId],
['tagDefineId', '=', $tagDefineId],
['isDel', '=', 0]
])
->find();
if (empty($existTag)) {
Db::name('traffic_pool_tag')->insert([
'poolCompanyId' => $customerId,
'identifier' => $customerInfo['identifier'],
'companyId' => $customerInfo['companyId'],
'tagDefineId' => $tagDefineId,
'tagType' => 2, // 站内标签
'tagName' => $tag,
'source' => 1, // 手动
'operatorId' => $userId,
'createTime' => time(),
]);
}
}
}
}
$updateFields[] = '标签';
}
}
// 更新客户信息
if (!empty($updateData)) {
$updateData['updateTime'] = time();
Db::name('traffic_pool_company')
->where('id', $customerId)
->update($updateData);
}
return json([
'code' => 200,
'msg' => '更新成功',
'data' => [
'updatedFields' => $updateFields
]
]);
} catch (\Exception $e) {
Log::error('更新客户信息失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
}
/**
* 计算客户估值
*
* @param int $poolCompanyId 客户ID
* @return int
*/
private function calculateCustomerValuation($poolCompanyId)
{
// TODO: 实现真实的估值计算逻辑
// 可以从订单表、行为记录表等计算
return 50000; // 模拟数据
}
/**
* 获取互动统计
*
* @param int $poolCompanyId 客户ID
* @return array
*/
private function getInteractionStats($poolCompanyId)
{
// 统计聊天消息数
$chatCount = Db::name('traffic_pool_behavior')
->where([
['poolCompanyId', '=', $poolCompanyId],
['behaviorType', '=', 1] // 发送消息
])
->count();
// 统计朋友圈互动数
$momentsCount = Db::name('traffic_pool_behavior')
->where([
['poolCompanyId', '=', $poolCompanyId],
['behaviorType', 'in', [9, 10]] // 点赞朋友圈、评论朋友圈
])
->count();
// 统计红包转账总额（从行为记录中获取）
$redPacketTotal = Db::name('traffic_pool_behavior')
->where([
['poolCompanyId', '=', $poolCompanyId],
['behaviorType', '=', 7] // 支付
])
->sum('amount');
$redPacketTotal = round(floatval($redPacketTotal ?? 0), 2);
// 计算活跃度评分（简化计算）
$activeScore = min(100, ($chatCount * 2 + $momentsCount * 3 + $redPacketTotal / 10));
// 获取最后互动时间
$lastBehavior = Db::name('traffic_pool_behavior')
->where('poolCompanyId', $poolCompanyId)
->order('behaviorTime desc')
->find();
$lastInteraction = '从未互动';
if (!empty($lastBehavior) && !empty($lastBehavior['behaviorTime'])) {
$time = intval($lastBehavior['behaviorTime']);
$diff = time() - $time;
if ($diff < 3600) {
$lastInteraction = '刚刚';
} elseif ($diff < 86400) {
$lastInteraction = '今天 ' . date('H:i', $time);
} elseif ($diff < 172800) {
$lastInteraction = '昨天 ' . date('H:i', $time);
} else {
$lastInteraction = date('Y-m-d H:i', $time);
}
}
return [
'lastInteraction' => $lastInteraction,
'chatCount' => intval($chatCount),
'momentsCount' => intval($momentsCount),
'redPacketTotal' => number_format($redPacketTotal, 2),
'activeScore' => intval($activeScore)
];
}
/**
* 获取价值评估
*
* @param int $poolCompanyId 客户ID
* @return array
*/
private function getValueEvaluation($poolCompanyId)
{
// TODO: 实现真实的价值评估计算
// 可以从RFM模型、CLV模型、社交裂变模型等计算
return [
'totalValuation' => 58600,
'models' => [
[
'name' => 'RFM 贡献模型',
'value' => 52000,
'weight' => 0.5,
'score' => 92
],
[
'name' => 'CLV 终身价值模型',
'value' => 78000,
'weight' => 0.3,
'score' => 88
],
[
'name' => '社交/裂变模型',
'value' => 15000,
'weight' => 0.2,
'score' => 75
]
]
];
}
/**
* 获取用户旅程
*
* @param int $poolCompanyId 客户ID
* @param int $limit 限制数量
* @return array
*/
private function getCustomerJourney($poolCompanyId, $limit = 10)
{
// 从行为记录表获取
$behaviors = Db::name('traffic_pool_behavior')
->where('poolCompanyId', $poolCompanyId)
->order('behaviorTime desc')
->limit($limit)
->select();
$journey = [];
$typeMap = [
1 => '发送消息',
2 => '接收消息',
3 => '浏览',
4 => '点击',
5 => '咨询',
6 => '下单',
7 => '支付',
8 => '退款',
9 => '点赞朋友圈',
10 => '评论朋友圈',
];
foreach ($behaviors as $behavior) {
$type = $typeMap[$behavior['behaviorType']] ?? '未知行为';
$content = $behavior['behaviorName'] ?? $type;
if (!empty($behavior['targetName'])) {
$content .= ': ' . $behavior['targetName'];
}
$journey[] = [
'type' => $type,
'content' => $content,
'time' => !empty($behavior['behaviorTime']) && is_numeric($behavior['behaviorTime'])
? date('Y-m-d H:i:s', intval($behavior['behaviorTime']))
: '',
'source' => '存客宝',
'actionType' => $this->getActionType($behavior['behaviorType']),
'amount' => !empty($behavior['amount']) && floatval($behavior['amount']) > 0
? '¥' . number_format(floatval($behavior['amount']), 2)
: '',
];
}
return $journey;
}
/**
* 获取行为类型
*
* @param int $behaviorType 行为类型
* @return string
*/
private function getActionType($behaviorType)
{
if (in_array($behaviorType, [6, 7, 8])) {
return 'transaction'; // 交易
} elseif (in_array($behaviorType, [1, 2, 9, 10])) {
return 'social'; // 社交
} elseif (in_array($behaviorType, [3, 4, 5])) {
return 'footprint'; // 轨迹
} else {
return 'flow'; // 流量
}
}
/**
* 获取消费偏好
*
* @param int $poolCompanyId 客户ID
* @return array
*/
private function getCustomerPreferences($poolCompanyId)
{
// TODO: 从行为记录和订单记录分析消费偏好
return [
'categories' => ['智能数码', '精品咖啡', '商务休闲'],
'recentItems' => ['iPhone 16 Pro', 'iPad Air'],
'coreInterest' => '数码发烧友 & 品质生活追求者'
];
}
/**
* 获取性别文本
*
* @param int $gender 性别代码
* @return string
*/
private function getGenderText($gender)
{
$map = [
0 => '保密',
1 => '男',
2 => '女',
];
return $map[$gender] ?? '未知';
}
/**
* 计算年龄
*
* @param string $birthday 生日
* @return int
*/
private function calculateAge($birthday)
{
if (empty($birthday)) {
return 0;
}
$birthTimestamp = strtotime($birthday);
if ($birthTimestamp === false) {
return 0;
}
$age = date('Y') - date('Y', $birthTimestamp);
if (date('md', $birthTimestamp) > date('md')) {
$age--;
}
return $age;
}
/**
* 脱敏身份证号
*
* @param string $idNumber 身份证号
* @return string
*/
private function maskIdNumber($idNumber)
{
if (empty($idNumber) || strlen($idNumber) < 8) {
return $idNumber;
}
return substr($idNumber, 0, 4) . str_repeat('*', strlen($idNumber) - 8) . substr($idNumber, -4);
}
}

436
application/store/controller/DeviceWechatController.php Normal file
View File

@@ -0,0 +1,436 @@
<?php
namespace app\store\controller;
use app\common\service\WechatAccountHealthScoreService;
use think\Db;
use think\facade\Log;
/**
* 设备和微信控制器
*/
class DeviceWechatController extends BaseController
{
/**
* 获取设备和微信信息
* GET /v2/store/device-wechat/info
*
* @return \think\response\Json
*/
public function getInfo()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId) || empty($companyId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取设备信息
$device = $this->device;
if (empty($device) || empty($device['id'])) {
return json(['code' => 404, 'msg' => '设备不存在']);
}
$deviceId = $device['id'];
$wechatId = $device['wechatId'] ?? '';
if (empty($wechatId)) {
return json(['code' => 404, 'msg' => '设备未绑定微信']);
}
// 1. 获取微信账号信息
$wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id,wechatId,alias,nickname,avatar,totalFriend')
->find();
if (empty($wechatAccount)) {
return json(['code' => 404, 'msg' => '微信账号不存在']);
}
$accountId = $wechatAccount['id'];
// 2. 获取设备持有人信息
$deviceOwner = Db::name('device_user')
->alias('du')
->join('users u', 'u.id = du.userId', 'left')
->where([
['du.deviceId', '=', $deviceId],
['du.companyId', '=', $companyId],
['du.deleteTime', '=', 0]
])
->field('u.username,u.account')
->find();
$deviceOwnerName = $deviceOwner['username'] ?? $deviceOwner['account'] ?? '未知';
// 3. 获取设备在线状态和微信状态
$deviceWechatLogin = Db::name('device_wechat_login')
->where([
['deviceId', '=', $deviceId],
['wechatId', '=', $wechatId],
['companyId', '=', $companyId]
])
->order('id desc')
->find();
$deviceOnline = !empty($device['alive']) && $device['alive'] == 1;
$wechatNormal = !empty($deviceWechatLogin['alive']) && $deviceWechatLogin['alive'] == 1;
// 4. 获取健康分信息
$healthScoreService = new WechatAccountHealthScoreService();
$healthScoreInfo = $healthScoreService->getHealthScore($accountId);
$healthScore = $healthScoreInfo['healthScore'] ?? 0;
$maxAddFriendPerDay = $healthScoreInfo['maxAddFriendPerDay'] ?? 0;
// 5. 获取今日加粉统计
$todayStats = $this->getTodayAddFriendStats($wechatId);
// 6. 获取基础构成
$baseComposition = $this->getBaseComposition($healthScoreInfo);
// 7. 判断健康状态
$healthStatus = $this->getHealthStatus($healthScore);
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
// 用户资料
'user' => [
'nickname' => $wechatAccount['nickname'] ?? '',
'wechatId' => $wechatAccount['alias'] ?? $wechatId,
'avatar' => $wechatAccount['avatar'] ?? '',
],
// 设备信息
'device' => [
'owner' => $deviceOwnerName,
'imei' => $device['imei'] ?? $device['deviceImei'] ?? '',
],
// 设备状态
'status' => [
'deviceOnline' => $deviceOnline,
'wechatNormal' => $wechatNormal,
],
// 微信健康分
'healthScore' => [
'score' => intval($healthScore),
'status' => $healthStatus,
'maxAddFriendPerDay' => intval($maxAddFriendPerDay),
'todayAdded' => intval($todayStats['todayAdded']),
'todayRemaining' => max(0, intval($maxAddFriendPerDay) - intval($todayStats['todayAdded'])),
'progress' => $maxAddFriendPerDay > 0 ? round((intval($todayStats['todayAdded']) / intval($maxAddFriendPerDay)) * 100, 2) : 0,
],
// 加粉统计
'addFriendStats' => [
'success' => intval($todayStats['success']),
'failed' => intval($todayStats['failed']),
'pending' => intval($todayStats['pending']),
],
// 基础构成
'baseComposition' => $baseComposition,
]
]);
} catch (\Exception $e) {
Log::error('获取设备和微信信息失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 获取动态记录（分页）
* GET /v2/store/device-wechat/dynamic-records
*
* @return \think\response\Json
*/
public function getDynamicRecords()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId) || empty($companyId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取设备信息
$device = $this->device;
if (empty($device) || empty($device['wechatId'])) {
return json(['code' => 404, 'msg' => '设备未绑定微信']);
}
$wechatId = $device['wechatId'];
// 获取微信账号ID
$wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id')
->find();
if (empty($wechatAccount)) {
return json(['code' => 404, 'msg' => '微信账号不存在']);
}
$accountId = $wechatAccount['id'];
// 分页参数
$page = intval($this->request->param('page', 1));
$limit = intval($this->request->param('limit', 10));
if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = 10;
if ($limit > 100) $limit = 100; // 限制最大每页数量
// 获取近7天的开始时间
$sevenDaysAgo = strtotime('-7 days');
// 查询动态记录（从健康分日志表）
$query = Db::table('s2_wechat_account_score_log')
->where([
['accountId', '=', $accountId],
['createTime', '>=', $sevenDaysAgo]
])
->order('createTime desc');
$total = $query->count();
$list = $query->page($page, $limit)->select();
// 格式化数据
$records = [];
foreach ($list as $item) {
// 使用changeValue字段（变动值）或计算valueAfter - valueBefore
$score = intval($item['changeValue'] ?? 0);
if ($score == 0) {
$score = intval($item['valueAfter'] ?? 0) - intval($item['valueBefore'] ?? 0);
}
$formatted = $score > 0 ? '+' . $score : (string)$score;
// 生成描述文本
$field = $item['field'] ?? '';
$description = $this->formatFieldDescription($field, $item);
$records[] = [
'name' => $description,
'score' => $score,
'formatted' => $formatted,
'type' => $score > 0 ? 'bonus' : ($score < 0 ? 'penalty' : 'neutral'),
'time' => !empty($item['createTime']) && is_numeric($item['createTime'])
? date('Y-m-d H:i:s', intval($item['createTime']))
: '',
];
}
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $records,
'total' => $total,
'page' => $page,
'limit' => $limit,
'note' => '仅显示近7天记录'
]
]);
} catch (\Exception $e) {
Log::error('获取动态记录失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 获取今日加粉统计
*
* @param string $wechatId 微信ID
* @return array
*/
private function getTodayAddFriendStats($wechatId)
{
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($companyId)) {
return [
'todayAdded' => 0,
'success' => 0,
'failed' => 0,
'pending' => 0,
];
}
$todayStart = strtotime(date('Y-m-d 00:00:00'));
$todayEnd = strtotime(date('Y-m-d 23:59:59'));
// 1. 查询今日加粉任务（成功和失败）
$todayTasks = Db::table('s2_friend_task')
->where('wechatId', $wechatId)
->whereBetween('createTime', [$todayStart, $todayEnd])
->field('status')
->select();
$stats = [
'todayAdded' => 0,
'success' => 0,
'failed' => 0,
'pending' => 0,
];
// 统计成功和失败
foreach ($todayTasks as $task) {
$status = intval($task['status'] ?? 0);
// 状态：0=执行中，1=成功，2=失败
if ($status == 1) {
$stats['success']++;
$stats['todayAdded']++;
} elseif ($status == 2) {
$stats['failed']++;
}
}
// 2. 查询场景获客中的待添加数量（friendStatus = 0 且来源是场景获客）
// 获取微信账号ID
$wechatAccount = Db::table('s2_wechat_account')
->where('wechatId', $wechatId)
->field('id')
->find();
if (!empty($wechatAccount)) {
$accountId = $wechatAccount['id'];
// 查询场景获客中未添加的好友数量
// 关联流量池公司表和流量来源表，筛选：
// - friendStatus = 0（未加）
// - sourceName 包含 "场景获客"
// - ownerAccountId = 当前微信账号ID（或根据业务需求调整）
$pendingCount = Db::name('traffic_pool_company')
->alias('tpc')
->join('traffic_pool_source tps', 'tps.poolCompanyId = tpc.id', 'left')
->where([
['tpc.companyId', '=', $companyId],
['tpc.friendStatus', '=', 0], // 未加
['tpc.ownerAccountId', '=', $accountId], // 归属当前微信账号
['tps.sourceName', 'like', '场景获客%'], // 来源是场景获客
])
->count();
$stats['pending'] = intval($pendingCount);
}
return $stats;
}
/**
* 获取基础构成
*
* @param array $healthScoreInfo 健康分信息
* @return array
*/
private function getBaseComposition($healthScoreInfo)
{
$baseScore = intval($healthScoreInfo['baseScore'] ?? 0);
$baseInfoScore = intval($healthScoreInfo['baseInfoScore'] ?? 0);
$friendCountScore = intval($healthScoreInfo['friendCountScore'] ?? 0);
$friendCount = intval($healthScoreInfo['friendCount'] ?? 0);
$composition = [];
// 账号基础分（默认60分）
$accountBaseScore = 60;
$composition[] = [
'name' => '账号基础分',
'description' => '系统分配默认初始分值',
'score' => $accountBaseScore,
'formatted' => '+' . $accountBaseScore,
];
// 基础信息分（已修改微信号）
if ($baseInfoScore > 0) {
$composition[] = [
'name' => '基础信息',
'description' => '已修改微信号(权重0.2)',
'score' => $baseInfoScore,
'formatted' => '+' . $baseInfoScore,
];
}
// 好友数量加成
if ($friendCountScore > 0) {
$composition[] = [
'name' => '好友数量加成',
'description' => '当前好友' . number_format($friendCount) . '人(权重0.3)',
'score' => $friendCountScore,
'formatted' => '+' . $friendCountScore,
];
}
return $composition;
}
/**
* 获取健康状态
*
* @param int $healthScore 健康分
* @return string
*/
private function getHealthStatus($healthScore)
{
if ($healthScore >= 80) {
return '健康';
} elseif ($healthScore >= 60) {
return '良好';
} elseif ($healthScore >= 40) {
return '一般';
} else {
return '较差';
}
}
/**
* 格式化字段描述
*
* @param string $field 字段名
* @param array $item 记录项
* @return string
*/
private function formatFieldDescription($field, $item)
{
$descriptions = [
'frequentPenalty' => '触发限额',
'noFrequentBonus' => '不触发频繁',
'banPenalty' => '封号',
'healthScore' => '健康分变动',
'baseScore' => '基础分',
'baseInfoScore' => '基础信息',
'friendCountScore' => '好友数量加成',
];
$baseDesc = $descriptions[$field] ?? $field;
// 特殊处理：连续N天不触发频繁
if ($field == 'noFrequentBonus') {
$extra = !empty($item['extra']) ? json_decode($item['extra'], true) : [];
$days = $extra['consecutiveDays'] ?? 0;
if ($days >= 3) {
return "连续{$days}天不触发频繁";
}
}
// 特殊处理：首次/再次触发限额
if ($field == 'frequentPenalty') {
$extra = !empty($item['extra']) ? json_decode($item['extra'], true) : [];
$count = $extra['frequentCount'] ?? 0;
if ($count == 1) {
return '首次触发限额';
} elseif ($count > 1) {
return '再次触发限额';
}
}
return $baseDesc;
}
}

531
application/store/controller/FlowPackageController.php
View File

@@ -2,253 +2,372 @@
namespace app\store\controller; namespace app\store\controller;
use app\common\controller\Api;
use app\store\model\FlowPackageModel; use app\store\model\FlowPackageModel;
use app\store\model\UserFlowPackageModel;
use app\store\model\FlowPackageOrderModel; use app\store\model\FlowPackageOrderModel;
use think\facade\Config; use app\store\model\UserFlowPackageModel;
use think\facade\Log;
/** /**
* 流量套餐控制器 * 流量套餐控制器 - V2版本
* 门店端流量采购功能
*/ */
class FlowPackageController extends Api class FlowPackageController extends BaseController
{ {
protected $noNeedLogin = [];
protected $noNeedRight = ['*'];
/** /**
* 获取流量套餐列表 * 获取流量套餐列表
* GET /v2/store/flow-packages
* *
* @return \think\Response * @return \think\response\Json
*/ */
public function getList() public function getList()
{ {
$params = $this->request->param(); try {
// 查询条件
// 查询条件 $where = [
$where = []; ['isDel', '=', 0],
['status', '=', 1], // 只获取启用的套餐
// 只获取未删除的数据 ['companyId', '=', $this->userInfo['companyId']]
$where[] = ['isDel', '=', 0];
// 套餐模型
$model = new FlowPackageModel();
// 查询数据
$list = $model->where($where)
->field('id, name, tag, originalPrice, price, monthlyFlow, duration, privileges')
->order('sort', 'asc')
->select();
// 格式化返回数据，添加计算字段
$result = [];
foreach ($list as $item) {
$result[] = [
'id' => $item['id'],
'name' => $item['name'],
'tag' => $item['tag'],
'originalPrice' => $item['originalPrice'],
'price' => $item['price'],
'monthlyFlow' => $item['monthlyFlow'],
'duration' => $item['duration'],
'discount' => $item->discount,
'totalFlow' => $item->totalFlow,
'privileges' => $item['privileges'],
]; ];
// 查询数据（包含公司ID和创建用户ID）
$list = FlowPackageModel::where($where)
->field('id, name, tag, originalPrice, price, monthlyFlow, duration, privileges, companyId, userId, createTime')
->order('sort', 'asc')
->select();
// 格式化返回数据，添加计算字段
$result = [];
foreach ($list as $item) {
$result[] = [
'id' => $item['id'],
'name' => $item['name'],
'tag' => $item['tag'],
'originalPrice' => $item['originalPrice'],
'price' => $item['price'],
'monthlyFlow' => $item['monthlyFlow'],
'duration' => $item['duration'],
'discount' => $item->discount,
'totalFlow' => $item->totalFlow,
'privileges' => $item['privileges'],
'createTime' => !empty($item['createTime']) ? date('Y-m-d H:i:s', $item['createTime']) : '', // 创建时间
];
}
return json([
'code' => 200,
'msg' => '获取成功',
'data' => $result
]);
} catch (\Exception $e) {
Log::error('获取流量套餐列表失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
return successJson($result, '获取成功');
} }
/** /**
* 获取流量套餐详情 * 获取流量套餐详情
* GET /v2/store/flow-packages/:id
* *
* @param int $id 套餐ID * @param int $id 套餐ID
* @return \think\Response * @return \think\response\Json
*/ */
public function detail($id) public function detail($id)
{ {
if (empty($id)) { try {
return errorJson('参数错误'); if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 查询数据
$info = FlowPackageModel::where('id', $id)
->where('isDel', 0)
->find();
if (empty($info)) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
// 格式化返回数据，添加计算字段
$result = [
'id' => $info['id'],
'name' => $info['name'],
'tag' => $info['tag'],
'originalPrice' => $info['originalPrice'],
'price' => $info['price'],
'monthlyFlow' => $info['monthlyFlow'],
'duration' => $info['duration'],
'discount' => $info->discount,
'totalFlow' => $info->totalFlow,
'privileges' => $info['privileges'],
'companyId' => $info['companyId'] ?? 0, // 公司ID
'userId' => $info['userId'] ?? 0, // 创建用户ID
'createTime' => !empty($info['createTime']) ? date('Y-m-d H:i:s', $info['createTime']) : '', // 创建时间
];
return json([
'code' => 200,
'msg' => '获取成功',
'data' => $result
]);
} catch (\Exception $e) {
Log::error('获取流量套餐详情失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
// 套餐模型
$model = new FlowPackageModel();
// 查询数据
$info = $model->where('id', $id)->where('isDel', 0)->find();
if (empty($info)) {
return errorJson('套餐不存在');
}
// 格式化返回数据，添加计算字段
$result = [
'id' => $info['id'],
'name' => $info['name'],
'tag' => $info['tag'],
'originalPrice' => $info['originalPrice'],
'price' => $info['price'],
'monthlyFlow' => $info['monthlyFlow'],
'duration' => $info['duration'],
'discount' => $info->discount,
'totalFlow' => $info->totalFlow,
'privileges' => $info['privileges'],
];
return successJson($result, '获取成功');
} }
/** /**
* 展示用户流量套餐使用情况 * 获取剩余流量
* GET /v2/store/flow-packages/remaining-flow
* *
* @return \think\Response * @return \think\response\Json
*/ */
public function remainingFlow() public function remainingFlow()
{ {
$params = $this->request->param(); try {
// 从认证中间件获取用户信息
$userInfo = request()->userInfo; $userInfo = $this->request->userInfo ?? [];
// 获取用户ID，通常应该从会话或令牌中获取 $userId = $userInfo['id'] ?? 0;
$userId = $userInfo['id'];
if (empty($userId)) {
return errorJson('请先登录');
}
// 获取用户当前有效的流量套餐
$userPackage = UserFlowPackageModel::getUserActivePackage($userId);
if (empty($userPackage)) { if (empty($userId)) {
return errorJson('您没有有效的流量套餐'); return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取用户当前有效的流量套餐
$userPackage = UserFlowPackageModel::getUserActivePackage($userId);
if (empty($userPackage)) {
return json(['code' => 404, 'msg' => '您没有有效的流量套餐']);
}
// 获取套餐详情
$packageId = $userPackage['packageId'];
$flowPackage = FlowPackageModel::where('id', $packageId)
->where('isDel', 0)
->find();
if (empty($flowPackage)) {
return json(['code' => 404, 'msg' => '套餐信息不存在']);
}
// 计算剩余流量
$totalFlow = intval($userPackage['totalFlow'] ?? $flowPackage->totalFlow ?? 0); // 总流量
$usedFlow = intval($userPackage['usedFlow'] ?? 0); // 已使用流量
$remainingFlow = $totalFlow - $usedFlow; // 剩余流量
$remainingFlow = $remainingFlow > 0 ? $remainingFlow : 0; // 确保不为负数
// 计算剩余天数
$now = time();
$expireTime = intval($userPackage['expireTime'] ?? 0);
$duration = intval($userPackage['duration'] ?? 0);
if ($expireTime <= 0) {
return json(['code' => 400, 'msg' => '套餐数据异常，到期时间无效']);
}
$remainingDays = ceil(($expireTime - $now) / 86400); // 向上取整，剩余天数
$remainingDays = $remainingDays > 0 ? $remainingDays : 0; // 确保不为负数
// 剩余百分比
$flowPercentage = $totalFlow > 0 ? round(($remainingFlow / $totalFlow) * 100, 1) : 0;
$timePercentage = $duration > 0 ?
round(($remainingDays / ($duration * 30)) * 100, 1) : 0;
// 返回数据
$result = [
'packageName' => $flowPackage['name'], // 套餐名称
'remainingFlow' => $remainingFlow, // 剩余流量(人)
'totalFlow' => $totalFlow, // 总流量(人)
'flowPercentage' => $flowPercentage, // 剩余流量百分比
'remainingDays' => $remainingDays, // 剩余天数
'totalDays' => $duration * 30, // 总天数(按30天/月计算)
'timePercentage' => $timePercentage, // 剩余时间百分比
'expireTime' => date('Y-m-d', $expireTime), // 到期日期
'startTime' => date('Y-m-d', $userPackage['startTime']), // 开始日期
];
return json([
'code' => 200,
'msg' => '获取成功',
'data' => $result
]);
} catch (\Exception $e) {
Log::error('获取剩余流量失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
// 获取套餐详情
$packageId = $userPackage['packageId'];
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($flowPackage)) {
return errorJson('套餐信息不存在');
}
// 计算剩余流量
$totalFlow = $userPackage['totalFlow'] ?? $flowPackage->totalFlow; // 总流量
$usedFlow = $userPackage['usedFlow'] ?? 0; // 已使用流量
$remainingFlow = $totalFlow - $usedFlow; // 剩余流量
$remainingFlow = $remainingFlow > 0 ? $remainingFlow : 0; // 确保不为负数
// 计算剩余天数
$now = time();
$expireTime = $userPackage['expireTime'];
$remainingDays = ceil(($expireTime - $now) / 86400); // 向上取整，剩余天数
$remainingDays = $remainingDays > 0 ? $remainingDays : 0; // 确保不为负数
// 剩余百分比
$flowPercentage = $totalFlow > 0 ? round(($remainingFlow / $totalFlow) * 100, 1) : 0;
$timePercentage = $userPackage['duration'] > 0 ?
round(($remainingDays / ($userPackage['duration'] * 30)) * 100, 1) : 0;
// 返回数据
$result = [
'packageName' => $flowPackage['name'], // 套餐名称
'remainingFlow' => $remainingFlow, // 剩余流量(人)
'totalFlow' => $totalFlow, // 总流量(人)
'flowPercentage' => $flowPercentage, // 剩余流量百分比
'remainingDays' => $remainingDays, // 剩余天数
'totalDays' => $userPackage['duration'] * 30, // 总天数(按30天/月计算)
'timePercentage' => $timePercentage, // 剩余时间百分比
'expireTime' => date('Y-m-d', $expireTime), // 到期日期
'startTime' => date('Y-m-d', $userPackage['startTime']), // 开始日期
];
return successJson($result, '获取成功');
} }
/** /**
* 创建流量采购订单 * 创建流量采购订单
* POST /v2/store/flow-packages/order
* *
* @return \think\Response * @return \think\response\Json
*/ */
public function createOrder() public function createOrder()
{ {
$params = $this->request->param(); try {
// 从BaseController获取用户信息
$userInfo = request()->userInfo; $userId = $this->userInfo['id'] ?? 0;
// 获取用户ID，通常应该从会话或令牌中获取 $companyId = $this->userInfo['companyId'] ?? 0;
$userId = $userInfo['id'];
if (empty($userId)) {
return errorJson('请先登录');
}
// 获取套餐ID
$packageId = isset($params['packageId']) ? intval($params['packageId']) : 0;
if (empty($packageId)) {
return errorJson('请选择套餐');
}
// 查询套餐信息
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($flowPackage)) {
return errorJson('套餐不存在');
}
// 获取支付方式（可选）
$payType = isset($params['payType']) ? $params['payType'] : 'wechat';
// 套餐价格和信息
$amount = floatval($flowPackage['price']);
$packageName = $flowPackage['name'];
$duration = intval($flowPackage['duration']);
$remark = isset($params['remark']) ? $params['remark'] : '';
// 处理金额为0的特殊情况
if ($amount <= 0) {
// 金额为0，无需支付，直接创建订单并设置为已支付
$order = FlowPackageOrderModel::createOrder(
$userId,
$packageId,
$packageName,
0,
$duration,
'nopay',
$remark
);
if (!$order) { if (empty($userId)) {
return errorJson('订单创建失败'); return json(['code' => 401, 'msg' => '请先登录']);
} }
// 创建用户流量套餐记录 if (empty($companyId)) {
$this->createUserFlowPackage($userId, $packageId, $order['id']); return json(['code' => 400, 'msg' => '公司信息不存在']);
// 返回成功信息
return successJson(['orderNo' => $order['orderNo'],'status' => 'success'], '购买成功');
} else {
// 创建正常需要支付的订单
$order = FlowPackageOrderModel::createOrder(
$userId,
$packageId,
$packageName,
$amount,
$duration,
$payType,
$remark
);
if (!$order) {
return errorJson('订单创建失败');
} }
// 返回订单信息，前端需要跳转到支付页面 // 获取套餐ID
return successJson([ $packageId = $this->request->param('packageId', 0);
'orderNo' => $order['orderNo'],
'amount' => $amount, if (empty($packageId)) {
'payType' => $payType, return json(['code' => 400, 'msg' => '请选择套餐']);
'status' => 'pending' }
], '订单创建成功');
// 查询套餐信息
$flowPackage = FlowPackageModel::where('id', $packageId)
->where('isDel', 0)
->find();
if (empty($flowPackage)) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
// 获取支付方式（可选）
$payType = $this->request->param('payType', 'wechat');
// 套餐价格和信息
$amount = floatval($flowPackage['price']);
$packageName = $flowPackage['name'];
$duration = intval($flowPackage['duration']);
$remark = $this->request->param('remark', '');
// 处理金额为0的特殊情况
if ($amount <= 0) {
// 金额为0，无需支付，直接创建订单并设置为已支付
$order = FlowPackageOrderModel::createOrder(
$userId,
$companyId,
$packageId,
$packageName,
0,
$duration,
'nopay',
$remark
);
if (!$order) {
return json(['code' => 500, 'msg' => '订单创建失败']);
}
// 创建用户流量套餐记录
$this->createUserFlowPackage($userId, $packageId, $order['id']);
// 返回成功信息
return json([
'code' => 200,
'msg' => '购买成功',
'data' => [
'orderNo' => $order['orderNo'],
'status' => 'success'
]
]);
} else {
// 创建正常需要支付的订单
$order = FlowPackageOrderModel::createOrder(
$userId,
$companyId,
$packageId,
$packageName,
$amount,
$duration,
$payType,
$remark
);
if (!$order) {
return json(['code' => 500, 'msg' => '订单创建失败']);
}
// 返回订单信息，前端需要跳转到支付页面
return json([
'code' => 200,
'msg' => '订单创建成功',
'data' => [
'orderNo' => $order['orderNo'],
'amount' => $amount,
'payType' => $payType,
'status' => 'pending'
]
]);
}
} catch (\Exception $e) {
Log::error('创建订单失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '创建订单失败：' . $e->getMessage()]);
}
}
/**
* 获取订单列表
* GET /v2/store/flow-packages/orders
*
* @return \think\response\Json
*/
public function getOrderList()
{
try {
// 从认证中间件获取用户信息
$page = intval($this->request->param('page', 1));
$limit = intval($this->request->param('limit', 10));
$status = $this->request->param('status', ''); // 订单状态筛选
// 确保分页参数有效
$page = $page > 0 ? $page : 1;
$limit = $limit > 0 ? $limit : 10;
$where = [
['userId', '=', $this->userInfo['id']],
['companyId', '=', $this->userInfo['companyId']], // 按公司ID查询
['isDel', '=', 0]
];
if ($status !== '' && $status !== null) {
$status = intval($status);
$where[] = ['status', '=', $status];
}
$query = FlowPackageOrderModel::where($where)
->order('id', 'desc');
$list = $query->page($page, $limit)->select();
$total = $query->count();
// 格式化数据
foreach ($list as &$item) {
$item['createTime'] = !empty($item['createTime']) && is_numeric($item['createTime']) ? date('Y-m-d H:i:s', intval($item['createTime'])) : '';
$item['payTime'] = !empty($item['payTime']) && is_numeric($item['payTime']) ? date('Y-m-d H:i:s', intval($item['payTime'])) : '';
}
unset($item);
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $list,
'total' => $total,
'page' => $page,
'limit' => $limit
]
]);
} catch (\Exception $e) {
Log::error('获取订单列表失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
} }
@@ -263,7 +382,9 @@ class FlowPackageController extends Api
private function createUserFlowPackage($userId, $packageId, $orderId) private function createUserFlowPackage($userId, $packageId, $orderId)
{ {
// 获取套餐信息 // 获取套餐信息
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find(); $flowPackage = FlowPackageModel::where('id', $packageId)
->where('isDel', 0)
->find();
if (empty($flowPackage)) { if (empty($flowPackage)) {
return false; return false;
@@ -273,23 +394,21 @@ class FlowPackageController extends Api
$now = time(); $now = time();
$expireTime = $now + (intval($flowPackage['duration']) * 30 * 86400); $expireTime = $now + (intval($flowPackage['duration']) * 30 * 86400);
// 用户流量套餐数据 // 用户流量套餐数据（注意：ck_user_flow_package表没有packageName和monthlyFlow字段）
$data = [ $data = [
'userId' => $userId, 'userId' => $userId,
'packageId' => $packageId, 'packageId' => $packageId,
'orderId' => $orderId, 'orderId' => $orderId,
'packageName' => $flowPackage['name'],
'monthlyFlow' => $flowPackage['monthlyFlow'],
'duration' => $flowPackage['duration'], 'duration' => $flowPackage['duration'],
'totalFlow' => $flowPackage->totalFlow, // 使用计算属性获取总流量 'totalFlow' => $flowPackage->totalFlow, // 使用计算属性获取总流量
'usedFlow' => 0, 'usedFlow' => 0,
'startTime' => $now, 'startTime' => $now,
'expireTime' => $expireTime, 'expireTime' => $expireTime,
'status' => 1, // 1:有效 0:无效 'status' => 1, // 1:有效 0:无效
'isDel' => 0
]; ];
// 创建用户流量套餐记录 // 创建用户流量套餐记录
return UserFlowPackageModel::create($data) ? true : false; return UserFlowPackageModel::create($data) ? true : false;
} }
} }

522
application/store/controller/TokensController.php Normal file
View File

@@ -0,0 +1,522 @@
<?php
namespace app\store\controller;
use app\store\model\TokensPackageModel;
use app\store\model\TokensCompanyModel;
use app\store\model\TokensRecordModel;
use app\common\controller\PaymentService;
use app\common\model\Order;
use think\Db;
use think\facade\Log;
use think\facade\Env;
/**
* 算力中心控制器
*/
class TokensController extends BaseController
{
/**
* 获取算力套餐列表
* GET /v2/store/tokens/packages
*
* @return \think\response\Json
*/
public function getList()
{
try {
$page = intval($this->request->param('page', 1));
$limit = intval($this->request->param('limit', 10));
// 确保分页参数有效
if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = 10;
$where = [
['isDel', '=', 0],
['status', '=', 1],
];
$query = TokensPackageModel::where($where);
$total = $query->count();
$list = $query->page($page, $limit)->order('sort ASC,id desc')->select();
// 格式化数据
$result = [];
foreach ($list as $item) {
$originalPrice = floatval($item['originalPrice'] ?? 0) / 100; // 分转元
$price = floatval($item['price'] ?? 0) / 100; // 分转元
$tokens = intval($item['tokens'] ?? 0);
// 计算折扣
$discount = 0;
if ($originalPrice > 0) {
$discount = round((($originalPrice - $price) / $originalPrice) * 100, 2);
}
// 计算单价
$unitPrice = $tokens > 0 ? round($price / $tokens, 6) : 0;
$result[] = [
'id' => intval($item['id']),
'name' => $item['name'] ?? '',
'tokens' => number_format($tokens),
'price' => round($price, 2),
'originalPrice' => round($originalPrice, 2),
'discount' => $discount,
'unitPrice' => $unitPrice,
'description' => $item->description,
'sort' => intval($item['sort'] ?? 50),
'isTrial' => intval($item['isTrial'] ?? 0),
'isRecommend' => intval($item['isRecommend'] ?? 0),
'isHot' => intval($item['isHot'] ?? 0),
'isVip' => intval($item['isVip'] ?? 0),
];
}
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $result,
'total' => $total,
'page' => $page,
'limit' => $limit
]
]);
} catch (\Exception $e) {
Log::error('获取算力套餐列表失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 购买算力
* POST /v2/store/tokens/pay
*
* @return \think\response\Json
*/
public function pay()
{
try {
$id = intval($this->request->param('id', 0));
$price = $this->request->param('price', '');
$payType = $this->request->param('payType', 'qrCode');
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
if (!in_array($payType, ['wechat', 'alipay', 'qrCode'])) {
return json(['code' => 400, 'msg' => '付款类型不正确']);
}
if (empty($id) && empty($price)) {
return json(['code' => 400, 'msg' => '套餐和自定义购买金额必须选一个']);
}
// 处理套餐或自定义购买
if (!empty($id)) {
$package = TokensPackageModel::where(['id' => $id, 'status' => 1, 'isDel' => 0])->find();
if (empty($package)) {
return json(['code' => 404, 'msg' => '套餐不存在或者已禁用']);
}
if ($package['price'] <= 0) {
return json(['code' => 400, 'msg' => '套餐金额异常']);
}
$specs = [
'id' => intval($package['id']),
'name' => $package['name'],
'price' => intval($package['price']), // 单位：分
'tokens' => intval($package['tokens']),
];
} else {
// 获取配置的tokens比例
$tokens_multiple = Env::get('payment.tokens_multiple', 20);
$specs = [
'id' => 0,
'name' => '自定义购买算力',
'price' => intval(floatval($price) * 100), // 元转分
'tokens' => intval(floatval($price) * $tokens_multiple),
];
}
// 生成订单号
$orderNo = date('YmdHis') . rand(100000, 999999);
$order = [
'companyId' => $companyId,
'userId' => $userId,
'orderNo' => $orderNo,
'goodsId' => $specs['id'],
'goodsName' => $specs['name'],
'goodsSpecs' => $specs,
'orderType' => 1, // 1=购买算力
'money' => $specs['price'],
'service' => $payType
];
$paymentService = new PaymentService();
$res = $paymentService->createOrder($order);
$res = json_decode($res, true);
if ($res['code'] == 200) {
return json([
'code' => 200,
'msg' => '订单创建成功',
'data' => [
'orderNo' => $orderNo,
'code_url' => $res['data'] ?? ''
]
]);
} else {
return json(['code' => 500, 'msg' => $res['msg'] ?? '订单创建失败']);
}
} catch (\Exception $e) {
Log::error('购买算力失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '购买失败：' . $e->getMessage()]);
}
}
/**
* 查询订单状态
* GET /v2/store/tokens/order
*
* @return \think\response\Json
*/
public function queryOrder()
{
try {
$orderNo = $this->request->param('orderNo', '');
if (empty($orderNo)) {
return json(['code' => 400, 'msg' => '订单号不能为空']);
}
$order = Order::where('orderNo', $orderNo)->find();
if (!$order) {
return json(['code' => 404, 'msg' => '该订单不存在']);
}
// 如果订单已支付，直接返回
if ($order->status == 1) {
return json([
'code' => 200,
'msg' => '订单已支付',
'data' => [
'orderNo' => $order->orderNo,
'status' => $order->status,
'payTime' => !empty($order->payTime) && is_numeric($order->payTime) ? date('Y-m-d H:i:s', intval($order->payTime)) : '',
]
]);
}
// 查询支付状态
$paymentService = new PaymentService();
$res = $paymentService->queryOrder($orderNo);
$res = json_decode($res, true);
if ($res['code'] == 200) {
return json([
'code' => 200,
'msg' => '订单已支付',
'data' => [
'orderNo' => $order->orderNo,
'status' => 1,
'payTime' => !empty($order->payTime) && is_numeric($order->payTime) ? date('Y-m-d H:i:s', intval($order->payTime)) : '',
]
]);
} else {
$errorMsg = !empty($order['payInfo']) ? $order['payInfo'] : '订单未支付';
return json([
'code' => 200,
'msg' => $errorMsg,
'data' => [
'orderNo' => $order->orderNo,
'status' => $order->status,
]
]);
}
} catch (\Exception $e) {
Log::error('查询订单失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '查询失败：' . $e->getMessage()]);
}
}
/**
* 获取订单列表
* GET /v2/store/tokens/orders
*
* @return \think\response\Json
*/
public function getOrderList()
{
try {
$page = intval($this->request->param('page', 1));
$limit = intval($this->request->param('limit', 10));
$status = $this->request->param('status', '');
$keyword = $this->request->param('keyword', '');
$orderType = $this->request->param('orderType', '');
$payType = $this->request->param('payType', '');
$startTime = $this->request->param('startTime', '');
$endTime = $this->request->param('endTime', '');
// 确保分页参数有效
if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = 10;
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 构建查询条件
$where = [
['userId', '=', $userId],
['companyId', '=', $companyId]
];
// 关键词搜索（订单号、商品名称）
if (!empty($keyword)) {
$where[] = ['orderNo|goodsName', 'like', '%' . $keyword . '%'];
}
// 状态筛选 (0-待支付 1-已付款 2-已退款 3-付款失败)
if ($status !== '') {
$where[] = ['status', '=', intval($status)];
}
// 订单类型筛选
if ($orderType !== '') {
$where[] = ['orderType', '=', intval($orderType)];
}
// 支付类型筛选
if ($payType !== '') {
$where[] = ['payType', '=', intval($payType)];
}
// 时间范围筛选
if (!empty($startTime)) {
$where[] = ['createTime', '>=', strtotime($startTime)];
}
if (!empty($endTime)) {
$where[] = ['createTime', '<=', strtotime($endTime . ' 23:59:59')];
}
// 分页查询
$query = Order::where($where)
->where(function ($query) {
$query->whereNull('deleteTime')->whereOr('deleteTime', 0);
});
$total = $query->count();
$list = $query->field('id,orderNo,goodsId,goodsName,goodsSpecs,orderType,money,status,payType,payTime,createTime')
->order('id desc')
->page($page, $limit)
->select();
// 格式化数据
$result = [];
foreach ($list as $item) {
// 金额转换（分转元）
$money = round(floatval($item['money'] ?? 0) / 100, 2);
// 解析商品规格
$specs = [];
if (!empty($item['goodsSpecs'])) {
$specs = is_string($item['goodsSpecs']) ? json_decode($item['goodsSpecs'], true) : $item['goodsSpecs'];
}
// 状态文本
$statusText = [
0 => '待支付',
1 => '已付款',
2 => '已退款',
3 => '付款失败'
];
// 订单类型文本
$orderTypeText = [
1 => '购买算力'
];
// 支付类型文本
$payTypeText = [
1 => '微信支付',
2 => '支付宝'
];
$result[] = [
'id' => intval($item['id']),
'orderNo' => $item['orderNo'],
'goodsId' => intval($item['goodsId'] ?? 0),
'goodsName' => $item['goodsName'] ?? '',
'goodsSpecs' => $specs,
'tokens' => isset($specs['tokens']) ? number_format(intval($specs['tokens'])) : '0',
'orderType' => intval($item['orderType'] ?? 0),
'orderTypeText' => $orderTypeText[$item['orderType'] ?? 0] ?? '其他',
'money' => $money,
'status' => intval($item['status'] ?? 0),
'statusText' => $statusText[$item['status'] ?? 0] ?? '未知',
'payType' => intval($item['payType'] ?? 0),
'payTypeText' => !empty($item['payType']) ? ($payTypeText[$item['payType']] ?? '未知') : '',
'payTime' => !empty($item['payTime']) && is_numeric($item['payTime']) ? date('Y-m-d H:i:s', intval($item['payTime'])) : '',
'createTime' => !empty($item['createTime']) && is_numeric($item['createTime']) ? date('Y-m-d H:i:s', intval($item['createTime'])) : '',
];
}
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $result,
'total' => $total,
'page' => $page,
'limit' => $limit
]
]);
} catch (\Exception $e) {
Log::error('获取订单列表失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 获取算力统计信息
* GET /v2/store/tokens/statistics
*
* @return \think\response\Json
*/
public function getTokensStatistics()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($companyId)) {
return json(['code' => 400, 'msg' => '公司信息获取失败']);
}
// 获取公司算力余额
$tokensCompany = TokensCompanyModel::where(['companyId' => $companyId, 'userId' => $userId])->find();
$remainingTokens = $tokensCompany ? intval($tokensCompany->tokens ?? 0) : 0;
// 获取今日开始和结束时间戳
$todayStart = strtotime(date('Y-m-d 00:00:00'));
$todayEnd = strtotime(date('Y-m-d 23:59:59'));
// 获取本月开始和结束时间戳
$monthStart = strtotime(date('Y-m-01 00:00:00'));
$monthEnd = strtotime(date('Y-m-t 23:59:59'));
// 统计今日消费（type=0表示消费）
$todayUsed = TokensRecordModel::where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0], // 0为减少（消费）
['createTime', '>=', $todayStart],
['createTime', '<=', $todayEnd]
])->sum('tokens');
$todayUsed = intval($todayUsed);
// 统计本月消费
$monthUsed = TokensRecordModel::where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0], // 0为减少（消费）
['createTime', '>=', $monthStart],
['createTime', '<=', $monthEnd]
])->sum('tokens');
$monthUsed = intval($monthUsed);
// 计算总算力（当前剩余 + 历史总消费）
$totalConsumed = TokensRecordModel::where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0]
])->sum('tokens');
$totalConsumed = intval($totalConsumed);
// 总充值算力
$totalRecharged = TokensRecordModel::where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 1] // 1为增加（充值）
])->sum('tokens');
$totalRecharged = intval($totalRecharged);
// 计算预计可用天数（基于过去一个月的平均消耗）
$estimatedDays = $this->calculateEstimatedDays($userId, $companyId, $remainingTokens);
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'totalTokens' => $totalRecharged, // 总算力（累计充值）
'todayUsed' => $todayUsed, // 今日使用
'monthUsed' => $monthUsed, // 本月使用
'remainingTokens' => $remainingTokens, // 剩余算力
'totalConsumed' => $totalConsumed, // 累计消费
'estimatedDays' => $estimatedDays, // 预计可用天数
]
]);
} catch (\Exception $e) {
Log::error('获取算力统计失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 计算预计可用天数（基于过去一个月的平均消耗）
*
* @param int $userId 用户ID
* @param int $companyId 公司ID
* @param int $remainingTokens 当前剩余算力
* @return int 预计可用天数，-1表示无法计算（无消耗记录或余额为0）
*/
private function calculateEstimatedDays($userId, $companyId, $remainingTokens)
{
// 如果余额为0或负数，无法计算
if ($remainingTokens <= 0) {
return -1;
}
// 计算过去30天的消耗总量（只统计减少的记录，type=0）
$oneMonthAgo = time() - (30 * 24 * 60 * 60); // 30天前的时间戳
$totalConsumed = TokensRecordModel::where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0], // 只统计减少的记录
['createTime', '>=', $oneMonthAgo]
])->sum('tokens');
$totalConsumed = intval($totalConsumed);
// 如果过去30天没有消耗记录，无法计算
if ($totalConsumed <= 0) {
return -1;
}
// 计算平均每天消耗量
$avgDailyConsumption = $totalConsumed / 30;
// 如果平均每天消耗为0，无法计算
if ($avgDailyConsumption <= 0) {
return -1;
}
// 计算预计可用天数 = 当前余额 / 平均每天消耗量
$estimatedDays = floor($remainingTokens / $avgDailyConsumption);
return $estimatedDays;
}
}

267
application/store/controller/UserController.php Normal file
View File

@@ -0,0 +1,267 @@
<?php
namespace app\store\controller;
use think\Db;
use think\facade\Log;
use app\common\service\UserApiKeyService;
/**
* 用户管理控制器
*/
class UserController extends BaseController
{
/**
* 获取用户资料
* GET /v2/store/user/profile
*
* @return \think\response\Json
*/
public function getProfile()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取用户基本信息
$user = Db::name('users')
->where([
['id', '=', $userId],
['companyId', '=', $companyId],
['typeId', '=', 2], // 门店端用户
['deleteTime', '=', 0]
])
->field('id, account, username, phone, avatar, companyId, typeId, status, createTime')
->find();
if (empty($user)) {
return json(['code' => 404, 'msg' => '用户不存在']);
}
// 获取算力信息
$tokensCompany = Db::name('tokens_company')
->where([
['userId', '=', $userId],
['companyId', '=', $companyId]
])
->find();
$remainingTokens = $tokensCompany ? intval($tokensCompany['tokens'] ?? 0) : 0;
// 统计今日消费
$todayStart = strtotime(date('Y-m-d 00:00:00'));
$todayEnd = strtotime(date('Y-m-d 23:59:59'));
$todayUsed = Db::name('tokens_record')
->where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0], // 0为减少（消费）
['createTime', '>=', $todayStart],
['createTime', '<=', $todayEnd]
])
->sum('tokens');
$todayUsed = intval($todayUsed);
// 统计本月消费
$monthStart = strtotime(date('Y-m-01 00:00:00'));
$monthEnd = strtotime(date('Y-m-t 23:59:59'));
$monthUsed = Db::name('tokens_record')
->where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 0], // 0为减少（消费）
['createTime', '>=', $monthStart],
['createTime', '<=', $monthEnd]
])
->sum('tokens');
$monthUsed = intval($monthUsed);
// 总充值算力
$totalRecharged = Db::name('tokens_record')
->where([
['userId', '=', $userId],
['companyId', '=', $companyId],
['type', '=', 1] // 1为增加（充值）
])
->sum('tokens');
$totalRecharged = intval($totalRecharged);
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'id' => intval($user['id']),
'account' => $user['account'] ?? '',
'username' => $user['username'] ?? '',
'phone' => $user['phone'] ?? '',
'avatar' => $user['avatar'] ?? 'https://img.icons8.com/color/512/circled-user-male-skin-type-7.png',
'companyId' => intval($user['companyId']),
'typeId' => intval($user['typeId']),
'status' => intval($user['status']),
'createTime' => !empty($user['createTime']) && is_numeric($user['createTime']) ? date('Y-m-d H:i:s', intval($user['createTime'])) : '',
// 算力信息
'tokens' => [
'remainingTokens' => $remainingTokens, // 剩余算力
'totalRecharged' => $totalRecharged, // 总算力（累计充值）
'todayUsed' => $todayUsed, // 今日使用
'monthUsed' => $monthUsed, // 本月使用
]
]
]);
} catch (\Exception $e) {
Log::error('获取用户资料失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 更新用户资料
* PUT /v2/store/user/profile
*
* @return \think\response\Json
*/
public function updateProfile()
{
try {
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 获取更新参数
$username = $this->request->param('username', '');
$avatar = $this->request->param('avatar', '');
$oldPassword = $this->request->param('oldPassword', '');
$newPassword = $this->request->param('newPassword', '');
// 检查用户是否存在
$user = Db::name('users')
->where([
['id', '=', $userId],
['companyId', '=', $companyId],
['typeId', '=', 2],
['deleteTime', '=', 0]
])
->find();
if (empty($user)) {
return json(['code' => 404, 'msg' => '用户不存在']);
}
$updateData = [];
$updateFields = [];
// 更新昵称
if ($username !== '') {
$updateData['username'] = $username;
$updateFields[] = '昵称';
}
// 更新头像
if ($avatar !== '') {
$updateData['avatar'] = $avatar;
$updateFields[] = '头像';
}
// 更新密码
if (!empty($oldPassword) && !empty($newPassword)) {
// 验证旧密码
$oldPasswordMd5 = md5($oldPassword);
if ($user['passwordMd5'] !== $oldPasswordMd5) {
return json(['code' => 400, 'msg' => '旧密码不正确']);
}
// 验证新密码长度
if (strlen($newPassword) < 6) {
return json(['code' => 400, 'msg' => '新密码长度不能少于6位']);
}
$updateData['passwordMd5'] = md5($newPassword);
$updateFields[] = '密码';
}
// 如果没有需要更新的字段
if (empty($updateData)) {
return json(['code' => 400, 'msg' => '没有需要更新的字段']);
}
// 更新数据
$updateData['updateTime'] = time();
$result = Db::name('users')
->where('id', $userId)
->update($updateData);
if ($result !== false) {
return json([
'code' => 200,
'msg' => '更新成功',
'data' => [
'updatedFields' => $updateFields
]
]);
} else {
return json(['code' => 500, 'msg' => '更新失败']);
}
} catch (\Exception $e) {
Log::error('更新用户资料失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
}
/**
* 获取当前用户的对外 API Key（没有则自动生成）
* GET /v2/store/user/api-key
*/
public function getApiKey()
{
$userId = $this->userInfo['id'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
try {
$apiKey = UserApiKeyService::bindOrGet((int)$userId);
return json([
'code' => 200,
'msg' => 'success',
'data' => ['apiKey' => $apiKey],
]);
} catch (\Exception $e) {
Log::error('获取 apiKey 失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 重新生成当前用户的对外 API Key（会覆盖旧 Key）
* POST /v2/store/user/api-key/regenerate
*/
public function regenerateApiKey()
{
$userId = $this->userInfo['id'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
try {
$apiKey = UserApiKeyService::forceGenerate((int)$userId);
return json([
'code' => 200,
'msg' => '重新生成成功，请妥善保存新 Key，旧 Key 已失效',
'data' => ['apiKey' => $apiKey],
]);
} catch (\Exception $e) {
Log::error('重新生成 apiKey 失败: ' . $e->getMessage());
return json(['code' => 500, 'msg' => '重新生成失败：' . $e->getMessage()]);
}
}
}

562
application/store/controller/VendorController.php
View File

@@ -6,26 +6,30 @@ use app\store\model\VendorPackageModel;
use app\store\model\VendorProjectModel; use app\store\model\VendorProjectModel;
use app\store\model\VendorOrderModel; use app\store\model\VendorOrderModel;
use think\facade\Log; use think\facade\Log;
use think\Db;
/** /**
* 套餐控制器 * 供应商套餐控制器
*/ */
class VendorController extends BaseController class VendorController extends BaseController
{ {
/** /**
* 获取套餐列表 * 获取供应商套餐列表
* * GET /v2/store/vendor/list
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function getList() public function getList()
{ {
try { try {
$page = $this->request->param('page', 1); $page = intval($this->request->param('page', 1));
$limit = $this->request->param('limit', 10); $limit = intval($this->request->param('limit', $this->request->param('pageSize', 10))); // 兼容 pageSize 参数
$keyword = $this->request->param('keyword', ''); $keyword = $this->request->param('keyword', '');
$status = $this->request->param('status', ''); $status = $this->request->param('status', '');
// 确保分页参数有效
if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = 10;
$where = [ $where = [
['isDel', '=', 0] ['isDel', '=', 0]
]; ];
@@ -35,41 +39,69 @@ class VendorController extends BaseController
$where[] = ['name', 'like', "%{$keyword}%"]; $where[] = ['name', 'like', "%{$keyword}%"];
} }
// 状态筛选 // 状态筛选（1=上架，0=下架）
if ($status !== '') { if ($status !== '') {
$where[] = ['status', '=', $status]; $where[] = ['status', '=', intval($status)];
} else {
// 默认只显示上架的套餐
$where[] = ['status', '=', 1];
} }
$list = VendorPackageModel::where($where) $list = VendorPackageModel::where($where)
->field('id, userId, companyId, name, originalPrice, price, discount, advancePayment, tags, description, cover, status, createTime, updateTime')
->order('id', 'desc') ->order('id', 'desc')
->page($page, $limit) ->page($page, $limit)
->select(); ->select();
$total = VendorPackageModel::where($where)->count(); $total = VendorPackageModel::where($where)->count();
// 格式化返回数据
$result = [];
foreach ($list as $item) {
$result[] = [
'id' => intval($item['id']),
'userId' => intval($item['userId'] ?? 0),
'companyId' => intval($item['companyId'] ?? 0),
'name' => $item['name'],
'originalPrice' => floatval($item['originalPrice']),
'price' => floatval($item['price']),
'discount' => $item->discount,
'advancePayment' => floatval($item['advancePayment'] ?? 0),
'tags' => $item->tags,
'description' => $item['description'] ?? '',
'cover' => $item['cover'] ?? '',
'status' => intval($item['status']),
'createTime' => !empty($item['createTime']) && is_numeric($item['createTime']) ? date('Y-m-d H:i:s', intval($item['createTime'])) : '',
'updateTime' => !empty($item['updateTime']) && is_numeric($item['updateTime']) ? date('Y-m-d H:i:s', intval($item['updateTime'])) : '',
];
}
return json([ return json([
'code' => 200, 'code' => 200,
'msg' => '获取成功', 'msg' => '获取成功',
'data' => [ 'data' => [
'list' => $list, 'list' => $result,
'total' => $total, 'total' => $total,
'page' => $page,
'limit' => $limit
] ]
]); ]);
} catch (\Exception $e) { } catch (\Exception $e) {
Log::error('获取套餐列表失败：' . $e->getMessage()); Log::error('获取供应商套餐列表失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]); return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
} }
/** /**
* 获取套餐详情 * 获取供应商套餐详情
* * GET /v2/store/vendor/detail
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function detail() public function detail()
{ {
try { try {
$id = $this->request->param('id', 0); $id = intval($this->request->param('id', 0));
if (empty($id)) { if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']); return json(['code' => 400, 'msg' => '参数错误']);
@@ -91,444 +123,116 @@ class VendorController extends BaseController
['isDel', '=', 0] ['isDel', '=', 0]
])->select(); ])->select();
$package['projects'] = $projects; // 格式化套餐信息
$packageData = [
'id' => intval($package['id']),
'userId' => intval($package['userId'] ?? 0),
'companyId' => intval($package['companyId'] ?? 0),
'name' => $package['name'],
'originalPrice' => floatval($package['originalPrice']),
'price' => floatval($package['price']),
'discount' => $package->discount,
'advancePayment' => floatval($package['advancePayment'] ?? 0),
'tags' => $package->tags,
'description' => $package['description'] ?? '',
'cover' => $package['cover'] ?? '',
'status' => intval($package['status']),
'createTime' => !empty($package['createTime']) && is_numeric($package['createTime']) ? date('Y-m-d H:i:s', intval($package['createTime'])) : '',
'updateTime' => !empty($package['updateTime']) && is_numeric($package['updateTime']) ? date('Y-m-d H:i:s', intval($package['updateTime'])) : '',
];
return json(['code' => 200, 'msg' => '获取成功', 'data' => $package]); // 格式化项目信息
$projectList = [];
foreach ($projects as $project) {
$projectList[] = [
'id' => intval($project['id']),
'packageId' => intval($project['packageId']),
'name' => $project['name'],
'originalPrice' => floatval($project['originalPrice']),
'price' => floatval($project['price']),
'duration' => intval($project['duration'] ?? 0),
'image' => $project['image'] ?? '',
'detail' => $project['detail'] ?? '',
];
}
$packageData['projects'] = $projectList;
return json(['code' => 200, 'msg' => '获取成功', 'data' => $packageData]);
} catch (\Exception $e) { } catch (\Exception $e) {
Log::error('获取套餐详情失败：' . $e->getMessage()); Log::error('获取供应商套餐详情失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]); return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
} }
/** /**
* 添加套餐 * 创建供应商订单
* * POST /v2/store/vendor/order
* @return \think\response\Json *
*/
public function add()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '套餐名称不能为空']);
}
// 检查名称是否已存在
$exists = VendorPackageModel::where([
['name', '=', $param['name']],
['isDel', '=', 0]
])->find();
if ($exists) {
return json(['code' => 400, 'msg' => '该套餐名称已存在']);
}
Db::startTrans();
try {
// 创建套餐
$package = new VendorPackageModel;
$package->name = $param['name'];
$package->originalPrice = $param['originalPrice'] ?? 0;
$package->price = $param['price'] ?? 0;
$package->discount = $param['discount'] ?? 0;
$package->advancePayment = $param['advancePayment'] ?? 0;
$package->tags = $param['tags'] ?? '';
$package->description = $param['description'] ?? '';
$package->cover = $param['cover'] ?? '';
$package->status = $param['status'] ?? 1;
$package->createTime = time();
$package->updateTime = time();
$package->save();
// 处理项目信息
if (!empty($param['projects']) && is_array($param['projects'])) {
foreach ($param['projects'] as $projectData) {
if (empty($projectData['name'])) {
continue;
}
// 创建项目
$project = new VendorProjectModel;
$project->packageId = $package->id;
$project->name = $projectData['name'];
$project->originalPrice = $projectData['originalPrice'] ?? 0;
$project->price = $projectData['price'] ?? 0;
$project->duration = $projectData['duration'] ?? 0;
$project->image = $projectData['image'] ?? '';
$project->detail = $projectData['detail'] ?? '';
$project->createTime = time();
$project->updateTime = time();
$project->save();
}
}
Db::commit();
return json(['code' => 200, 'msg' => '添加成功', 'data' => ['id' => $package->id]]);
} catch (\Exception $e) {
Db::rollback();
Log::error('添加套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('添加套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加异常：' . $e->getMessage()]);
}
}
/**
* 编辑套餐
*
* @return \think\response\Json
*/
public function edit()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '参数错误']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '套餐名称不能为空']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $param['id']],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
// 检查名称是否已存在
$exists = VendorPackageModel::where([
['name', '=', $param['name']],
['id', '<>', $param['id']],
['isDel', '=', 0]
])->find();
if ($exists) {
return json(['code' => 400, 'msg' => '该套餐名称已存在']);
}
Db::startTrans();
try {
// 更新套餐
$package->name = $param['name'];
$package->originalPrice = $param['originalPrice'] ?? $package->originalPrice;
$package->price = $param['price'] ?? $package->price;
$package->discount = $param['discount'] ?? $package->discount;
$package->advancePayment = $param['advancePayment'] ?? $package->advancePayment;
$package->tags = $param['tags'] ?? $package->tags;
$package->description = $param['description'] ?? $package->description;
$package->cover = $param['cover'] ?? $package->cover;
$package->status = $param['status'] ?? $package->status;
$package->updateTime = time();
$package->save();
Db::commit();
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Db::rollback();
Log::error('更新套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('编辑套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '编辑异常：' . $e->getMessage()]);
}
}
/**
* 删除套餐
*
* @return \think\response\Json
*/
public function delete()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $id],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
Db::startTrans();
try {
// 软删除套餐
$package->isDel = 1;
$package->updateTime = time();
$package->save();
// 软删除关联的项目
VendorProjectModel::where('packageId', $id)
->update([
'isDel' => 1,
'updateTime' => time()
]);
Db::commit();
return json(['code' => 200, 'msg' => '删除成功']);
} catch (\Exception $e) {
Db::rollback();
Log::error('删除套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('删除套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除异常：' . $e->getMessage()]);
}
}
/**
* 添加项目
*
* @return \think\response\Json
*/
public function addProject()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['packageId'])) {
return json(['code' => 400, 'msg' => '套餐ID不能为空']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '项目名称不能为空']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $param['packageId']],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
try {
// 创建项目
$project = new VendorProjectModel;
$project->packageId = $param['packageId'];
$project->name = $param['name'];
$project->originalPrice = $param['originalPrice'] ?? 0;
$project->price = $param['price'] ?? 0;
$project->duration = $param['duration'] ?? 0;
$project->image = $param['image'] ?? '';
$project->detail = $param['detail'] ?? '';
$project->createTime = time();
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '添加成功', 'data' => ['id' => $project->id]]);
} catch (\Exception $e) {
Log::error('添加项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('添加项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加异常：' . $e->getMessage()]);
}
}
/**
* 编辑项目
*
* @return \think\response\Json
*/
public function editProject()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '项目ID不能为空']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '项目名称不能为空']);
}
// 检查项目是否存在
$project = VendorProjectModel::where([
['id', '=', $param['id']],
['isDel', '=', 0]
])->find();
if (!$project) {
return json(['code' => 404, 'msg' => '项目不存在']);
}
try {
// 更新项目
$project->name = $param['name'];
$project->originalPrice = $param['originalPrice'] ?? $project->originalPrice;
$project->price = $param['price'] ?? $project->price;
$project->duration = $param['duration'] ?? $project->duration;
$project->image = $param['image'] ?? $project->image;
$project->detail = $param['detail'] ?? $project->detail;
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Log::error('更新项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('编辑项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '编辑异常：' . $e->getMessage()]);
}
}
/**
* 删除项目
*
* @return \think\response\Json
*/
public function deleteProject()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 检查项目是否存在
$project = VendorProjectModel::where([
['id', '=', $id],
['isDel', '=', 0]
])->find();
if (!$project) {
return json(['code' => 404, 'msg' => '项目不存在']);
}
try {
// 软删除项目
$project->isDel = 1;
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '删除成功']);
} catch (\Exception $e) {
Log::error('删除项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('删除项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除异常：' . $e->getMessage()]);
}
}
/**
* 创建订单
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function createOrder() public function createOrder()
{ {
try { try {
if (!$this->request->isPost()) { $packageId = intval($this->request->param('packageId', 0));
return json(['code' => 400, 'msg' => '请求方式错误']); $remark = $this->request->param('remark', '');
}
$param = $this->request->post(); if (empty($packageId)) {
// 参数验证
if (empty($param['packageId'])) {
return json(['code' => 400, 'msg' => '套餐ID不能为空']); return json(['code' => 400, 'msg' => '套餐ID不能为空']);
} }
// 检查套餐是否存在 // 获取用户信息
$package = VendorPackageModel::where([ $userId = $this->userInfo['id'] ?? 0;
['id', '=', $param['packageId']], $companyId = $this->userInfo['companyId'] ?? 0;
['isDel', '=', 0],
['status', '=', 1]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在或已下架']);
}
// 获取当前用户信息
$userId = $this->request->userInfo['id'];
if (empty($userId)) { if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']); return json(['code' => 401, 'msg' => '请先登录']);
} }
Db::startTrans(); if (empty($companyId)) {
try { return json(['code' => 400, 'msg' => '公司信息不存在']);
// 生成订单
$order = new VendorOrderModel;
$order->orderNo = VendorOrderModel::generateOrderNo();
$order->userId = $userId;
$order->packageId = $package->id;
$order->packageName = $package->name;
$order->totalAmount = $package->price;
$order->payAmount = $package->price;
$order->advancePayment = $package->advancePayment;
$order->status = VendorOrderModel::STATUS_UNPAID;
$order->remark = $param['remark'] ?? '';
$order->createTime = time();
$order->updateTime = time();
$order->save();
Db::commit();
return json([
'code' => 200,
'msg' => '订单创建成功',
'data' => [
'orderId' => $order->id,
'orderNo' => $order->orderNo
]
]);
} catch (\Exception $e) {
Db::rollback();
Log::error('创建订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '创建订单失败：' . $e->getMessage()]);
} }
// 检查套餐是否存在且上架
$package = VendorPackageModel::where([
['id', '=', $packageId],
['isDel', '=', 0],
['status', '=', 1]
])->find();
if (empty($package)) {
return json(['code' => 404, 'msg' => '套餐不存在或已下架']);
}
// 创建订单
$order = VendorOrderModel::createOrder(
$userId,
$companyId,
$package->id,
$package->name,
floatval($package->price),
floatval($package->price),
floatval($package->advancePayment ?? 0),
$remark
);
if (!$order) {
return json(['code' => 500, 'msg' => '订单创建失败']);
}
return json([
'code' => 200,
'msg' => '订单创建成功',
'data' => [
'orderId' => intval($order['id']),
'orderNo' => $order['orderNo']
]
]);
} catch (\Exception $e) { } catch (\Exception $e) {
Log::error('创建订单异常：' . $e->getMessage()); Log::error('创建供应商订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '创建订单异常：' . $e->getMessage()]); return json(['code' => 500, 'msg' => '创建订单失败：' . $e->getMessage()]);
} }
} }
} }

248
application/store/controller/VendorOrderController.php
View File

@@ -2,35 +2,44 @@
namespace app\store\controller; namespace app\store\controller;
use app\store\model\VendorOrderModel;
use app\store\model\VendorPackageModel; use app\store\model\VendorPackageModel;
use app\store\model\VendorProjectModel; use app\store\model\VendorProjectModel;
use app\store\model\VendorOrderModel;
use think\facade\Log; use think\facade\Log;
use think\Db;
/** /**
* 订单控制器 * 供应商订单控制器
*/ */
class VendorOrderController extends BaseController class VendorOrderController extends BaseController
{ {
/** /**
* 获取订单列表 * 获取订单列表
* * GET /v2/store/vendor/orders
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function getList() public function getList()
{ {
try { try {
$page = $this->request->param('page', 1); $page = intval($this->request->param('page', 1));
$limit = $this->request->param('limit', 10); $limit = intval($this->request->param('limit', $this->request->param('pageSize', 10))); // 兼容 pageSize 参数
$status = $this->request->param('status', ''); $status = $this->request->param('status', '');
$keyword = $this->request->param('keyword', ''); $keyword = $this->request->param('keyword', '');
// 获取当前用户信息 // 确保分页参数有效
$userId = $this->request->userInfo['id']; if ($page <= 0) $page = 1;
if ($limit <= 0) $limit = 10;
$userId = $this->userInfo['id'] ?? 0;
$companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
$where = [ $where = [
['userId', '=', $userId] ['userId', '=', $userId],
['companyId', '=', $companyId], // 按公司ID查询
]; ];
// 关键词搜索 // 关键词搜索
@@ -40,22 +49,42 @@ class VendorOrderController extends BaseController
// 状态筛选 // 状态筛选
if ($status !== '') { if ($status !== '') {
$where[] = ['status', '=', $status]; $where[] = ['status', '=', intval($status)];
} }
$list = VendorOrderModel::with(['package']) $list = VendorOrderModel::where($where)
->where($where)
->order('id', 'desc') ->order('id', 'desc')
->page($page, $limit) ->page($page, $limit)
->select(); ->select();
$total = VendorOrderModel::where($where)->count(); $total = VendorOrderModel::where($where)->count();
// 格式化数据
$result = [];
foreach ($list as $item) {
$result[] = [
'id' => intval($item['id']),
'orderNo' => $item['orderNo'],
'userId' => intval($item['userId']),
'companyId' => intval($item['companyId'] ?? 0),
'packageId' => intval($item['packageId']),
'packageName' => $item['packageName'],
'totalAmount' => floatval($item['totalAmount']),
'payAmount' => floatval($item['payAmount']),
'advancePayment' => floatval($item['advancePayment'] ?? 0),
'status' => intval($item['status']),
'payTime' => !empty($item['payTime']) && is_numeric($item['payTime']) ? date('Y-m-d H:i:s', intval($item['payTime'])) : '',
'remark' => $item['remark'] ?? '',
'createTime' => !empty($item['createTime']) && is_numeric($item['createTime']) ? date('Y-m-d H:i:s', intval($item['createTime'])) : '',
'updateTime' => !empty($item['updateTime']) && is_numeric($item['updateTime']) ? date('Y-m-d H:i:s', intval($item['updateTime'])) : '',
];
}
return json([ return json([
'code' => 200, 'code' => 200,
'msg' => '获取成功', 'msg' => '获取成功',
'data' => [ 'data' => [
'list' => $list, 'list' => $result,
'total' => $total, 'total' => $total,
'page' => $page, 'page' => $page,
'limit' => $limit 'limit' => $limit
@@ -69,161 +98,148 @@ class VendorOrderController extends BaseController
/** /**
* 获取订单详情 * 获取订单详情
* * GET /v2/store/vendor/orders/:id
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function detail() public function detail()
{ {
try { try {
$id = $this->request->param('id', 0); $id = intval($this->request->param('id', 0));
if (empty($id)) { if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']); return json(['code' => 400, 'msg' => '参数错误']);
} }
// 获取当前用户信息 $userId = $this->userInfo['id'] ?? 0;
$userId = $this->request->userInfo['id']; $companyId = $this->userInfo['companyId'] ?? 0;
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 查询订单 // 查询订单
$order = VendorOrderModel::with(['package']) $order = VendorOrderModel::where([
->where([ ['id', '=', $id],
['id', '=', $id], ['userId', '=', $userId],
['userId', '=', $userId] ['companyId', '=', $companyId]
])->find(); ])->find();
if (empty($order)) { if (empty($order)) {
return json(['code' => 404, 'msg' => '订单不存在']); return json(['code' => 404, 'msg' => '订单不存在']);
} }
// 查询套餐信息
$package = VendorPackageModel::where([
['id', '=', $order['packageId']],
['isDel', '=', 0]
])->find();
// 查询套餐项目 // 查询套餐项目
if (!empty($order['package'])) { $projects = [];
if ($package) {
$projects = VendorProjectModel::where([ $projects = VendorProjectModel::where([
['packageId', '=', $order['packageId']], ['packageId', '=', $order['packageId']],
['isDel', '=', 0] ['isDel', '=', 0]
])->select(); ])->select();
$order['package']['projects'] = $projects;
} }
return json(['code' => 200, 'msg' => '获取成功', 'data' => $order]); // 格式化订单信息
$orderData = [
'id' => intval($order['id']),
'orderNo' => $order['orderNo'],
'userId' => intval($order['userId']),
'companyId' => intval($order['companyId'] ?? 0),
'packageId' => intval($order['packageId']),
'packageName' => $order['packageName'],
'totalAmount' => floatval($order['totalAmount']),
'payAmount' => floatval($order['payAmount']),
'advancePayment' => floatval($order['advancePayment'] ?? 0),
'status' => intval($order['status']),
'payTime' => !empty($order['payTime']) && is_numeric($order['payTime']) ? date('Y-m-d H:i:s', intval($order['payTime'])) : '',
'remark' => $order['remark'] ?? '',
'createTime' => !empty($order['createTime']) && is_numeric($order['createTime']) ? date('Y-m-d H:i:s', intval($order['createTime'])) : '',
'updateTime' => !empty($order['updateTime']) && is_numeric($order['updateTime']) ? date('Y-m-d H:i:s', intval($order['updateTime'])) : '',
];
// 添加套餐信息
if ($package) {
$orderData['package'] = [
'id' => intval($package['id']),
'name' => $package['name'],
'originalPrice' => floatval($package['originalPrice']),
'price' => floatval($package['price']),
'description' => $package['description'] ?? '',
'cover' => $package['cover'] ?? '',
];
}
// 添加项目列表
$projectList = [];
foreach ($projects as $project) {
$projectList[] = [
'id' => intval($project['id']),
'name' => $project['name'],
'originalPrice' => floatval($project['originalPrice']),
'price' => floatval($project['price']),
'duration' => intval($project['duration'] ?? 0),
'image' => $project['image'] ?? '',
'detail' => $project['detail'] ?? '',
];
}
$orderData['package']['projects'] = $projectList;
return json(['code' => 200, 'msg' => '获取成功', 'data' => $orderData]);
} catch (\Exception $e) { } catch (\Exception $e) {
Log::error('获取订单详情失败：' . $e->getMessage()); Log::error('获取订单详情失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]); return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
} }
} }
/**
* 更新订单状态
*
* @return \think\response\Json
*/
public function updateStatus()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '订单ID不能为空']);
}
if (!isset($param['status'])) {
return json(['code' => 400, 'msg' => '订单状态不能为空']);
}
// 检查订单是否存在
$order = VendorOrderModel::where('id', $param['id'])->find();
if (!$order) {
return json(['code' => 404, 'msg' => '订单不存在']);
}
// 检查状态是否有效
$validStatus = [
VendorOrderModel::STATUS_UNPAID,
VendorOrderModel::STATUS_PAID,
VendorOrderModel::STATUS_COMPLETED,
VendorOrderModel::STATUS_CANCELED
];
if (!in_array($param['status'], $validStatus)) {
return json(['code' => 400, 'msg' => '无效的订单状态']);
}
// 更新订单状态
$updateData = [
'status' => $param['status'],
'updateTime' => time()
];
// 如果订单状态为已支付，记录支付时间
if ($param['status'] == VendorOrderModel::STATUS_PAID) {
$updateData['payTime'] = time();
}
try {
$order->save($updateData);
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Log::error('更新订单状态失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('更新订单状态异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新异常：' . $e->getMessage()]);
}
}
/** /**
* 取消订单 * 取消订单
* * POST /v2/store/vendor/orders/:id/cancel
*
* @return \think\response\Json * @return \think\response\Json
*/ */
public function cancel() public function cancel()
{ {
try { try {
if (!$this->request->isPost()) { $id = intval($this->request->param('id', 0));
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$id = $this->request->param('id', 0);
if (empty($id)) { if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']); return json(['code' => 400, 'msg' => '参数错误']);
} }
// 获取当前用户信息 $userId = $this->userInfo['id'] ?? 0;
$userId = $this->request->userInfo['id']; $companyId = $this->userInfo['companyId'] ?? 0;
// 检查订单是否存在 if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
// 检查订单是否存在且为待支付状态
$order = VendorOrderModel::where([ $order = VendorOrderModel::where([
['id', '=', $id], ['id', '=', $id],
['userId', '=', $userId], ['userId', '=', $userId],
['companyId', '=', $companyId],
['status', '=', VendorOrderModel::STATUS_UNPAID] ['status', '=', VendorOrderModel::STATUS_UNPAID]
])->find(); ])->find();
if (!$order) { if (empty($order)) {
return json(['code' => 404, 'msg' => '订单不存在或状态不允许取消']); return json(['code' => 404, 'msg' => '订单不存在或状态不允许取消']);
} }
try { // 更新订单状态为已取消
// 更新订单状态为已取消 $order->status = VendorOrderModel::STATUS_CANCELED;
$order->status = VendorOrderModel::STATUS_CANCELED; $order->updateTime = time();
$order->updateTime = time(); $order->save();
$order->save();
return json(['code' => 200, 'msg' => '取消成功']);
return json(['code' => 200, 'msg' => '取消成功']);
} catch (\Exception $e) {
Log::error('取消订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '取消失败：' . $e->getMessage()]);
}
} catch (\Exception $e) { } catch (\Exception $e) {
Log::error('取消订单异常：' . $e->getMessage()); Log::error('取消订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '取消异常：' . $e->getMessage()]); return json(['code' => 500, 'msg' => '取消失败：' . $e->getMessage()]);
} }
} }
} }

230
application/store/create_and_move_agent.py Normal file
View File

@@ -0,0 +1,230 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""自动创建Agent管理目录并移动接口"""
import sys
import requests
import json
import time
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版
AGENT_API_IDS = [415861964, 415861967] # 已上传的Agent接口ID
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("自动创建Agent管理目录并移动接口")
print("=" * 80)
# 步骤1: 检查是否已存在Agent管理目录
print("\n[1/4] 检查现有目录...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
agent_folder_id = None
if response.status_code == 200:
tree_data = response.json().get('data', [])
def find_agent_folder(items):
for item in items:
if item.get('type') == 'apiDetailFolder':
folder = item.get('folder', {})
if item.get('name') == 'Agent管理' and folder.get('parentId') == int(PARENT_FOLDER_ID):
return folder.get('id')
for child in item.get('children', []):
result = find_agent_folder([child])
if result:
return result
return None
agent_folder_id = find_agent_folder(tree_data)
if agent_folder_id:
print(f" ✓ 找到现有'Agent管理'目录 (ID: {agent_folder_id})")
else:
print(f" ✗ 未找到'Agent管理'目录，开始创建...")
# 步骤2: 尝试多种方法创建目录
print("\n[2/4] 尝试创建目录...")
# 方法1: 使用 api-details-folders 端点（最常用）
create_methods = [
{
"name": "api-details-folders",
"url": f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-details-folders",
"data": {
"name": "Agent管理",
"parentId": int(PARENT_FOLDER_ID)
}
},
{
"name": "folders (with type)",
"url": f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/folders",
"data": {
"name": "Agent管理",
"parentId": int(PARENT_FOLDER_ID),
"type": "apiDetailFolder"
}
},
{
"name": "folders (simple)",
"url": f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/folders",
"data": {
"name": "Agent管理",
"parentId": int(PARENT_FOLDER_ID)
}
}
]
for method in create_methods:
print(f"\n 尝试方法: {method['name']}")
try:
create_resp = requests.post(
method['url'],
headers=headers,
json=method['data'],
timeout=10
)
print(f" 状态码: {create_resp.status_code}")
if create_resp.status_code == 200:
try:
result = create_resp.json()
if result.get('success') and 'data' in result:
agent_folder_id = result['data'].get('id')
print(f" ✓ 成功创建目录 (ID: {agent_folder_id})")
break
else:
print(f" ✗ 响应: {json.dumps(result, ensure_ascii=False)}")
except json.JSONDecodeError:
# 检查是否是重定向响应
if 'window.location.href' in create_resp.text:
print(f" ✗ API重定向（可能被限制）")
else:
print(f" ✗ 非JSON响应: {create_resp.text[:100]}")
elif create_resp.status_code == 201:
# 201 Created
try:
result = create_resp.json()
agent_folder_id = result.get('id') or result.get('data', {}).get('id')
if agent_folder_id:
print(f" ✓ 成功创建目录 (ID: {agent_folder_id})")
break
except:
print(f" ✗ 无法解析响应")
else:
print(f" ✗ HTTP {create_resp.status_code}: {create_resp.text[:200]}")
except Exception as e:
print(f" ✗ 异常: {str(e)}")
time.sleep(0.5)
# 如果所有方法都失败，尝试使用导入OpenAPI的方式
if not agent_folder_id:
print("\n 尝试方法: OpenAPI导入（带目录结构）")
# 这个方法需要先准备OpenAPI文件，暂时跳过
print(" ⚠️ 需要准备OpenAPI文件，跳过此方法")
# 步骤3: 如果创建成功，移动接口
if agent_folder_id:
print(f"\n[3/4] 移动接口到'Agent管理'目录 (ID: {agent_folder_id})...")
print("-" * 80)
success_count = 0
fail_count = 0
for i, api_id in enumerate(AGENT_API_IDS, 1):
print(f"\n [{i}/{len(AGENT_API_IDS)}] 移动接口 {api_id}...")
try:
move_resp = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json={"folderId": int(agent_folder_id)},
timeout=10
)
if move_resp.status_code == 200:
result = move_resp.json()
if result.get('success'):
success_count += 1
print(f" ✓ 移动成功")
else:
fail_count += 1
print(f" ✗ 失败: {result.get('errorMessage', '未知错误')}")
else:
fail_count += 1
print(f" ✗ HTTP {move_resp.status_code}")
print(f" {move_resp.text[:200]}")
except Exception as e:
fail_count += 1
print(f" ✗ 异常: {str(e)}")
time.sleep(0.3)
# 步骤4: 验证结果
print(f"\n[4/4] 验证结果...")
verify_resp = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
if verify_resp.status_code == 200:
tree_data = verify_resp.json().get('data', [])
agent_folder = None
def find_folder(items):
for item in items:
if item.get('type') == 'apiDetailFolder':
folder = item.get('folder', {})
if folder.get('id') == agent_folder_id:
return item
for child in item.get('children', []):
result = find_folder([child])
if result:
return result
return None
agent_folder = find_folder(tree_data)
if agent_folder:
api_count = len([c for c in agent_folder.get('children', []) if c.get('type') == 'apiDetail'])
print(f" ✓ 目录存在，包含 {api_count} 个接口")
else:
print(f" ⚠️ 目录存在但无法在树中找到")
print("\n" + "=" * 80)
print("完成！")
print("=" * 80)
print(f"✓ 成功移动: {success_count} 个接口")
print(f"✗ 失败: {fail_count} 个接口")
if success_count > 0:
print(f"\n✨ Agent接口已整理到'Agent管理'目录")
print(f"📁 目录ID: {agent_folder_id}")
print(f"🌐 访问查看: https://app.apifox.com/project/{PROJECT_ID}")
else:
print("\n" + "=" * 80)
print("⚠️ 无法自动创建目录")
print("=" * 80)
print("\n可能的原因:")
print("1. Apifox API对目录创建有限制")
print("2. Token权限不足")
print("3. 需要使用Web界面手动创建")
print("\n建议操作:")
print("1. 打开 https://app.apifox.com/project/6037107")
print("2. 在'门店端-新版'下创建'Agent管理'目录")
print("3. 运行: python move_to_agent_folder.py <目录ID>")
print("\n" + "=" * 80)

193
application/store/create_traffic_folder.py Normal file
View File

@@ -0,0 +1,193 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
STORE_FOLDER_ID = "78015216" # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 流量采购接口ID列表
TRAFFIC_API_IDS = [
"415976880", # 获取可购买的流量池包列表
"415976882", # 获取流量池包详情
"415977273", # 购买流量
"415976885", # 获取已购买的流量列表
"415976886", # 获取购买记录列表
"415976889", # 获取购买记录详情
"415976892" # 获取流量采购统计
]
def get_folder_tree():
"""获取项目目录树"""
try:
response = requests.get(
f"{BASE_URL}/projects/{PROJECT_ID}/api-tree-list",
headers=headers,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return result.get('data', [])
return []
except Exception as e:
print(f"获取目录树失败: {e}")
return []
def create_folder(parent_id, name):
"""创建目录"""
try:
data = {
"name": name,
"parentId": parent_id,
"type": "http"
}
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/folders",
headers=headers,
json=data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return result.get('data', {}).get('id'), None
else:
return None, result.get('errorMessage', 'Unknown error')
else:
return None, f"HTTP {response.status_code}: {response.text[:200]}"
except Exception as e:
return None, str(e)
def find_folder_by_name(tree, name, parent_id=None):
"""在目录树中查找指定名称的目录"""
for item in tree:
if item.get('type') == 'folder':
item_id = item.get('id')
item_name = item.get('name', '')
item_parent = item.get('parentId')
# 检查是否匹配
if item_name == name:
if parent_id is None or item_parent == parent_id:
return item_id
# 递归查找子目录
children = item.get('children', [])
if children:
found = find_folder_by_name(children, name, parent_id)
if found:
return found
return None
def move_api(api_id, folder_id):
"""移动API到指定目录"""
try:
# 先获取API详情
response = requests.get(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
timeout=30
)
if response.status_code != 200:
return False, f"获取API失败: HTTP {response.status_code}"
api_data = response.json().get('data')
if not api_data:
return False, "API不存在"
# 更新folderId
api_data['folderId'] = folder_id
# 更新API
update_response = requests.put(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json=api_data,
timeout=30
)
if update_response.status_code == 200:
result = update_response.json()
if result.get('success'):
return True, None
else:
return False, result.get('errorMessage', 'Unknown error')
else:
return False, f"HTTP {update_response.status_code}: {update_response.text[:200]}"
except Exception as e:
return False, str(e)
print("=" * 60)
print("创建流量采购管理目录并移动接口...")
print("=" * 60)
# 1. 获取目录树
print("\n【1/3】获取目录树...")
tree = get_folder_tree()
if not tree:
print("❌ 无法获取目录树")
sys.exit(1)
print("✅ 目录树获取成功")
# 2. 检查目录是否已存在
print("\n【2/3】检查目录是否已存在...")
existing_folder_id = find_folder_by_name(tree, "流量采购管理", STORE_FOLDER_ID)
if existing_folder_id:
print(f"✅ 目录已存在 (ID: {existing_folder_id})")
folder_id = existing_folder_id
else:
print("📁 目录不存在，开始创建...")
folder_id, error = create_folder(STORE_FOLDER_ID, "流量采购管理")
if folder_id:
print(f"✅ 目录创建成功 (ID: {folder_id})")
else:
print(f"❌ 目录创建失败: {error}")
print("\n⚠️ 如果API创建失败，请手动在Apifox Web界面创建目录")
print(f" 目录名称: 流量采购管理")
print(f" 父目录: 门店端-新版 (ID: {STORE_FOLDER_ID})")
sys.exit(1)
# 3. 移动接口
print(f"\n【3/3】移动接口到目录 (ID: {folder_id})...")
success_count = 0
fail_count = 0
for i, api_id in enumerate(TRAFFIC_API_IDS, 1):
print(f" [{i}/{len(TRAFFIC_API_IDS)}] 移动接口 (ID: {api_id})...", end=" ")
success, error = move_api(api_id, folder_id)
if success:
print("✅")
success_count += 1
else:
print(f"❌ {error}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 完成！")
print(f"\n📊 统计:")
print(f" - 目录ID: {folder_id}")
print(f" - 成功移动: {success_count}/{len(TRAFFIC_API_IDS)}")
print(f" - 失败: {fail_count}")
if fail_count > 0:
print(f"\n⚠️ 有 {fail_count} 个接口移动失败")
print(" 如果API移动失败，请手动在Apifox Web界面移动接口")
print(f" 目标目录: 流量采购管理 (ID: {folder_id})")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print(f" 流量采购管理目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
print("=" * 60)

114
application/store/create_vendor_folder.py Normal file
View File

@@ -0,0 +1,114 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
import os
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
folder_name = "供应链采购管理"
description = "供应链采购管理相关接口"
print("=" * 60)
print(f"创建目录: {folder_name}")
print("=" * 60)
# 通过导入OpenAPI创建目录
openapi_spec = {
"openapi": "3.0.0",
"info": {
"title": "供应链采购管理目录创建",
"version": "1.0.0"
},
"tags": [
{
"name": folder_name,
"description": description
}
],
"paths": {
f"/api/__placeholder__/supply-chain": {
"get": {
"summary": f"[占位] {folder_name} 目录占位接口",
"description": "这是一个占位接口，用于创建目录。可以在 Apifox 中手动删除。",
"tags": [folder_name],
"responses": {
"200": {
"description": "占位响应"
}
}
}
}
}
}
payload = {
"input": json.dumps(openapi_spec, ensure_ascii=False),
"options": {
"targetEndpointFolderId": int(PARENT_FOLDER_ID), # 指定父目录
"endpointOverwriteBehavior": "CREATE_NEW"
}
}
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/import-openapi",
headers=headers,
json=payload,
params={"locale": "zh-CN"},
timeout=30
)
print(f"\nHTTP状态码: {response.status_code}")
print(f"响应内容: {response.text[:1000]}")
if response.status_code == 200:
try:
result = response.json()
except:
print("⚠️ 响应不是JSON格式，可能是重定向或HTML")
print(" 目录可能已创建，请在Apifox Web UI中查看")
sys.exit(0)
print(f"响应: {json.dumps(result, ensure_ascii=False, indent=2)[:500]}")
if result.get('success'):
counters = result.get('data', {}).get('counters', {})
endpoint_folder_created = counters.get('endpointFolderCreated', 0)
endpoint_created = counters.get('endpointCreated', 0)
if endpoint_folder_created > 0:
print(f"\n✅ 目录创建成功！")
print(f" 已创建 {endpoint_folder_created} 个目录")
print(f" 已创建 {endpoint_created} 个占位接口")
print(f"\n💡 提示: 占位接口可以在 Apifox Web UI 中手动删除")
elif endpoint_created > 0:
print(f"\n⚠️ 目录可能已存在")
print(f" 已创建 {endpoint_created} 个占位接口")
print(f"\n💡 提示: 请在 Apifox Web UI 中查看目录是否已创建")
else:
print(f"\n⚠️ 未创建目录或接口")
else:
print(f"\n❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
else:
print(f"\n❌ HTTP {response.status_code}")
print(f"响应内容: {response.text[:500]}")
except Exception as e:
print(f"\n❌ 异常: {str(e)}")
import traceback
traceback.print_exc()
print("\n" + "=" * 60)

26
application/store/database_traffic_purchase_record.sql Normal file
View File

@@ -0,0 +1,26 @@
-- 流量采购购买记录表
CREATE TABLE IF NOT EXISTS `ck_traffic_purchase_record` (
`id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`orderNo` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '订单编号',
`companyId` int(11) NOT NULL DEFAULT 0 COMMENT '购买公司ID',
`userId` int(11) NOT NULL DEFAULT 0 COMMENT '购买用户ID',
`packageId` int(11) NOT NULL DEFAULT 0 COMMENT '流量池包ID',
`packageName` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL DEFAULT '' COMMENT '流量池包名称',
`totalCount` int(11) NOT NULL DEFAULT 0 COMMENT '总流量数量',
`successCount` int(11) NOT NULL DEFAULT 0 COMMENT '成功购买数量',
`skipCount` int(11) NOT NULL DEFAULT 0 COMMENT '跳过数量（重复）',
`status` tinyint(1) NOT NULL DEFAULT 1 COMMENT '状态：1=成功，2=部分成功，3=失败',
`remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '备注',
`createTime` int(11) NOT NULL DEFAULT 0 COMMENT '创建时间',
`updateTime` int(11) NOT NULL DEFAULT 0 COMMENT '更新时间',
`isDel` tinyint(1) NOT NULL DEFAULT 0 COMMENT '是否删除：0=否，1=是',
`deleteTime` int(11) NOT NULL DEFAULT 0 COMMENT '删除时间',
PRIMARY KEY (`id`) USING BTREE,
UNIQUE INDEX `uk_order_no`(`orderNo`) USING BTREE,
INDEX `idx_company_id`(`companyId`) USING BTREE,
INDEX `idx_user_id`(`userId`) USING BTREE,
INDEX `idx_package_id`(`packageId`) USING BTREE,
INDEX `idx_create_time`(`createTime`) USING BTREE,
INDEX `idx_status`(`status`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '流量采购购买记录表' ROW_FORMAT = Dynamic;

170
application/store/final_organize_agent.py Normal file
View File

@@ -0,0 +1,170 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
最终方案：自动整理Agent接口
由于Apifox API对目录创建有限制，提供两种方案：
1. 手动创建目录后自动移动接口（推荐）
2. 使用OpenAPI导入（如果API权限足够）
"""
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = 78015216 # 门店端-新版
AGENT_API_IDS = [415861964, 415861967] # 已上传的Agent接口ID
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("Agent接口整理工具")
print("=" * 80)
# 方案1: 检查是否已存在Agent管理目录
print("\n[方案1] 检查现有目录...")
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
agent_folder_id = None
if response.status_code == 200:
tree_data = response.json().get('data', [])
def find_agent_folder(items):
for item in items:
if item.get('type') == 'apiDetailFolder':
folder = item.get('folder', {})
if item.get('name') == 'Agent管理' and folder.get('parentId') == int(PARENT_FOLDER_ID):
return folder.get('id')
for child in item.get('children', []):
result = find_agent_folder([child])
if result:
return result
return None
agent_folder_id = find_agent_folder(tree_data)
if agent_folder_id:
print(f" ✓ 找到'Agent管理'目录 (ID: {agent_folder_id})")
print(f"\n开始移动接口...")
success = 0
failed = 0
for i, api_id in enumerate(AGENT_API_IDS, 1):
print(f"\n [{i}/{len(AGENT_API_IDS)}] 移动接口 {api_id}...")
try:
move_resp = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json={"folderId": int(agent_folder_id)},
timeout=10
)
if move_resp.status_code == 200:
try:
result = move_resp.json()
if result.get('success'):
success += 1
print(f" ✓ 移动成功")
else:
failed += 1
print(f" ✗ 失败: {result.get('errorMessage', '未知错误')}")
except json.JSONDecodeError:
# 检查响应内容
if move_resp.text.strip():
print(f" ⚠️ 响应不是JSON: {move_resp.text[:200]}")
# 如果响应是空或特殊格式，可能已经成功
if move_resp.text.strip() == '' or 'success' in move_resp.text.lower():
success += 1
print(f" ✓ 可能已移动成功（响应格式异常）")
else:
failed += 1
else:
# 空响应可能表示成功
success += 1
print(f" ✓ 移动成功（空响应）")
else:
failed += 1
print(f" ✗ HTTP {move_resp.status_code}: {move_resp.text[:200]}")
except Exception as e:
failed += 1
print(f" ✗ 异常: {str(e)}")
print("\n" + "=" * 80)
print("完成！")
print("=" * 80)
print(f"✓ 成功移动: {success} 个接口")
print(f"✗ 失败: {failed} 个接口")
if success > 0:
print(f"\n✨ Agent接口已整理到'Agent管理'目录")
print(f"📁 目录ID: {agent_folder_id}")
print(f"🌐 访问查看: https://app.apifox.com/project/{PROJECT_ID}")
else:
print(" ✗ 未找到'Agent管理'目录")
print("\n" + "=" * 80)
print("请选择操作方式：")
print("=" * 80)
print("\n【方式A】手动创建目录后移动接口（推荐）")
print(" 1. 打开 https://app.apifox.com/project/6037107")
print(" 2. 在'门店端-新版'下创建'Agent管理'目录")
print(" 3. 运行: python final_organize_agent.py <目录ID>")
print("\n【方式B】直接提供目录ID")
print(" 如果你已经知道目录ID，直接运行:")
print(f" python move_to_agent_folder.py <目录ID>")
print("\n" + "=" * 80)
# 如果提供了命令行参数（目录ID）
if len(sys.argv) > 1:
folder_id = sys.argv[1]
print(f"\n使用提供的目录ID: {folder_id}")
print("开始移动接口...")
success = 0
failed = 0
for i, api_id in enumerate(AGENT_API_IDS, 1):
print(f"\n [{i}/{len(AGENT_API_IDS)}] 移动接口 {api_id}...")
try:
move_resp = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json={"folderId": int(folder_id)},
timeout=10
)
if move_resp.status_code == 200:
result = move_resp.json()
if result.get('success'):
success += 1
print(f" ✓ 移动成功")
else:
failed += 1
print(f" ✗ 失败: {result.get('errorMessage', '未知错误')}")
else:
failed += 1
print(f" ✗ HTTP {move_resp.status_code}")
except Exception as e:
failed += 1
print(f" ✗ 异常: {str(e)}")
print("\n" + "=" * 80)
print("完成！")
print("=" * 80)
print(f"✓ 成功移动: {success} 个接口")
print(f"✗ 失败: {failed} 个接口")
print("\n" + "=" * 80)

77
application/store/find_auth_folder.py Normal file
View File

@@ -0,0 +1,77 @@
# -*- coding: utf-8 -*-
"""查找门店端-新版下的认证目录"""
import requests
import json
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = 78015216 # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}"
}
print("查询目录结构...")
# 获取完整目录树
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
def find_folder_in_tree(node, parent_id):
"""在目录树中查找指定父目录下的所有子目录"""
folders = []
if isinstance(node, list):
for item in node:
folders.extend(find_folder_in_tree(item, parent_id))
return folders
if isinstance(node, dict):
if node.get('type') == 'apiDetailFolder':
folder = node.get('folder', {})
folder_parent_id = folder.get('parentId')
# 如果是目标父目录的子目录
if folder_parent_id == parent_id:
folder_info = {
'id': folder.get('id'),
'name': node.get('name'),
'parentId': folder_parent_id
}
folders.append(folder_info)
print(f" 找到子目录: {folder_info['name']} (ID: {folder_info['id']})")
# 也显示父目录本身
if folder.get('id') == parent_id:
print(f"\n父目录: {node.get('name')} (ID: {folder.get('id')})")
print(f"子目录:")
# 递归处理子节点
for child in node.get('children', []):
folders.extend(find_folder_in_tree(child, parent_id))
return folders
if response.status_code == 200:
data = response.json().get('data', [])
folders = find_folder_in_tree(data, PARENT_FOLDER_ID)
print(f"\n共找到 {len(folders)} 个子目录")
# 查找"认证"目录
auth_folder = next((f for f in folders if f['name'] == '认证'), None)
if auth_folder:
print(f"\n✓ '认证' 目录已存在: ID = {auth_folder['id']}")
# 保存ID供后续使用
with open('auth_folder_id.txt', 'w') as f:
f.write(str(auth_folder['id']))
else:
print("\n✗ '认证' 目录不存在，需要创建")
else:
print(f"错误: {response.status_code}")

110
application/store/fix_failed_apis.py Normal file
View File

@@ -0,0 +1,110 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 失败的API ID
FAILED_API_IDS = {
"passwordLogin": "415781876",
"noPasswordLogin": "415781877",
"getModules": "415861964",
"purchase": None # 这个需要重新创建
}
def get_api(api_id):
"""获取API详情"""
try:
response = requests.get(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return result.get('data')
return None
except Exception as e:
print(f"获取API失败: {e}")
return None
def update_api_simple(api_id, updates):
"""简单更新API（只更新描述等字段）"""
try:
response = requests.patch(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json=updates,
timeout=30
)
if response.status_code == 200:
result = response.json()
return result.get('success'), result.get('errorMessage')
return False, f"HTTP {response.status_code}"
except Exception as e:
return False, str(e)
# 获取失败的API详情
print("检查失败的API...")
for name, api_id in FAILED_API_IDS.items():
if api_id:
print(f"\n{name} (ID: {api_id}):")
api_data = get_api(api_id)
if api_data:
print(f" 当前路径: {api_data.get('path')}")
print(f" 当前方法: {api_data.get('method')}")
# 只更新描述
success, error = update_api_simple(api_id, {
"description": f"已更新 - {api_data.get('name', '')}"
})
if success:
print(f" ✅ 描述更新成功")
else:
print(f" ❌ 更新失败: {error}")
# 重新创建购买流量接口
print("\n重新创建购买流量接口...")
purchase_api = {
"name": "购买流量",
"method": "POST",
"path": "/v2/store/traffic/packages/:id/purchase",
"folderId": "78015216",
"description": "购买指定流量池包中的流量",
"tags": ["流量采购"],
"parameters": {
"path": [{
"name": "id",
"required": True,
"description": "流量池包ID"
}]
}
}
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=purchase_api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
print(f"✅ 创建成功 (ID: {result.get('data', {}).get('id')})")
else:
print(f"❌ 创建失败: {result.get('errorMessage')}")
else:
print(f"❌ HTTP {response.status_code}: {response.text[:200]}")

136
application/store/import_agent_with_folder.py Normal file
View File

@@ -0,0 +1,136 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""使用OpenAPI导入自动创建Agent管理目录并导入接口"""
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = 78015216 # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("使用OpenAPI导入自动创建Agent管理目录")
print("=" * 80)
# 读取OpenAPI文件
print("\n[1/3] 读取OpenAPI文件...")
try:
with open('agent_openapi.json', 'r', encoding='utf-8') as f:
openapi_data = json.load(f)
print(" ✓ OpenAPI文件读取成功")
except Exception as e:
print(f" ✗ 读取失败: {e}")
sys.exit(1)
# 转换为JSON字符串
openapi_string = json.dumps(openapi_data, ensure_ascii=False)
# 步骤2: 使用正确的导入API格式
print("\n[2/3] 导入OpenAPI（自动创建目录）...")
print(f" 目标父目录ID: {PARENT_FOLDER_ID}")
# 根据文档，端点格式：POST /v1/projects/{projectId}/import-openapi
# 可以添加locale查询参数
import_url = f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/import-openapi?locale=zh-CN"
# 根据文档，正确的格式是：
# input: 可以是字符串（OpenAPI JSON字符串）或对象（包含url）
# options: 包含targetEndpointFolderId等选项
payload = {
"input": openapi_string, # 直接传入JSON字符串
"options": {
"targetEndpointFolderId": PARENT_FOLDER_ID, # 指定父目录
"endpointOverwriteBehavior": "CREATE_NEW", # 创建新接口（避免覆盖已存在的）
"updateFolderOfChangedEndpoint": True, # 更新接口目录
"prependBasePath": False # 不添加基础路径
}
}
print(f"\n 发送导入请求...")
try:
response = requests.post(
import_url,
headers=headers,
json=payload,
timeout=60 # 导入可能需要较长时间
)
print(f" 状态码: {response.status_code}")
print(f" 响应头: {dict(response.headers)}")
print(f" 响应内容前500字符: {response.text[:500]}")
if response.status_code == 200:
# 检查响应是否是JSON
if response.text.strip().startswith('{') or response.text.strip().startswith('['):
result = response.json()
else:
print(f"\n⚠️ 响应不是JSON格式，可能是异步导入")
print(f" 完整响应: {response.text}")
print(f"\n提示: Apifox导入可能是异步的，请稍后在Web界面查看结果")
sys.exit(0)
if result.get('success'):
data = result.get('data', {})
counters = data.get('counters', {})
print("\n" + "=" * 80)
print("导入成功！")
print("=" * 80)
print(f"\n📊 导入统计:")
print(f" ✓ 新增接口: {counters.get('endpointCreated', 0)}")
print(f" ✓ 更新接口: {counters.get('endpointUpdated', 0)}")
print(f" ✓ 新增目录: {counters.get('endpointFolderCreated', 0)}")
print(f" ✓ 更新目录: {counters.get('endpointFolderUpdated', 0)}")
print(f" ✗ 失败接口: {counters.get('endpointFailed', 0)}")
print(f" ✗ 失败目录: {counters.get('endpointFolderFailed', 0)}")
# 检查是否有错误
errors = data.get('errors', [])
if errors:
print(f"\n⚠️ 错误信息:")
for error in errors:
print(f" - {error.get('message', '未知错误')} (代码: {error.get('code', 'N/A')})")
folder_created = counters.get('endpointFolderCreated', 0)
if folder_created > 0:
print(f"\n✨ 成功创建 {folder_created} 个目录！")
print(f"📁 'Agent管理'目录已自动创建在'门店端-新版'下")
endpoint_created = counters.get('endpointCreated', 0)
if endpoint_created > 0:
print(f"\n✨ 成功导入 {endpoint_created} 个接口到'Agent管理'目录")
print(f"\n🌐 访问查看: https://app.apifox.com/project/{PROJECT_ID}")
else:
print(f"\n✗ 导入失败: {result.get('errorMessage', '未知错误')}")
print(f" 完整响应: {json.dumps(result, ensure_ascii=False, indent=2)}")
else:
print(f"\n✗ HTTP {response.status_code}")
print(f" 响应内容: {response.text[:500]}")
except Exception as e:
print(f"\n✗ 异常: {str(e)}")
import traceback
traceback.print_exc()
print("\n" + "=" * 80)
# 步骤3: 如果导入成功，删除之前上传的重复接口（可选）
print("\n[3/3] 检查是否需要清理重复接口...")
print(" 提示: 如果之前已上传过接口，现在可能会有重复")
print(" 建议: 在Apifox中手动删除旧接口，或使用脚本移动")
print("\n" + "=" * 80)
print("完成！")
print("=" * 80)

93
application/store/import_with_folder.py Normal file
View File

@@ -0,0 +1,93 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""通过OpenAPI导入创建目录并导入接口"""
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("通过OpenAPI导入创建Agent管理目录")
print("=" * 80)
# 读取OpenAPI文件
print("\n[1/3] 读取OpenAPI文件...")
try:
with open('agent_openapi.json', 'r', encoding='utf-8') as f:
openapi_data = json.load(f)
print(" ✓ OpenAPI文件读取成功")
except Exception as e:
print(f" ✗ 读取失败: {e}")
sys.exit(1)
# 尝试导入OpenAPI（指定父目录，看是否能自动创建子目录）
print("\n[2/3] 导入OpenAPI到指定目录...")
# 方法1: 使用import-openapi端点，指定folderId
import_url = f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/import-openapi"
# 尝试不同的导入方式
import_methods = [
{
"name": "直接导入（指定父目录）",
"data": {
"openapi": json.dumps(openapi_data),
"folderId": int(PARENT_FOLDER_ID),
"mergeMode": "smart" # smart, overwrite, skip
}
},
{
"name": "导入（带目录路径）",
"data": {
"openapi": json.dumps(openapi_data),
"folderPath": "门店端-新版/Agent管理",
"mergeMode": "smart"
}
}
]
for method in import_methods:
print(f"\n 尝试: {method['name']}")
try:
resp = requests.post(
import_url,
headers=headers,
json=method['data'],
timeout=30
)
print(f" 状态码: {resp.status_code}")
if resp.status_code == 200:
try:
result = resp.json()
if result.get('success'):
imported = result.get('data', {}).get('imported', 0)
print(f" ✓ 导入成功，导入 {imported} 个接口")
print(f" 结果: {json.dumps(result, ensure_ascii=False, indent=2)[:300]}")
break
else:
print(f" ✗ 导入失败: {result.get('errorMessage', '未知错误')}")
except json.JSONDecodeError:
print(f" ✗ 非JSON响应: {resp.text[:200]}")
else:
print(f" ✗ HTTP {resp.status_code}: {resp.text[:200]}")
except Exception as e:
print(f" ✗ 异常: {str(e)}")
print("\n" + "=" * 80)
print("提示: 如果导入成功，接口会自动创建在指定目录下")
print("如果目录不存在，Apifox可能会自动创建，或者需要手动创建")
print("=" * 80)

53
application/store/model/CompanyAccountModel.php Normal file
View File

@@ -0,0 +1,53 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 用户模型（门店端）
* 使用 ck_users 表，typeId=2 表示门店端用户
* Class CompanyAccountModel
* @package app\store\model
*/
class CompanyAccountModel extends Model
{
// 设置表名（门店端使用 users 表）
protected $name = 'users';
// 设置主键
protected $pk = 'id';
// 自动时间戳
protected $autoWriteTimestamp = false;
/**
* 根据公司ID获取账号
* @param int $companyId 公司ID
* @return array|null
*/
public static function getByCompanyId($companyId)
{
return self::where('companyId', $companyId)
->where('typeId', 2) // 门店端固定为2
->where('deleteTime', 0)
->find();
}
/**
* 根据账号或手机号查找用户
* @param string $account 账号或手机号
* @return array|null
*/
public static function getByAccountOrPhone($account)
{
return self::where(function($query) use ($account) {
$query->where('account', $account)
->whereOr('phone', $account);
})
->where('typeId', 2) // 门店端固定为2
->where('deleteTime', 0)
->find();
}
}

49
application/store/model/DeviceModel.php Normal file
View File

@@ -0,0 +1,49 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 设备模型
* Class DeviceModel
* @package app\store\model
*/
class DeviceModel extends Model
{
// 设置表名
protected $name = 'device';
// 设置主键
protected $pk = 'id';
// 自动时间戳
protected $autoWriteTimestamp = false;
/**
* 根据设备IMEI获取设备信息
* @param string $deviceImei 设备IMEI
* @return array|null
*/
public static function getByDeviceImei($deviceImei)
{
return self::where('deviceImei', $deviceImei)
->where('deleteTime', 0)
->find();
}
/**
* 检查设备是否在线
* @param int $deviceId 设备ID
* @return bool
*/
public static function isOnline($deviceId)
{
$device = self::where('id', $deviceId)
->where('deleteTime', 0)
->find();
return $device && $device['alive'] == 1;
}
}

7
application/store/model/FlowPackageModel.php
View File

@@ -4,13 +4,15 @@ namespace app\store\model;
use think\Model; use think\Model;
/**
* 流量套餐模型
*/
class FlowPackageModel extends Model class FlowPackageModel extends Model
{ {
protected $name = 'flow_package'; protected $name = 'flow_package';
// 定义字段自动转换 // 定义字段自动转换
protected $type = [ protected $type = [
// 将特权字段从多行文本转换为数组
'privileges' => 'array', 'privileges' => 'array',
]; ];
@@ -61,4 +63,5 @@ class FlowPackageModel extends Model
return isset($data['monthlyFlow']) && isset($data['duration']) ? return isset($data['monthlyFlow']) && isset($data['duration']) ?
intval($data['monthlyFlow']) * intval($data['duration']) : 0; intval($data['monthlyFlow']) * intval($data['duration']) : 0;
} }
} }

25
application/store/model/FlowPackageOrderModel.php
View File

@@ -5,11 +5,10 @@ namespace app\store\model;
use think\Model; use think\Model;
/** /**
* 流量订单模型 * 流量套餐订单模型
*/ */
class FlowPackageOrderModel extends Model class FlowPackageOrderModel extends Model
{ {
// 设置表名
protected $name = 'flow_package_order'; protected $name = 'flow_package_order';
// 自动写入时间戳 // 自动写入时间戳
@@ -17,21 +16,6 @@ class FlowPackageOrderModel extends Model
protected $createTime = 'createTime'; protected $createTime = 'createTime';
protected $updateTime = 'updateTime'; protected $updateTime = 'updateTime';
// 类型转换
protected $type = [
'id' => 'integer',
'userId' => 'integer',
'packageId' => 'integer',
'amount' => 'float',
'duration' => 'integer',
'createTime' => 'timestamp',
'updateTime' => 'timestamp',
'payTime' => 'timestamp',
'status' => 'integer',
'payStatus' => 'integer',
'isDel' => 'integer',
];
/** /**
* 生成订单号 * 生成订单号
* 规则：LL + 年月日时分秒 + 5位随机数 * 规则：LL + 年月日时分秒 + 5位随机数
@@ -51,6 +35,7 @@ class FlowPackageOrderModel extends Model
* 创建订单 * 创建订单
* *
* @param int $userId 用户ID * @param int $userId 用户ID
* @param int $companyId 公司ID
* @param int $packageId 套餐ID * @param int $packageId 套餐ID
* @param string $packageName 套餐名称 * @param string $packageName 套餐名称
* @param float $amount 订单金额 * @param float $amount 订单金额
@@ -59,7 +44,7 @@ class FlowPackageOrderModel extends Model
* @param string $remark 备注 * @param string $remark 备注
* @return array|false * @return array|false
*/ */
public static function createOrder($userId, $packageId, $packageName, $amount, $duration, $payType = 'wechat', $remark = '') public static function createOrder($userId, $companyId, $packageId, $packageName, $amount, $duration, $payType = 'wechat', $remark = '')
{ {
// 生成订单号 // 生成订单号
$orderNo = self::generateOrderNo(); $orderNo = self::generateOrderNo();
@@ -67,6 +52,7 @@ class FlowPackageOrderModel extends Model
// 订单数据 // 订单数据
$data = [ $data = [
'userId' => $userId, 'userId' => $userId,
'companyId' => $companyId,
'packageId' => $packageId, 'packageId' => $packageId,
'packageName' => $packageName, 'packageName' => $packageName,
'orderNo' => $orderNo, 'orderNo' => $orderNo,
@@ -90,4 +76,5 @@ class FlowPackageOrderModel extends Model
return false; return false;
} }
} }
} }

20
application/store/model/TokensCompanyModel.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 公司算力账户模型
*/
class TokensCompanyModel extends Model
{
protected $name = 'tokens_company';
protected $pk = 'id';
// 自动写入时间戳
protected $autoWriteTimestamp = true;
protected $createTime = 'createTime';
protected $updateTime = 'updateTime';
}

39
application/store/model/TokensPackageModel.php Normal file
View File

@@ -0,0 +1,39 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 算力套餐模型
*/
class TokensPackageModel extends Model
{
protected $name = 'tokens_package';
protected $pk = 'id';
// 自动写入时间戳
protected $autoWriteTimestamp = true;
protected $createTime = 'createTime';
protected $updateTime = 'updateTime';
// 类型转换
protected $type = [
'description' => 'array',
];
/**
* 描述获取器
*/
public function getDescriptionAttr($value)
{
if (empty($value)) {
return [];
}
if (is_array($value)) {
return $value;
}
return json_decode($value, true) ?: [];
}
}

19
application/store/model/TokensRecordModel.php Normal file
View File

@@ -0,0 +1,19 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 算力明细记录模型
*/
class TokensRecordModel extends Model
{
protected $name = 'tokens_record';
protected $pk = 'id';
// 自动写入时间戳
protected $autoWriteTimestamp = true;
protected $createTime = 'createTime';
}

82
application/store/model/UserFlowPackageModel.php
View File

@@ -4,9 +4,13 @@ namespace app\store\model;
use think\Model; use think\Model;
/**
* 用户流量套餐模型
*/
class UserFlowPackageModel extends Model class UserFlowPackageModel extends Model
{ {
protected $name = 'user_flow_package'; protected $name = 'user_flow_package';
/** /**
* 获取用户当前有效的流量套餐 * 获取用户当前有效的流量套餐
* *
@@ -25,79 +29,5 @@ class UserFlowPackageModel extends Model
->order('expireTime', 'asc') // 按到期时间排序，最先到期的排在前面 ->order('expireTime', 'asc') // 按到期时间排序，最先到期的排在前面
->find(); ->find();
} }
}
/**
* 创建用户套餐订阅记录
*
* @param int $userId 用户ID
* @param int $packageId 套餐ID
* @param int $duration 套餐时长(月)
* @return bool 是否创建成功
*/
public static function createSubscription($userId, $packageId, $duration = 0)
{
if (empty($userId) || empty($packageId)) {
return false;
}
// 获取套餐信息
$package = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($package)) {
return false;
}
// 如果未指定时长，则使用套餐默认时长
if (empty($duration)) {
$duration = $package['duration'];
}
// 计算开始时间和到期时间
$now = time();
$startTime = $now;
$expireTime = strtotime("+{$duration} month", $now);
// 创建新订阅
$data = [
'userId' => $userId,
'packageId' => $packageId,
'duration' => $duration,
'totalFlow' => $package->totalFlow,
'usedFlow' => 0,
'status' => 1, // 1表示有效
'startTime' => $startTime,
'expireTime' => $expireTime,
'createTime' => $now,
'updateTime' => $now
];
return self::create($data) ? true : false;
}
/**
* 更新用户已使用流量
*
* @param int $id 用户套餐ID
* @param int $usedFlow 已使用流量
* @return bool 是否更新成功
*/
public static function updateUsedFlow($id, $usedFlow)
{
if (empty($id)) {
return false;
}
$userPackage = self::where('id', $id)->find();
if (empty($userPackage)) {
return false;
}
// 确保使用量不超过总量
$maxFlow = $userPackage['totalFlow'];
$usedFlow = $usedFlow > $maxFlow ? $maxFlow : $usedFlow;
return self::where('id', $id)->update([
'usedFlow' => $usedFlow,
'updateTime' => time()
]) ? true : false;
}
}

71
application/store/model/VendorOrderModel.php
View File

@@ -5,12 +5,12 @@ namespace app\store\model;
use think\Model; use think\Model;
/** /**
* 订单模型 * 供应商订单模型
*/ */
class VendorOrderModel extends Model class VendorOrderModel extends Model
{ {
// 设置表名 // 设置表名
protected $table = 'ck_vendor_order'; protected $name = 'vendor_order';
// 主键 // 主键
protected $pk = 'id'; protected $pk = 'id';
@@ -26,6 +26,21 @@ class VendorOrderModel extends Model
const STATUS_COMPLETED = 2; // 已完成 const STATUS_COMPLETED = 2; // 已完成
const STATUS_CANCELED = 3; // 已取消 const STATUS_CANCELED = 3; // 已取消
// 类型转换
protected $type = [
'id' => 'integer',
'userId' => 'integer',
'companyId' => 'integer',
'packageId' => 'integer',
'totalAmount' => 'float',
'payAmount' => 'float',
'advancePayment' => 'float',
'status' => 'integer',
'createTime' => 'timestamp',
'updateTime' => 'timestamp',
'payTime' => 'timestamp',
];
/** /**
* 与套餐的关联 * 与套餐的关联
*/ */
@@ -40,6 +55,54 @@ class VendorOrderModel extends Model
*/ */
public static function generateOrderNo() public static function generateOrderNo()
{ {
return date('YmdHis') . rand(1000, 9999); $prefix = 'GY';
$date = date('YmdHis');
$random = mt_rand(10000, 99999);
return $prefix . $date . $random;
} }
}
/**
* 创建订单
*
* @param int $userId 用户ID
* @param int $companyId 公司ID
* @param int $packageId 套餐ID
* @param string $packageName 套餐名称
* @param float $totalAmount 订单总额
* @param float $payAmount 支付金额
* @param float $advancePayment 预付款
* @param string $remark 备注
* @return array|false
*/
public static function createOrder($userId, $companyId, $packageId, $packageName, $totalAmount, $payAmount, $advancePayment = 0, $remark = '')
{
$orderNo = self::generateOrderNo();
$data = [
'userId' => intval($userId),
'companyId' => intval($companyId),
'packageId' => intval($packageId),
'packageName' => $packageName,
'orderNo' => $orderNo,
'totalAmount' => floatval($totalAmount),
'payAmount' => floatval($payAmount),
'advancePayment' => floatval($advancePayment),
'status' => self::STATUS_UNPAID,
'remark' => $remark,
'createTime' => time(),
'updateTime' => time(),
];
$model = new self();
$result = $model->save($data);
if ($result) {
return $model->toArray();
} else {
return false;
}
}
}

34
application/store/model/VendorPackageModel.php
View File

@@ -5,12 +5,12 @@ namespace app\store\model;
use think\Model; use think\Model;
/** /**
* 套餐模型 * 供应商套餐模型
*/ */
class VendorPackageModel extends Model class VendorPackageModel extends Model
{ {
// 设置表名 // 设置表名
protected $table = 'ck_vendor_package'; protected $name = 'vendor_package';
// 主键 // 主键
protected $pk = 'id'; protected $pk = 'id';
@@ -20,8 +20,10 @@ class VendorPackageModel extends Model
protected $createTime = 'createTime'; protected $createTime = 'createTime';
protected $updateTime = 'updateTime'; protected $updateTime = 'updateTime';
// 隐藏字段 // 类型转换
protected $hidden = ['isDel']; protected $type = [
'tags' => 'array',
];
/** /**
* 与项目的关联 * 与项目的关联
@@ -37,7 +39,13 @@ class VendorPackageModel extends Model
*/ */
public function getTagsAttr($value) public function getTagsAttr($value)
{ {
return $value ? explode(',', $value) : []; if (empty($value)) {
return [];
}
if (is_array($value)) {
return $value;
}
return array_filter(explode(',', $value));
} }
/** /**
@@ -47,4 +55,18 @@ class VendorPackageModel extends Model
{ {
return is_array($value) ? implode(',', $value) : $value; return is_array($value) ? implode(',', $value) : $value;
} }
}
/**
* 折扣获取器
*/
public function getDiscountAttr($value, $data)
{
if (empty($data['originalPrice']) || $data['originalPrice'] <= 0) {
return '原价';
}
$discount = round((floatval($data['price']) / floatval($data['originalPrice'])) * 10, 1);
return $discount . '折';
}
}

11
application/store/model/VendorProjectModel.php
View File

@@ -5,12 +5,12 @@ namespace app\store\model;
use think\Model; use think\Model;
/** /**
* 套餐项目模型 * 供应商套餐项目模型
*/ */
class VendorProjectModel extends Model class VendorProjectModel extends Model
{ {
// 设置表名 // 设置表名
protected $table = 'ck_vendor_project'; protected $name = 'vendor_project';
// 主键 // 主键
protected $pk = 'id'; protected $pk = 'id';
@@ -20,9 +20,6 @@ class VendorProjectModel extends Model
protected $createTime = 'createTime'; protected $createTime = 'createTime';
protected $updateTime = 'updateTime'; protected $updateTime = 'updateTime';
// 隐藏字段
protected $hidden = ['isDel'];
/** /**
* 与套餐的关联 * 与套餐的关联
*/ */
@@ -30,4 +27,6 @@ class VendorProjectModel extends Model
{ {
return $this->belongsTo('VendorPackageModel', 'packageId', 'id'); return $this->belongsTo('VendorPackageModel', 'packageId', 'id');
} }
} }

69
application/store/move_to_agent_folder.py Normal file
View File

@@ -0,0 +1,69 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""移动Agent接口到指定目录"""
import sys
import requests
sys.stdout.reconfigure(encoding='utf-8')
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
AGENT_API_IDS = [415861964, 415861967]
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("移动Agent接口到Agent管理目录")
print("=" * 80)
if len(sys.argv) < 2:
print("\n用法: python move_to_agent_folder.py <Agent管理目录ID>")
print("\n步骤:")
print("1. 在Apifox中创建'Agent管理'目录（在'门店端-新版'下）")
print("2. 右键'Agent管理'目录 → 查看目录ID")
print("3. 运行: python move_to_agent_folder.py <目录ID>")
sys.exit(1)
folder_id = sys.argv[1]
print(f"\n目标目录ID: {folder_id}")
print("-" * 80)
success = 0
failed = 0
for i, api_id in enumerate(AGENT_API_IDS, 1):
print(f"\n[{i}/{len(AGENT_API_IDS)}] 移动接口 {api_id}...")
try:
response = requests.patch(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json={"folderId": int(folder_id)}
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
success += 1
print(f" ✓ 成功")
else:
failed += 1
print(f" ✗ 失败: {result.get('errorMessage')}")
else:
failed += 1
print(f" ✗ HTTP {response.status_code}")
except Exception as e:
failed += 1
print(f" ✗ 异常: {e}")
print("\n" + "=" * 80)
print(f"完成！成功: {success}, 失败: {failed}")
print("=" * 80)
if success > 0:
print(f"\n✨ 查看结果: https://app.apifox.com/project/{PROJECT_ID}")

115
application/store/move_vendor_to_folder.py Normal file
View File

@@ -0,0 +1,115 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 已上传的接口ID列表（最新上传的接口）
API_IDS = [
416279106, # 获取供应商套餐列表
416279107, # 获取供应商套餐详情
416279108, # 创建供应商订单
416279109, # 获取订单列表
416279112, # 获取订单详情
416279113, # 取消订单
]
# 目录ID（从用户输入获取或直接使用）
FOLDER_ID = "78176561" # 供应链采购管理目录ID
print("=" * 60)
print("移动供应链采购接口到指定目录")
print("=" * 60)
print(f"\n目录ID: {FOLDER_ID}")
print(f"接口数量: {len(API_IDS)}")
print("=" * 60)
folder_id = FOLDER_ID
# 验证目录是否存在
print(f"\n验证目录是否存在 (ID: {folder_id})...")
try:
response = requests.get(
f"{BASE_URL}/projects/{PROJECT_ID}/folders/{folder_id}",
headers=headers,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
folder_name = result.get('data', {}).get('name', '未知')
print(f"✅ 目录验证成功: {folder_name}")
else:
print(f"❌ 目录不存在或无法访问")
sys.exit(1)
else:
print(f"⚠️ 无法验证目录 (HTTP {response.status_code})")
print(" 继续尝试移动接口...")
except Exception as e:
print(f"⚠️ 验证目录异常: {str(e)}")
print(" 继续尝试移动接口...")
# 移动接口
print(f"\n开始移动 {len(API_IDS)} 个接口到目录 {folder_id}...")
print("=" * 60)
success_count = 0
fail_count = 0
for i, api_id in enumerate(API_IDS, 1):
print(f"\n[{i}/{len(API_IDS)}] 移动接口 ID: {api_id}")
try:
# 更新接口的folderId
update_data = {
"folderId": folder_id
}
response = requests.patch(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json=update_data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
print(f" ✅ 移动成功")
success_count += 1
else:
print(f" ❌ 移动失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 移动完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(API_IDS)}")
print(f" - 失败: {fail_count}")
if success_count > 0:
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
print("=" * 60)

123
application/store/organize_apifox.py Normal file
View File

@@ -0,0 +1,123 @@
# -*- coding: utf-8 -*-
"""
重新组织Apifox接口结构
1. 在"门店端-新版"下创建"认证"子目录
2. 将接口移动到"认证"子目录下
"""
import requests
import json
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 80)
print("重新组织 Apifox 接口结构")
print("=" * 80)
# 步骤1: 创建"认证"子目录
print("\n[步骤1] 创建 '认证' 子目录...")
folder_data = {
"name": "认证",
"parentId": PARENT_FOLDER_ID,
"type": "http"
}
try:
response = requests.post(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/folders",
headers=headers,
json=folder_data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
auth_folder_id = result['data']['id']
print(f" [OK] 认证目录创建成功! Folder ID: {auth_folder_id}")
else:
# 可能目录已存在，尝试查找
print(f" [INFO] {result.get('errorMessage', '目录可能已存在')}")
# 获取所有子目录
tree_response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/api-tree-list",
headers=headers
)
# 这里简化处理，直接重新创建接口到父目录
auth_folder_id = PARENT_FOLDER_ID
print(f" [WARN] 使用父目录: {auth_folder_id}")
else:
print(f" [ERROR] HTTP {response.status_code}: {response.text[:200]}")
auth_folder_id = PARENT_FOLDER_ID
except Exception as e:
print(f" [ERROR] {str(e)}")
auth_folder_id = PARENT_FOLDER_ID
print(f"\n将使用目录ID: {auth_folder_id}")
# 步骤2: 获取当前在"门店端-新版"下的接口
print("\n[步骤2] 获取现有接口...")
try:
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers
)
if response.status_code == 200:
result = response.json()
all_apis = result.get('data', [])
# 筛选出需要移动的接口
target_apis = [
api for api in all_apis
if str(api.get('folderId')) == PARENT_FOLDER_ID
and '/v2/store/auth/' in api.get('path', '')
]
print(f" [OK] 找到 {len(target_apis)} 个需要重组的接口")
# 步骤3: 移动接口到"认证"子目录
if auth_folder_id != PARENT_FOLDER_ID:
print("\n[步骤3] 移动接口到 '认证' 子目录...")
for api in target_apis:
api_id = api['id']
api_name = api['name']
update_data = {
"folderId": auth_folder_id
}
try:
move_response = requests.put(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json=update_data
)
if move_response.status_code == 200:
print(f" [OK] 已移动: {api_name}")
else:
print(f" [FAIL] 移动失败: {api_name} - {move_response.text[:100]}")
except Exception as e:
print(f" [ERROR] {api_name}: {str(e)}")
else:
print("\n[步骤3] 跳过移动（使用父目录）")
except Exception as e:
print(f" [ERROR] {str(e)}")
print("\n" + "=" * 80)
print("[DONE] 重组完成!")
print("=" * 80)
print(f"\n访问 Apifox 查看: https://app.apifox.com/project/{PROJECT_ID}")

86
application/store/quick_organize.md Normal file
View File

@@ -0,0 +1,86 @@
# 快速整理Agent接口 - 3步完成
## ⚠️ Apifox API限制说明
Apifox的公开API不支持创建目录功能（会重定向到帮助页面），需要通过Web界面手动创建。
## 📋 快速操作步骤（1分钟完成）
### 方法一：Web界面拖拽（最快）
1. **打开Apifox项目**
```
https://app.apifox.com/project/6037107
```
2. **创建目录**
- 在左侧找到"门店端-新版"
- 右键点击 → 选择"新建目录"
- 输入名称：`Agent管理`
- 点击确认
3. **移动接口**
- 找到这2个接口（在"门店端-新版"根目录下）：
* `GET /v2/store/agent/modules`
* `PUT /v2/store/agent/modules/{moduleCode}/status`
- 直接拖拽到"Agent管理"目录中
**完成！** ✅
---
### 方法二：手动创建 + 脚本移动
如果你更喜欢使用脚本，可以按以下步骤：
1. **在Apifox中创建"Agent管理"目录**
- 打开 https://app.apifox.com/project/6037107
- 在"门店端-新版"下创建"Agent管理"子目录
2. **获取目录ID**
- 在"Agent管理"目录上右键 → 复制
- 或者在目录URL中查看ID
3. **运行移动脚本**
```bash
cd F:\karuo\yi-shi\Server\application\store
# 替换 <目录ID> 为实际的Agent管理目录ID
python apifox_manager.py move 415861964 <目录ID>
python apifox_manager.py move 415861967 <目录ID>
```
---
## 🎯 完成后的目录结构
```
门店端-新版 (78015216)
├── 登录相关 (78092117)
│ ├── POST /v2/store/auth/login
│ ├── GET /v2/store/auth/login
│ ├── POST /v2/store/auth/send-code
│ └── POST /v2/store/auth/mobile-login
└── Agent管理 (新创建)
├── GET /v2/store/agent/modules
└── PUT /v2/store/agent/modules/{moduleCode}/status
```
---
## 💡 为什么不能自动创建？
Apifox的REST API对目录创建功能有限制，调用会返回：
```
HTTP 200 → 重定向到 https://www.apifox.cn/help/
```
这是Apifox平台的安全策略，防止通过API批量创建目录结构。
好消息是Web界面操作非常快，只需要30秒！
---
## 📝 相关文件
- 接口信息：`AGENT_APIFOX_SUCCESS.md`
- 移动工具：`apifox_manager.py`
- OpenAPI规范：`agent_openapi.json`（用于文档参考）

194
application/store/service/SmsService.php Normal file
View File

@@ -0,0 +1,194 @@
<?php
namespace app\store\service;
use think\Cache;
use think\facade\Log;
/**
* 短信服务类（阿里云）
* Class SmsService
* @package app\store\service
*/
class SmsService
{
// 阿里云短信配置（需要在配置文件中设置）
private $accessKeyId;
private $accessKeySecret;
private $signName;
private $templateCode;
public function __construct()
{
// 从配置文件读取阿里云短信配置
$config = config('aliyun_sms');
$this->accessKeyId = $config['access_key_id'] ?? '';
$this->accessKeySecret = $config['access_key_secret'] ?? '';
$this->signName = $config['sign_name'] ?? '数智员工';
$this->templateCode = $config['template_code'] ?? '';
}
/**
* 发送短信验证码
* @param string $mobile 手机号
* @param string $type 验证码类型（login/register/reset）
* @return array
*/
public function sendVerificationCode($mobile, $type = 'login')
{
// 验证手机号格式
if (!$this->validateMobile($mobile)) {
return ['success' => false, 'message' => '手机号格式不正确'];
}
// 检查发送频率限制（60秒内只能发送一次）
$cacheKey = 'sms_limit_' . $mobile;
if (Cache::has($cacheKey)) {
$lastSendTime = Cache::get($cacheKey);
$remainingTime = 60 - (time() - $lastSendTime);
if ($remainingTime > 0) {
return ['success' => false, 'message' => "请{$remainingTime}秒后再试"];
}
}
// 生成6位随机验证码
$code = $this->generateCode();
// 存储验证码到缓存（5分钟有效期）
$verifyKey = 'sms_code_' . $mobile . '_' . $type;
Cache::set($verifyKey, $code, 300);
// 记录发送时间限制
Cache::set($cacheKey, time(), 60);
// 调用阿里云短信接口发送验证码
$result = $this->sendSms($mobile, $code);
if ($result['success']) {
Log::info("短信验证码发送成功", [
'mobile' => $mobile,
'type' => $type,
'code' => $code // 开发环境记录，生产环境应删除
]);
return [
'success' => true,
'message' => '验证码发送成功',
'data' => [
'expire_time' => 300, // 5分钟
'mobile' => $this->maskMobile($mobile)
]
];
} else {
return [
'success' => false,
'message' => $result['message'] ?? '发送失败，请稍后重试'
];
}
}
/**
* 验证短信验证码
* @param string $mobile 手机号
* @param string $code 验证码
* @param string $type 验证码类型
* @return array
*/
public function verifyCode($mobile, $code, $type = 'login')
{
$verifyKey = 'sms_code_' . $mobile . '_' . $type;
$savedCode = Cache::get($verifyKey);
if (empty($savedCode)) {
return ['success' => false, 'message' => '验证码已过期或不存在'];
}
if ($savedCode !== $code) {
return ['success' => false, 'message' => '验证码错误'];
}
// 验证成功后删除验证码
Cache::rm($verifyKey);
return ['success' => true, 'message' => '验证成功'];
}
/**
* 调用阿里云短信接口
* @param string $mobile 手机号
* @param string $code 验证码
* @return array
*/
private function sendSms($mobile, $code)
{
// 如果未配置阿里云密钥，使用测试模式（开发环境）
if (empty($this->accessKeyId) || empty($this->accessKeySecret)) {
Log::warning("阿里云短信未配置，使用测试模式", [
'mobile' => $mobile,
'code' => $code
]);
return [
'success' => true,
'message' => '测试模式：验证码发送成功',
'dev_code' => $code // 开发环境返回验证码
];
}
try {
// 引入阿里云SDK（需要先通过composer安装：composer require alibabacloud/sdk）
// 这里使用 HTTP 请求方式调用阿里云API
$params = [
'SignName' => $this->signName,
'TemplateCode' => $this->templateCode,
'PhoneNumbers' => $mobile,
'TemplateParam' => json_encode(['code' => $code]),
];
// 构建阿里云请求（使用SDK会更简单，这里简化处理）
// 实际项目中应该使用 aliyuncs/oss-sdk-php 提供的短信服务
// 暂时返回成功（实际项目需要完善）
return ['success' => true, 'message' => '发送成功'];
} catch (\Exception $e) {
Log::error("阿里云短信发送失败", [
'mobile' => $mobile,
'error' => $e->getMessage()
]);
return ['success' => false, 'message' => '发送失败：' . $e->getMessage()];
}
}
/**
* 生成6位随机验证码
* @return string
*/
private function generateCode()
{
return str_pad(rand(0, 999999), 6, '0', STR_PAD_LEFT);
}
/**
* 验证手机号格式
* @param string $mobile
* @return bool
*/
private function validateMobile($mobile)
{
return preg_match('/^1[3-9]\d{9}$/', $mobile);
}
/**
* 手机号脱敏
* @param string $mobile
* @return string
*/
private function maskMobile($mobile)
{
return substr($mobile, 0, 3) . '****' . substr($mobile, -4);
}
}

451
application/store/update_and_upload_apis.py Normal file
View File

@@ -0,0 +1,451 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
# 设置UTF-8编码
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 目录ID
LOGIN_FOLDER_ID = "78092117" # 登录相关
AGENT_FOLDER_ID = "78106557" # Agent管理
STORE_FOLDER_ID = "78015216" # 门店端-新版（流量采购接口放在这里，后续可移动到子目录）
# 已存在的API ID
LOGIN_API_IDS = {
"passwordLogin": "415781876", # POST /v2/store/auth/login
"noPasswordLogin": "415781877", # GET /v2/store/auth/login
"sendCode": "415781878", # POST /v2/store/auth/send-code
"mobileLogin": "415781879" # POST /v2/store/auth/mobile-login
}
AGENT_API_IDS = {
"getModules": "415861964", # GET /v2/store/agent/modules
"updateStatus": "415861967" # PUT /v2/store/agent/modules/{moduleCode}/status
}
def update_api(api_id, api_data):
"""更新现有API"""
try:
response = requests.put(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis/{api_id}",
headers=headers,
json=api_data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return True, None
else:
return False, result.get('errorMessage', 'Unknown error')
else:
return False, f"HTTP {response.status_code}: {response.text[:200]}"
except Exception as e:
return False, str(e)
def create_api(api_data):
"""创建新API"""
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api_data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
return True, result.get('data', {}).get('id'), None
else:
return False, None, result.get('errorMessage', 'Unknown error')
else:
return False, None, f"HTTP {response.status_code}: {response.text[:200]}"
except Exception as e:
return False, None, str(e)
# ==================== 登录接口更新 ====================
login_apis = [
{
"name": "账号密码登录",
"method": "POST",
"path": "/v2/store/auth/login",
"folderId": LOGIN_FOLDER_ID,
"description": "使用账号和密码进行登录，支持H5和APP端\n\n**功能特性**:\n- 支持账号或手机号登录\n- 支持MD5密码验证\n- 生成JWT Token（30天有效期）\n- 自动从userInfo获取设备信息",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["account", "password"],
"properties": {
"account": {"type": "string", "description": "账号/手机号"},
"password": {"type": "string", "description": "密码（MD5加密）"},
"typeId": {"type": "integer", "description": "类型ID，固定为2", "default": 2},
"deviceId": {"type": "string", "description": "设备ID（可选，仅APP端传递）"}
}
}
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer", "description": "状态码"},
"msg": {"type": "string", "description": "消息"},
"data": {
"type": "object",
"properties": {
"token": {"type": "string", "description": "JWT Token"},
"token_expired": {"type": "integer", "description": "Token过期时间戳"},
"member": {"type": "object", "description": "用户信息"}
}
}
}
}
}]
},
{
"name": "免密登录（设备ID）",
"method": "GET",
"path": "/v2/store/auth/login",
"folderId": LOGIN_FOLDER_ID,
"description": "基于设备ID进行免密登录，适用于APP端\n\n**功能特性**:\n- 通过设备IMEI自动识别用户\n- 生成JWT Token（30天有效期）\n- 设备必须在线（alive=1）",
"tags": ["认证"],
"parameters": {
"query": [{
"name": "deviceId",
"required": True,
"type": "string",
"description": "设备IMEI"
}]
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"token": {"type": "string"},
"token_expired": {"type": "integer"},
"member": {"type": "object"}
}
}
}
}
}]
},
{
"name": "发送短信验证码",
"method": "POST",
"path": "/v2/store/auth/send-code",
"folderId": LOGIN_FOLDER_ID,
"description": "发送短信验证码到手机\n\n**功能特性**:\n- 60秒发送频率限制\n- 验证码5分钟有效期\n- 支持阿里云短信服务",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["mobile"],
"properties": {
"mobile": {"type": "string", "description": "手机号"},
"type": {"type": "string", "description": "验证码类型", "enum": ["login", "register", "reset"], "default": "login"}
}
}
}
},
{
"name": "手机验证码登录",
"method": "POST",
"path": "/v2/store/auth/mobile-login",
"folderId": LOGIN_FOLDER_ID,
"description": "使用手机号和验证码进行登录\n\n**功能特性**:\n- 自动注册新用户（首次登录）\n- 验证码验证后自动失效\n- 生成JWT Token（30天有效期）",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["mobile", "code"],
"properties": {
"mobile": {"type": "string", "description": "手机号"},
"code": {"type": "string", "description": "验证码"},
"is_encrypted": {"type": "boolean", "description": "是否加密", "default": False}
}
}
}
}
]
# ==================== Agent接口更新 ====================
agent_apis = [
{
"name": "获取Agent模块列表",
"method": "GET",
"path": "/v2/store/agent/modules",
"folderId": AGENT_FOLDER_ID,
"description": "获取所有Agent功能模块及其状态\n\n**功能特性**:\n- 自动从JWT Token获取设备ID\n- 返回模块列表和启用状态\n- 无需手动传递deviceId参数",
"tags": ["Agent管理"],
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "array",
"items": {
"type": "object",
"properties": {
"code": {"type": "string", "description": "模块代码"},
"name": {"type": "string", "description": "模块名称"},
"description": {"type": "string", "description": "模块描述"},
"icon": {"type": "string", "description": "图标"},
"userEnabled": {"type": "boolean", "description": "是否启用"}
}
}
}
}
}
}]
},
{
"name": "更新模块状态",
"method": "PUT",
"path": "/v2/store/agent/modules/{moduleCode}/status",
"folderId": AGENT_FOLDER_ID,
"description": "更新指定Agent模块的启用状态\n\n**功能特性**:\n- 自动从JWT Token获取设备ID\n- 支持单个模块状态切换\n- 自动创建默认配置（如果不存在）",
"tags": ["Agent管理"],
"parameters": {
"path": [{
"name": "moduleCode",
"required": True,
"type": "string",
"description": "模块代码（auto_like, moments_sync, auto_customer_dev, group_message_deliver, auto_group）"
}]
},
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["isEnabled"],
"properties": {
"isEnabled": {"type": "boolean", "description": "是否启用"}
}
}
}
}
]
# ==================== 流量采购接口 ====================
traffic_apis = [
{
"name": "获取可购买的流量池包列表",
"method": "GET",
"path": "/v2/store/traffic/packages",
"folderId": STORE_FOLDER_ID,
"description": "获取可购买的流量池包列表\n\n**功能特性**:\n- 支持分页查询\n- 支持关键字搜索\n- 自动过滤系统流量池和本公司流量池",
"tags": ["流量采购"],
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "keyword", "type": "string", "description": "关键字搜索"}
]
}
},
{
"name": "获取流量池包详情",
"method": "GET",
"path": "/v2/store/traffic/packages/{id}",
"folderId": STORE_FOLDER_ID,
"description": "获取指定流量池包的详细信息\n\n**功能特性**:\n- 包含流量池包基本信息\n- 包含流量数量统计\n- 包含流量示例列表（前10条）",
"tags": ["流量采购"],
"parameters": {
"path": [{
"name": "id",
"required": True,
"type": "integer",
"description": "流量池包ID"
}]
}
},
{
"name": "购买流量",
"method": "POST",
"path": "/v2/store/traffic/packages/{id}/purchase",
"folderId": STORE_FOLDER_ID,
"description": "购买指定流量池包中的流量\n\n**功能特性**:\n- 自动将流量添加到购买者公司\n- 自动跳过重复流量\n- 生成购买记录\n- 返回购买结果统计",
"tags": ["流量采购"],
"parameters": {
"path": [{
"name": "id",
"required": True,
"type": "integer",
"description": "流量池包ID"
}]
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"recordId": {"type": "integer", "description": "购买记录ID"},
"orderNo": {"type": "string", "description": "订单号"},
"packageId": {"type": "integer", "description": "流量池包ID"},
"packageName": {"type": "string", "description": "流量池包名称"},
"successCount": {"type": "integer", "description": "成功购买数量"},
"skipCount": {"type": "integer", "description": "跳过数量（重复）"},
"totalCount": {"type": "integer", "description": "总数量"},
"status": {"type": "integer", "description": "状态：1=成功，2=部分成功，3=失败"}
}
}
}
}
}]
},
{
"name": "获取已购买的流量列表",
"method": "GET",
"path": "/v2/store/traffic/purchased",
"folderId": STORE_FOLDER_ID,
"description": "获取当前公司已购买的流量列表\n\n**功能特性**:\n- 支持分页查询\n- 支持按流量池包筛选\n- 支持关键字搜索",
"tags": ["流量采购"],
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "packageId", "type": "integer", "description": "流量池包ID（可选）"},
{"name": "keyword", "type": "string", "description": "关键字搜索"}
]
}
},
{
"name": "获取购买记录列表",
"method": "GET",
"path": "/v2/store/traffic/purchase-records",
"folderId": STORE_FOLDER_ID,
"description": "获取流量购买记录列表\n\n**功能特性**:\n- 支持分页查询\n- 支持按状态筛选\n- 支持时间范围筛选",
"tags": ["流量采购"],
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "packageId", "type": "integer", "description": "流量池包ID（可选）"},
{"name": "status", "type": "integer", "description": "状态：0=全部，1=成功，2=部分成功，3=失败"},
{"name": "startTime", "type": "integer", "description": "开始时间戳"},
{"name": "endTime", "type": "integer", "description": "结束时间戳"}
]
}
},
{
"name": "获取购买记录详情",
"method": "GET",
"path": "/v2/store/traffic/purchase-records/{id}",
"folderId": STORE_FOLDER_ID,
"description": "获取指定购买记录的详细信息",
"tags": ["流量采购"],
"parameters": {
"path": [{
"name": "id",
"required": True,
"type": "integer",
"description": "购买记录ID"
}]
}
},
{
"name": "获取流量采购统计",
"method": "GET",
"path": "/v2/store/traffic/statistics",
"folderId": STORE_FOLDER_ID,
"description": "获取流量采购统计数据\n\n**功能特性**:\n- 总购买记录数和流量数\n- 今日/本周/本月统计\n- 按状态统计\n- 热门流量池包排行\n- 购买趋势数据",
"tags": ["流量采购"]
}
]
# ==================== 执行更新和上传 ====================
print("=" * 60)
print("开始更新和上传接口到Apifox...")
print(f"项目ID: {PROJECT_ID}")
print("=" * 60)
# 1. 更新登录接口
print("\n【1/3】更新登录接口...")
login_keys = ["passwordLogin", "noPasswordLogin", "sendCode", "mobileLogin"]
for i, (key, api) in enumerate(zip(login_keys, login_apis), 1):
api_id = LOGIN_API_IDS[key]
print(f" [{i}/4] 更新: {api['name']} (ID: {api_id})")
success, error = update_api(api_id, api)
if success:
print(f" ✅ 更新成功")
else:
print(f" ❌ 更新失败: {error}")
# 2. 更新Agent接口
print("\n【2/3】更新Agent接口...")
agent_keys = ["getModules", "updateStatus"]
for i, (key, api) in enumerate(zip(agent_keys, agent_apis), 1):
api_id = AGENT_API_IDS[key]
print(f" [{i}/2] 更新: {api['name']} (ID: {api_id})")
success, error = update_api(api_id, api)
if success:
print(f" ✅ 更新成功")
else:
print(f" ❌ 更新失败: {error}")
# 3. 上传流量采购接口
print("\n【3/3】上传流量采购接口...")
traffic_api_ids = []
for i, api in enumerate(traffic_apis, 1):
print(f" [{i}/{len(traffic_apis)}] 创建: {api['name']}")
success, api_id, error = create_api(api)
if success:
print(f" ✅ 创建成功 (ID: {api_id})")
traffic_api_ids.append(api_id)
else:
print(f" ❌ 创建失败: {error}")
# 输出结果
print("\n" + "=" * 60)
print("✅ 完成！")
print("\n📊 统计:")
print(f" - 登录接口: 4个（已更新）")
print(f" - Agent接口: 2个（已更新）")
print(f" - 流量采购接口: {len(traffic_api_ids)}/{len(traffic_apis)}个（已创建）")
if traffic_api_ids:
print(f"\n📝 流量采购接口ID:")
for i, api_id in enumerate(traffic_api_ids, 1):
print(f" {i}. {api_id}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print("=" * 60)

176
application/store/upload_customer_apis.py Normal file
View File

@@ -0,0 +1,176 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
# 目录ID（如果目录已创建，请在这里填写目录ID，否则将上传到父目录）
CUSTOMER_FOLDER_ID = "" # 请在此填写客户管理目录ID，或留空使用父目录
print("=" * 60)
print("上传客户管理接口到Apifox")
print("=" * 60)
print(f"父目录ID: {PARENT_FOLDER_ID}")
# 使用提供的目录ID或父目录
folder_id = CUSTOMER_FOLDER_ID if CUSTOMER_FOLDER_ID else PARENT_FOLDER_ID
print(f"客户管理目录ID: {folder_id}")
print("=" * 60)
# 客户管理接口列表
apis = [
{
"name": "获取客户列表",
"method": "GET",
"path": "/v2/store/customers",
"folderId": folder_id,
"description": "获取当前用户的客户列表，支持分页、搜索、筛选。\n\n**功能特性**:\n- 支持关键词搜索（昵称、微信号、手机号）\n- 支持状态筛选（潜在、活跃、沉默、流失）\n- 支持价值筛选（高、中、低）\n- 支持生命周期筛选\n- 返回客户基本信息、状态、价值、标签、最后联系时间等",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "keyword", "type": "string", "description": "关键词搜索（昵称、微信号、手机号）"},
{"name": "status", "type": "string", "description": "状态筛选：潜在、活跃、沉默、流失"},
{"name": "value", "type": "string", "description": "价值筛选：高、中、低"},
{"name": "lifecycle", "type": "string", "description": "生命周期筛选：潜在、活跃、沉默、流失"}
]
}
},
{
"name": "获取客户详情",
"method": "GET",
"path": "/v2/store/customers/:id",
"folderId": folder_id,
"description": "获取指定客户的详细信息，包括：\n- 好友概览（头像、昵称、微信号、转化状态、估值）\n- 互动统计（聊天消息数、朋友圈互动数、红包转账总额、活跃度评分）\n- 微信资料（昵称、备注名、微信号、地区、微信手机号）\n- 基础信息（姓名、性别、年龄、手机号、邮箱、身份证号、住址）\n- 客户标签（流量池标签、普通标签）\n- 价值评估详情（RFM模型、CLV模型、社交裂变模型）\n- 用户旅程（访问朋友圈、地理位置、点赞记录、成交记录等）\n- 消费偏好（核心兴趣画像、偏好品类、最近消费）\n- AI智能洞察（客户画像总结、预测与建议）",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "客户ID（poolCompanyId）"}
]
}
},
{
"name": "更新客户信息",
"method": "PUT",
"path": "/v2/store/customers/:id",
"folderId": folder_id,
"description": "更新客户信息，支持更新微信资料、基础信息、标签。\n\n**更新类型**:\n- wechat: 更新微信资料（备注名）\n- personal: 更新基础信息（姓名、性别、年龄、手机号、邮箱、身份证号、住址）\n- tags: 更新客户标签",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "客户ID（poolCompanyId）"}
]
},
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"updateType": {"type": "string", "description": "更新类型：wechat=微信资料，personal=基础信息，tags=标签"},
"remarkName": {"type": "string", "description": "备注名（更新微信资料时）"},
"realName": {"type": "string", "description": "姓名（更新基础信息时）"},
"sex": {"type": "string", "description": "性别：男、女（更新基础信息时）"},
"age": {"type": "integer", "description": "年龄（更新基础信息时）"},
"phone": {"type": "string", "description": "手机号（更新基础信息时）"},
"email": {"type": "string", "description": "邮箱（更新基础信息时）"},
"idNumber": {"type": "string", "description": "身份证号（更新基础信息时）"},
"address": {"type": "string", "description": "住址（更新基础信息时）"},
"tags": {"type": "array", "items": {"type": "string"}, "description": "标签列表（更新标签时）"}
}
}
}
}
]
print(f"\n开始上传 {len(apis)} 个接口...")
print("=" * 60)
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_info in enumerate(api_ids, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
if folder_id != PARENT_FOLDER_ID:
print(f" 客户管理目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "客户管理接口上传成功.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 客户管理接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 目录ID: {folder_id}\n")
f.write(f"- 项目ID: {PROJECT_ID}\n\n")
f.write(f"## 接口列表\n\n")
for api_info in api_ids:
f.write(f"### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

134
application/store/upload_device_wechat_apis.py Normal file
View File

@@ -0,0 +1,134 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
# 目录ID（如果目录已创建，请在这里填写目录ID，否则将上传到父目录）
DEVICE_WECHAT_FOLDER_ID = "" # 请在此填写设备和微信目录ID，或留空使用父目录
print("=" * 60)
print("上传设备和微信接口到Apifox")
print("=" * 60)
print(f"父目录ID: {PARENT_FOLDER_ID}")
# 使用提供的目录ID或父目录
folder_id = DEVICE_WECHAT_FOLDER_ID if DEVICE_WECHAT_FOLDER_ID else PARENT_FOLDER_ID
print(f"设备和微信目录ID: {folder_id}")
print("=" * 60)
# 设备和微信接口列表
apis = [
{
"name": "获取设备和微信信息",
"method": "GET",
"path": "/v2/store/device-wechat/info",
"folderId": folder_id,
"description": "获取当前用户绑定的设备和微信信息，包括：\n- 用户资料（头像、昵称、微信号）\n- 设备信息（设备持有人、IMEI）\n- 设备状态（设备在线、微信正常）\n- 微信健康分（分数、状态、每日加粉限额、今日已添加、剩余）\n- 加粉统计（成功、失败、待加）\n- 基础构成（账号基础分、基础信息、好友数量加成）",
},
{
"name": "获取动态记录",
"method": "GET",
"path": "/v2/store/device-wechat/dynamic-records",
"folderId": folder_id,
"description": "获取微信健康分的动态记录（分页），仅显示近7天记录。包括健康分变动记录，如触发限额、封号、不触发频繁等。",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10, "maximum": 100}
]
}
}
]
print(f"\n开始上传 {len(apis)} 个接口...")
print("=" * 60)
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_info in enumerate(api_ids, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
if folder_id != PARENT_FOLDER_ID:
print(f" 设备和微信目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "设备和微信接口上传成功.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 设备和微信接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 目录ID: {folder_id}\n")
f.write(f"- 项目ID: {PROJECT_ID}\n\n")
f.write(f"## 接口列表\n\n")
for api_info in api_ids:
f.write(f"### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

267
application/store/upload_flow_packages.py Normal file
View File

@@ -0,0 +1,267 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
FOLDER_ID = "78121195" # 流量采购管理目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 流量采购接口列表
apis = [
{
"name": "获取流量套餐列表",
"method": "GET",
"path": "/v2/store/flow-packages",
"folderId": FOLDER_ID,
"description": "获取所有可购买的流量套餐列表\n\n**功能特性**:\n- 只返回启用状态的套餐\n- 按排序字段排序\n- 包含套餐价格、月流量、时长等信息",
"tags": ["流量采购"],
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "array",
"items": {
"type": "object",
"properties": {
"id": {"type": "integer", "description": "套餐ID"},
"name": {"type": "string", "description": "套餐名称"},
"tag": {"type": "string", "description": "套餐标签"},
"originalPrice": {"type": "number", "description": "原价"},
"price": {"type": "number", "description": "售价"},
"monthlyFlow": {"type": "integer", "description": "每月流量(人/月)"},
"duration": {"type": "integer", "description": "套餐时长(月)"},
"discount": {"type": "string", "description": "折扣"},
"totalFlow": {"type": "integer", "description": "总流量(人)"},
"privileges": {"type": "array", "description": "套餐特权"}
}
}
}
}
}
}]
},
{
"name": "获取流量套餐详情",
"method": "GET",
"path": "/v2/store/flow-packages/{id}",
"folderId": FOLDER_ID,
"description": "获取指定流量套餐的详细信息\n\n**功能特性**:\n- 包含套餐完整信息\n- 包含计算字段（折扣、总流量等）",
"tags": ["流量采购"],
"parameters": {
"path": [{
"name": "id",
"required": True,
"type": "integer",
"description": "套餐ID"
}]
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"id": {"type": "integer"},
"name": {"type": "string"},
"tag": {"type": "string"},
"originalPrice": {"type": "number"},
"price": {"type": "number"},
"monthlyFlow": {"type": "integer"},
"duration": {"type": "integer"},
"discount": {"type": "string"},
"totalFlow": {"type": "integer"},
"privileges": {"type": "array"}
}
}
}
}
}]
},
{
"name": "获取剩余流量",
"method": "GET",
"path": "/v2/store/flow-packages/remaining-flow",
"folderId": FOLDER_ID,
"description": "获取当前用户的有效流量套餐剩余流量信息\n\n**功能特性**:\n- 自动从JWT Token获取用户ID\n- 返回剩余流量、剩余天数、百分比等信息\n- 如果用户没有有效套餐，返回404",
"tags": ["流量采购"],
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"packageName": {"type": "string", "description": "套餐名称"},
"remainingFlow": {"type": "integer", "description": "剩余流量(人)"},
"totalFlow": {"type": "integer", "description": "总流量(人)"},
"flowPercentage": {"type": "number", "description": "剩余流量百分比"},
"remainingDays": {"type": "integer", "description": "剩余天数"},
"totalDays": {"type": "integer", "description": "总天数"},
"timePercentage": {"type": "number", "description": "剩余时间百分比"},
"expireTime": {"type": "string", "description": "到期日期"},
"startTime": {"type": "string", "description": "开始日期"}
}
}
}
}
}]
},
{
"name": "创建流量采购订单",
"method": "POST",
"path": "/v2/store/flow-packages/order",
"folderId": FOLDER_ID,
"description": "创建流量套餐购买订单\n\n**功能特性**:\n- 自动从JWT Token获取用户ID\n- 支持金额为0的免费套餐（自动完成）\n- 返回订单信息供前端跳转支付",
"tags": ["流量采购"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["packageId"],
"properties": {
"packageId": {"type": "integer", "description": "套餐ID"},
"payType": {"type": "string", "description": "支付方式", "enum": ["wechat", "alipay"], "default": "wechat"},
"remark": {"type": "string", "description": "备注"}
}
}
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"orderNo": {"type": "string", "description": "订单号"},
"amount": {"type": "number", "description": "订单金额（仅待支付订单）"},
"payType": {"type": "string", "description": "支付方式（仅待支付订单）"},
"status": {"type": "string", "description": "订单状态：success=购买成功（免费套餐），pending=待支付"}
}
}
}
}
}]
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/flow-packages/orders",
"folderId": FOLDER_ID,
"description": "获取当前用户的流量套餐订单列表\n\n**功能特性**:\n- 自动从JWT Token获取用户ID\n- 支持分页查询\n- 支持按订单状态筛选",
"tags": ["流量采购"],
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态：0=待支付, 1=已完成, 2=已取消, 3=已退款"}
]
},
"responses": [{
"code": 200,
"contentType": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"code": {"type": "integer"},
"msg": {"type": "string"},
"data": {
"type": "object",
"properties": {
"list": {"type": "array", "description": "订单列表"},
"total": {"type": "integer", "description": "总数量"},
"page": {"type": "integer", "description": "当前页码"},
"limit": {"type": "integer", "description": "每页数量"}
}
}
}
}
}]
}
]
# 创建接口
print("=" * 60)
print("开始上传流量采购接口到Apifox...")
print(f"项目ID: {PROJECT_ID}")
print(f"目录ID: {FOLDER_ID}")
print("=" * 60)
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append(api_id)
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_id in enumerate(api_ids, 1):
print(f" {i}. {api_id}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print(f" 流量采购目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{FOLDER_ID}")
print("=" * 60)

141
application/store/upload_flow_packages_simple.py Normal file
View File

@@ -0,0 +1,141 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
FOLDER_ID = "78121195" # 流量采购管理目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 流量采购接口列表（简化版）
apis = [
{
"name": "获取流量套餐列表",
"method": "GET",
"path": "/v2/store/flow-packages",
"folderId": FOLDER_ID,
"description": "获取所有可购买的流量套餐列表"
},
{
"name": "获取流量套餐详情",
"method": "GET",
"path": "/v2/store/flow-packages/:id",
"folderId": FOLDER_ID,
"description": "获取指定流量套餐的详细信息",
"parameters": {
"path": [{
"name": "id",
"required": True,
"description": "套餐ID"
}]
}
},
{
"name": "获取剩余流量",
"method": "GET",
"path": "/v2/store/flow-packages/remaining-flow",
"folderId": FOLDER_ID,
"description": "获取当前用户的有效流量套餐剩余流量信息"
},
{
"name": "创建流量采购订单",
"method": "POST",
"path": "/v2/store/flow-packages/order",
"folderId": FOLDER_ID,
"description": "创建流量套餐购买订单",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["packageId"],
"properties": {
"packageId": {"type": "integer", "description": "套餐ID"},
"payType": {"type": "string", "description": "支付方式", "default": "wechat"},
"remark": {"type": "string", "description": "备注"}
}
}
}
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/flow-packages/orders",
"folderId": FOLDER_ID,
"description": "获取当前用户的流量套餐订单列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态"}
]
}
}
]
# 创建接口
print("=" * 60)
print("开始上传流量采购接口到Apifox...")
print(f"项目ID: {PROJECT_ID}")
print(f"目录ID: {FOLDER_ID}")
print("=" * 60)
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append(api_id)
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_id in enumerate(api_ids, 1):
print(f" {i}. {api_id}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print(f" 流量采购目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{FOLDER_ID}")
print("=" * 60)

127
application/store/upload_to_apifox.py Normal file
View File

@@ -0,0 +1,127 @@
# -*- coding: utf-8 -*-
import requests
import json
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
FOLDER_ID = "78015216" # 门店端-新版 目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 接口列表
apis = [
{
"name": "账号密码登录",
"method": "POST",
"path": "/v2/store/auth/login",
"folderId": FOLDER_ID,
"description": "使用账号和密码进行登录，支持H5和APP端",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["account", "password"],
"properties": {
"account": {"type": "string", "description": "账号/手机号"},
"password": {"type": "string", "description": "密码"},
"typeId": {"type": "integer", "description": "类型ID，固定为2"},
"deviceId": {"type": "string", "description": "设备ID（可选）"}
}
}
}
},
{
"name": "免密登录（设备ID）",
"method": "GET",
"path": "/v2/store/auth/login",
"folderId": FOLDER_ID,
"description": "基于设备ID进行免密登录，适用于APP端\n\n**请求参数**:\n- deviceId: 设备IMEI",
"tags": ["认证"],
"parameters": {
"query": [{
"name": "deviceId",
"required": True,
"type": "string",
"description": "设备IMEI"
}]
}
},
{
"name": "发送短信验证码",
"method": "POST",
"path": "/v2/store/auth/send-code",
"folderId": FOLDER_ID,
"description": "发送短信验证码到手机\n\n**功能特性**:\n- 60秒发送频率限制\n- 验证码5分钟有效期\n- 支持阿里云短信服务",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["mobile"],
"properties": {
"mobile": {"type": "string", "description": "手机号"},
"type": {"type": "string", "description": "验证码类型", "enum": ["login", "register", "reset"]}
}
}
}
},
{
"name": "手机验证码登录",
"method": "POST",
"path": "/v2/store/auth/mobile-login",
"folderId": FOLDER_ID,
"description": "使用手机号和验证码进行登录\n\n**功能特性**:\n- 自动注册新用户（首次登录）\n- 验证码验证后自动失效",
"tags": ["认证"],
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["mobile", "code"],
"properties": {
"mobile": {"type": "string", "description": "手机号"},
"code": {"type": "string", "description": "验证码"},
"is_encrypted": {"type": "boolean", "description": "是否加密"}
}
}
}
}
]
# 创建接口
print("开始上传接口到Apifox...")
print(f"项目ID: {PROJECT_ID}")
print(f"Token: {TOKEN[:20]}...")
print("-" * 50)
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
print(f" [OK] Success: {api['method']} {api['path']}")
else:
print(f" [FAIL] Error: {result.get('errorMessage', 'Unknown')}")
else:
print(f" [FAIL] HTTP {response.status_code}: {response.text[:200]}")
except Exception as e:
print(f" [ERROR] Exception: {str(e)}")
print("\n" + "=" * 50)
print("[DONE] Completed! Created 4 APIs")
print("\nVisit Apifox: https://app.apifox.com/project/6037107")

249
application/store/upload_user_tokens_apis.py Normal file
View File

@@ -0,0 +1,249 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
# 目录ID（如果目录已创建，请在这里填写目录ID，否则将上传到父目录）
# 用户管理目录ID（如果已创建，填写ID；否则留空使用父目录）
USER_FOLDER_ID = "" # 请在此填写用户管理目录ID，或留空使用父目录
# 算力中心目录ID（如果已创建，填写ID；否则留空使用父目录）
TOKENS_FOLDER_ID = "" # 请在此填写算力中心目录ID，或留空使用父目录
print("=" * 60)
print("上传用户管理和算力中心接口到Apifox")
print("=" * 60)
print(f"父目录ID: {PARENT_FOLDER_ID}")
# 使用提供的目录ID或父目录
user_folder_id = USER_FOLDER_ID if USER_FOLDER_ID else PARENT_FOLDER_ID
tokens_folder_id = TOKENS_FOLDER_ID if TOKENS_FOLDER_ID else PARENT_FOLDER_ID
print(f"用户管理目录ID: {user_folder_id}")
print(f"算力中心目录ID: {tokens_folder_id}")
print("=" * 60)
# 用户管理接口列表
user_apis = [
{
"name": "获取用户资料",
"method": "GET",
"path": "/v2/store/user/profile",
"folderId": user_folder_id,
"description": "获取当前用户的详细资料，包含基本信息、算力信息（剩余算力、今日使用、本月使用、总算力等）",
},
{
"name": "更新用户资料",
"method": "PUT",
"path": "/v2/store/user/profile",
"folderId": user_folder_id,
"description": "更新用户资料，支持修改头像、昵称、密码",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"username": {"type": "string", "description": "昵称"},
"avatar": {"type": "string", "description": "头像URL"},
"oldPassword": {"type": "string", "description": "旧密码（修改密码时必填）"},
"newPassword": {"type": "string", "description": "新密码（修改密码时必填，长度不能少于6位）"}
}
}
}
}
]
# 算力中心接口列表
tokens_apis = [
{
"name": "获取算力套餐列表",
"method": "GET",
"path": "/v2/store/tokens/packages",
"folderId": tokens_folder_id,
"description": "获取所有可购买的算力套餐列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10}
]
}
},
{
"name": "购买算力",
"method": "POST",
"path": "/v2/store/tokens/pay",
"folderId": tokens_folder_id,
"description": "购买算力套餐或自定义购买算力",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"properties": {
"id": {"type": "integer", "description": "套餐ID（购买套餐时必填）"},
"price": {"type": "number", "description": "自定义购买金额（元，自定义购买时必填）"},
"payType": {"type": "string", "description": "支付方式：wechat=微信，alipay=支付宝，qrCode=二维码", "default": "qrCode"}
}
}
}
},
{
"name": "查询订单状态",
"method": "GET",
"path": "/v2/store/tokens/order",
"folderId": tokens_folder_id,
"description": "查询算力购买订单的支付状态",
"parameters": {
"query": [
{"name": "orderNo", "type": "string", "required": True, "description": "订单号"}
]
}
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/tokens/orders",
"folderId": tokens_folder_id,
"description": "获取当前用户的算力购买订单列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态：0=待支付，1=已付款，2=已退款，3=付款失败"},
{"name": "keyword", "type": "string", "description": "关键词搜索（订单号或商品名称）"},
{"name": "orderType", "type": "integer", "description": "订单类型：1=购买算力"},
{"name": "payType", "type": "integer", "description": "支付类型：1=微信支付，2=支付宝"},
{"name": "startTime", "type": "string", "description": "开始时间（格式：Y-m-d）"},
{"name": "endTime", "type": "string", "description": "结束时间（格式：Y-m-d）"}
]
}
},
{
"name": "获取算力统计",
"method": "GET",
"path": "/v2/store/tokens/statistics",
"folderId": tokens_folder_id,
"description": "获取当前用户的算力统计信息，包括总算力、今日使用、本月使用、剩余算力、累计消费、预计可用天数等",
}
]
# 合并所有接口
all_apis = user_apis + tokens_apis
print(f"\n开始上传 {len(all_apis)} 个接口...")
print("=" * 60)
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(all_apis, 1):
print(f"\n[{i}/{len(all_apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path'],
'folderId': api['folderId']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(all_apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
# 按目录分组显示
user_apis_list = [api for api in api_ids if api['folderId'] == user_folder_id]
tokens_apis_list = [api for api in api_ids if api['folderId'] == tokens_folder_id]
if user_apis_list:
print(f"\n【用户管理】目录 (ID: {user_folder_id}):")
for i, api_info in enumerate(user_apis_list, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
if tokens_apis_list:
print(f"\n【算力中心】目录 (ID: {tokens_folder_id}):")
for i, api_info in enumerate(tokens_apis_list, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
if user_folder_id != PARENT_FOLDER_ID:
print(f" 用户管理目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{user_folder_id}")
if tokens_folder_id != PARENT_FOLDER_ID:
print(f" 算力中心目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{tokens_folder_id}")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "用户管理和算力中心接口上传成功.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 用户管理和算力中心接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 用户管理目录ID: {user_folder_id}\n")
f.write(f"- 算力中心目录ID: {tokens_folder_id}\n")
f.write(f"- 项目ID: {PROJECT_ID}\n\n")
f.write(f"## 接口列表\n\n")
if user_apis_list:
f.write(f"### 用户管理\n\n")
for api_info in user_apis_list:
f.write(f"#### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
if tokens_apis_list:
f.write(f"### 算力中心\n\n")
for api_info in tokens_apis_list:
f.write(f"#### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

235
application/store/upload_vendor_apis.py Normal file
View File

@@ -0,0 +1,235 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 步骤1: 尝试创建目录
print("=" * 60)
print("步骤1: 创建供应链采购管理目录...")
print("=" * 60)
folder_name = "供应链采购管理"
folder_id = None
try:
# 尝试创建目录
folder_data = {
"name": folder_name,
"parentId": PARENT_FOLDER_ID,
"type": "folder"
}
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/folders",
headers=headers,
json=folder_data,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
folder_id = result.get('data', {}).get('id')
print(f"✅ 目录创建成功 (ID: {folder_id})")
else:
print(f"⚠️ 目录创建失败: {result.get('errorMessage', 'Unknown error')}")
print(" 将尝试使用现有目录或上传到父目录")
else:
print(f"⚠️ HTTP {response.status_code}: {response.text[:200]}")
print(" 将尝试使用现有目录或上传到父目录")
except Exception as e:
print(f"⚠️ 创建目录异常: {str(e)}")
print(" 将尝试使用现有目录或上传到父目录")
# 如果目录创建失败，使用父目录ID
if not folder_id:
folder_id = PARENT_FOLDER_ID
print(f"\n📁 将上传到父目录 (ID: {folder_id})")
print(" 请手动创建'供应链采购管理'目录后，将接口移动到该目录")
# 步骤2: 上传接口
print("\n" + "=" * 60)
print("步骤2: 上传供应链采购接口...")
print(f"目录ID: {folder_id}")
print("=" * 60)
# 供应链采购接口列表
apis = [
{
"name": "获取供应商套餐列表",
"method": "GET",
"path": "/v2/store/vendor/list",
"folderId": folder_id,
"description": "获取所有可购买的供应商套餐列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "keyword", "type": "string", "description": "关键词搜索"},
{"name": "status", "type": "integer", "description": "状态筛选：1=上架，0=下架"}
]
}
},
{
"name": "获取供应商套餐详情",
"method": "GET",
"path": "/v2/store/vendor/detail",
"folderId": folder_id,
"description": "获取指定供应商套餐的详细信息，包含项目列表",
"parameters": {
"query": [
{"name": "id", "type": "integer", "required": True, "description": "套餐ID"}
]
}
},
{
"name": "创建供应商订单",
"method": "POST",
"path": "/v2/store/vendor/order",
"folderId": folder_id,
"description": "创建供应商套餐购买订单",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["packageId"],
"properties": {
"packageId": {"type": "integer", "description": "套餐ID"},
"remark": {"type": "string", "description": "备注"}
}
}
}
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/vendor/orders",
"folderId": folder_id,
"description": "获取当前用户的供应商订单列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态：0=待支付，1=已支付，2=已完成，3=已取消"},
{"name": "keyword", "type": "string", "description": "关键词搜索（订单号或套餐名称）"}
]
}
},
{
"name": "获取订单详情",
"method": "GET",
"path": "/v2/store/vendor/orders/:id",
"folderId": folder_id,
"description": "获取指定供应商订单的详细信息",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
},
{
"name": "取消订单",
"method": "POST",
"path": "/v2/store/vendor/orders/:id/cancel",
"folderId": folder_id,
"description": "取消待支付的供应商订单",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
}
]
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_info in enumerate(api_ids, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
if folder_id != PARENT_FOLDER_ID:
print(f" 供应链采购目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
else:
print(f" 父目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{PARENT_FOLDER_ID}")
print(f" ⚠️ 请手动创建'供应链采购管理'目录，并将接口移动到该目录")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "供应链采购接口上传成功.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 供应链采购接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 目录名称: {folder_name}\n")
f.write(f"- 目录ID: {folder_id}\n")
f.write(f"- 父目录ID: {PARENT_FOLDER_ID}\n\n")
f.write(f"## 接口列表\n\n")
for api_info in api_ids:
f.write(f"### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

308
application/store/upload_vendor_apis_v2.py Normal file
View File

@@ -0,0 +1,308 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
PARENT_FOLDER_ID = "78015216" # 门店端-新版目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
# 步骤1: 创建目录（通过导入OpenAPI方式）
print("=" * 60)
print("步骤1: 创建供应链采购管理目录...")
print("=" * 60)
folder_name = "供应链采购管理"
# 使用 folder_manager.py 的方法：通过导入OpenAPI创建目录
try:
openapi_spec = {
"openapi": "3.0.0",
"info": {
"title": "供应链采购管理目录创建",
"version": "1.0.0"
},
"tags": [
{
"name": folder_name,
"description": "供应链采购管理相关接口"
}
],
"paths": {
f"/api/__placeholder__/supply-chain": {
"get": {
"summary": f"[占位] {folder_name} 目录占位接口",
"description": "这是一个占位接口，用于创建目录。可以在 Apifox 中手动删除。",
"tags": [folder_name],
"responses": {
"200": {
"description": "占位响应"
}
}
}
}
}
}
payload = {
"input": json.dumps(openapi_spec, ensure_ascii=False),
"options": {
"targetEndpointFolderId": int(PARENT_FOLDER_ID), # 指定父目录
"endpointOverwriteBehavior": "CREATE_NEW"
}
}
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/import-openapi",
headers=headers,
json=payload,
params={"locale": "zh-CN"},
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
counters = result.get('data', {}).get('counters', {})
endpoint_folder_created = counters.get('endpointFolderCreated', 0)
if endpoint_folder_created > 0:
print(f"✅ 目录创建成功！")
print(f" 已创建 {endpoint_folder_created} 个目录")
else:
print(f"⚠️ 目录可能已存在，继续上传接口...")
else:
print(f"⚠️ 目录创建失败: {result.get('errorMessage', 'Unknown error')}")
print(" 继续尝试上传接口到父目录...")
else:
print(f"⚠️ HTTP {response.status_code}: {response.text[:200]}")
print(" 继续尝试上传接口到父目录...")
except Exception as e:
print(f"⚠️ 创建目录异常: {str(e)}")
print(" 继续尝试上传接口到父目录...")
# 步骤2: 先获取目录ID（通过导出项目结构查找）
print("\n" + "=" * 60)
print("步骤2: 查找目录ID...")
print("=" * 60)
folder_id = None
try:
# 导出项目结构来查找目录
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/export-openapi",
headers=headers,
json={"version": "3.0"},
timeout=30
)
if response.status_code == 200:
openapi_data = response.json()
tags = openapi_data.get('tags', [])
for tag in tags:
if tag.get('name') == folder_name:
# 找到目录，但需要获取实际的folderId
# 由于OpenAPI导出不包含folderId，我们需要通过其他方式获取
print(f"✅ 找到目录: {folder_name}")
break
# 如果找不到，使用父目录ID
if not folder_id:
folder_id = PARENT_FOLDER_ID
print(f"📁 将上传到父目录 (ID: {folder_id})")
print(" 提示：如果目录已创建，可以在Apifox Web UI中查看目录ID，然后手动移动接口")
else:
folder_id = PARENT_FOLDER_ID
print(f"⚠️ 无法获取目录信息，使用父目录 (ID: {folder_id})")
except Exception as e:
folder_id = PARENT_FOLDER_ID
print(f"⚠️ 查找目录异常: {str(e)}")
print(f" 使用父目录 (ID: {folder_id})")
# 步骤3: 上传接口
print("\n" + "=" * 60)
print("步骤3: 上传供应链采购接口...")
print(f"目录ID: {folder_id}")
print("=" * 60)
# 供应链采购接口列表
apis = [
{
"name": "获取供应商套餐列表",
"method": "GET",
"path": "/v2/store/vendor/list",
"folderId": folder_id,
"description": "获取所有可购买的供应商套餐列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "keyword", "type": "string", "description": "关键词搜索"},
{"name": "status", "type": "integer", "description": "状态筛选：1=上架，0=下架"}
]
}
},
{
"name": "获取供应商套餐详情",
"method": "GET",
"path": "/v2/store/vendor/detail",
"folderId": folder_id,
"description": "获取指定供应商套餐的详细信息，包含项目列表",
"parameters": {
"query": [
{"name": "id", "type": "integer", "required": True, "description": "套餐ID"}
]
}
},
{
"name": "创建供应商订单",
"method": "POST",
"path": "/v2/store/vendor/order",
"folderId": folder_id,
"description": "创建供应商套餐购买订单",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["packageId"],
"properties": {
"packageId": {"type": "integer", "description": "套餐ID"},
"remark": {"type": "string", "description": "备注"}
}
}
}
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/vendor/orders",
"folderId": folder_id,
"description": "获取当前用户的供应商订单列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态：0=待支付，1=已支付，2=已完成，3=已取消"},
{"name": "keyword", "type": "string", "description": "关键词搜索（订单号或套餐名称）"}
]
}
},
{
"name": "获取订单详情",
"method": "GET",
"path": "/v2/store/vendor/orders/:id",
"folderId": folder_id,
"description": "获取指定供应商订单的详细信息",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
},
{
"name": "取消订单",
"method": "POST",
"path": "/v2/store/vendor/orders/:id/cancel",
"folderId": folder_id,
"description": "取消待支付的供应商订单",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
}
]
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_info in enumerate(api_ids, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print(f" 父目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{PARENT_FOLDER_ID}")
if folder_id != PARENT_FOLDER_ID:
print(f" 供应链采购目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{folder_id}")
else:
print(f"\n💡 提示:")
print(f" 1. 目录可能已通过OpenAPI导入创建")
print(f" 2. 请在Apifox Web UI中查看是否已创建'{folder_name}'目录")
print(f" 3. 如果目录已创建，可以使用 move_vendor_to_folder.py 脚本移动接口")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "供应链采购接口上传成功.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 供应链采购接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 目录名称: {folder_name}\n")
f.write(f"- 目录ID: {folder_id if folder_id != PARENT_FOLDER_ID else '待确认'}\n")
f.write(f"- 父目录ID: {PARENT_FOLDER_ID}\n\n")
f.write(f"## 接口列表\n\n")
for api_info in api_ids:
f.write(f"### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

187
application/store/upload_vendor_to_folder.py Normal file
View File

@@ -0,0 +1,187 @@
# -*- coding: utf-8 -*-
import sys
import requests
import json
sys.stdout.reconfigure(encoding='utf-8')
# 配置
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
FOLDER_ID = "78176561" # 供应链采购管理目录ID
BASE_URL = "https://api.apifox.com/api/v1"
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}",
"Content-Type": "application/json; charset=utf-8"
}
print("=" * 60)
print("上传供应链采购接口到指定目录")
print("=" * 60)
print(f"目录ID: {FOLDER_ID}")
print("=" * 60)
# 供应链采购接口列表
apis = [
{
"name": "获取供应商套餐列表",
"method": "GET",
"path": "/v2/store/vendor/list",
"folderId": FOLDER_ID,
"description": "获取所有可购买的供应商套餐列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "keyword", "type": "string", "description": "关键词搜索"},
{"name": "status", "type": "integer", "description": "状态筛选：1=上架，0=下架"}
]
}
},
{
"name": "获取供应商套餐详情",
"method": "GET",
"path": "/v2/store/vendor/detail",
"folderId": FOLDER_ID,
"description": "获取指定供应商套餐的详细信息，包含项目列表",
"parameters": {
"query": [
{"name": "id", "type": "integer", "required": True, "description": "套餐ID"}
]
}
},
{
"name": "创建供应商订单",
"method": "POST",
"path": "/v2/store/vendor/order",
"folderId": FOLDER_ID,
"description": "创建供应商套餐购买订单",
"requestBody": {
"type": "application/json",
"jsonSchema": {
"type": "object",
"required": ["packageId"],
"properties": {
"packageId": {"type": "integer", "description": "套餐ID"},
"remark": {"type": "string", "description": "备注"}
}
}
}
},
{
"name": "获取订单列表",
"method": "GET",
"path": "/v2/store/vendor/orders",
"folderId": FOLDER_ID,
"description": "获取当前用户的供应商订单列表",
"parameters": {
"query": [
{"name": "page", "type": "integer", "description": "页码", "default": 1},
{"name": "limit", "type": "integer", "description": "每页数量", "default": 10},
{"name": "pageSize", "type": "integer", "description": "每页数量（兼容参数）", "default": 10},
{"name": "status", "type": "integer", "description": "订单状态：0=待支付，1=已支付，2=已完成，3=已取消"},
{"name": "keyword", "type": "string", "description": "关键词搜索（订单号或套餐名称）"}
]
}
},
{
"name": "获取订单详情",
"method": "GET",
"path": "/v2/store/vendor/orders/:id",
"folderId": FOLDER_ID,
"description": "获取指定供应商订单的详细信息",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
},
{
"name": "取消订单",
"method": "POST",
"path": "/v2/store/vendor/orders/:id/cancel",
"folderId": FOLDER_ID,
"description": "取消待支付的供应商订单",
"parameters": {
"path": [
{"name": "id", "type": "integer", "required": True, "description": "订单ID"}
]
}
}
]
success_count = 0
fail_count = 0
api_ids = []
for i, api in enumerate(apis, 1):
print(f"\n[{i}/{len(apis)}] 创建接口: {api['name']}")
print(f" {api['method']} {api['path']}")
try:
response = requests.post(
f"{BASE_URL}/projects/{PROJECT_ID}/http-apis",
headers=headers,
json=api,
timeout=30
)
if response.status_code == 200:
result = response.json()
if result.get('success'):
api_id = result.get('data', {}).get('id')
print(f" ✅ 创建成功 (ID: {api_id})")
success_count += 1
api_ids.append({
'id': api_id,
'name': api['name'],
'path': api['path']
})
else:
print(f" ❌ 创建失败: {result.get('errorMessage', 'Unknown error')}")
fail_count += 1
else:
print(f" ❌ HTTP {response.status_code}: {response.text[:200]}")
fail_count += 1
except Exception as e:
print(f" ❌ 异常: {str(e)}")
fail_count += 1
# 输出结果
print("\n" + "=" * 60)
print("✅ 上传完成！")
print(f"\n📊 统计:")
print(f" - 成功: {success_count}/{len(apis)}")
print(f" - 失败: {fail_count}")
if api_ids:
print(f"\n📝 接口ID列表:")
for i, api_info in enumerate(api_ids, 1):
print(f" {i}. {api_info['name']} (ID: {api_info['id']})")
print(f" {api_info['path']}")
print(f"\n🔗 访问链接:")
print(f" https://app.apifox.com/project/{PROJECT_ID}")
print(f" 供应链采购目录: https://app.apifox.com/project/{PROJECT_ID}/apis/folder/{FOLDER_ID}")
print("=" * 60)
# 保存接口ID到文件
if api_ids:
output_file = "供应链采购接口上传成功_目录78176561.md"
with open(output_file, 'w', encoding='utf-8') as f:
f.write("# 供应链采购接口上传成功\n\n")
f.write(f"## 目录信息\n\n")
f.write(f"- 目录名称: 供应链采购管理\n")
f.write(f"- 目录ID: {FOLDER_ID}\n")
f.write(f"- 项目ID: {PROJECT_ID}\n\n")
f.write(f"## 接口列表\n\n")
for api_info in api_ids:
f.write(f"### {api_info['name']}\n\n")
f.write(f"- **接口ID**: {api_info['id']}\n")
f.write(f"- **路径**: {api_info['path']}\n\n")
print(f"\n💾 接口ID已保存到: {output_file}")

50
application/store/verify_folder.py Normal file
View File

@@ -0,0 +1,50 @@
# -*- coding: utf-8 -*-
import requests
import json
TOKEN = "afxp_fa4137GfIzJtlOCeQHjpCXc83SFWmeAOrZnq"
PROJECT_ID = "6037107"
FOLDER_ID = "78015216" # 门店端-新版
headers = {
"X-Apifox-Api-Version": "2024-03-28",
"Authorization": f"Bearer {TOKEN}"
}
print("=" * 80)
print("验证接口是否在 [门店端-新版] 目录下")
print("=" * 80)
print(f"项目ID: {PROJECT_ID}")
print(f"目录ID: {FOLDER_ID}")
print("-" * 80)
# 获取目录下的所有接口
response = requests.get(
f"https://api.apifox.com/api/v1/projects/{PROJECT_ID}/http-apis",
headers=headers
)
if response.status_code == 200:
result = response.json()
apis_data = result.get('data', [])
# 筛选出在目标目录下的接口
folder_apis = [api for api in apis_data if str(api.get('folderId')) == FOLDER_ID]
print(f"\n在 [门店端-新版] 目录下找到 {len(folder_apis)} 个接口:\n")
for i, api in enumerate(folder_apis, 1):
method = api.get('method', '').upper()
name = api.get('name', '')
path = api.get('path', '')
api_id = api.get('id', '')
print(f"[{i}] {method:6s} {name:20s} {path}")
print(f" API ID: {api_id}")
print("\n" + "=" * 80)
print("[OK] 验证完成!")
print("=" * 80)
else:
print(f"[ERROR] 请求失败: HTTP {response.status_code}")
print(response.text)

106
application/store/供应链采购接口Apifox上传完成.md Normal file
View File

@@ -0,0 +1,106 @@
# 供应链采购接口 Apifox 上传完成
## ✅ 上传结果
**上传时间**: 2025-02-05
**项目ID**: 6037107
**父目录**: 门店端-新版 (ID: 78015216)
### 接口列表（6个接口全部上传成功）
| 序号 | 接口名称 | 方法 | 路径 | 接口ID |
|------|---------|------|------|--------|
| 1 | 获取供应商套餐列表 | GET | `/v2/store/vendor/list` | 416273809 |
| 2 | 获取供应商套餐详情 | GET | `/v2/store/vendor/detail` | 416273810 |
| 3 | 创建供应商订单 | POST | `/v2/store/vendor/order` | 416273813 |
| 4 | 获取订单列表 | GET | `/v2/store/vendor/orders` | 416273814 |
| 5 | 获取订单详情 | GET | `/v2/store/vendor/orders/:id` | 416273815 |
| 6 | 取消订单 | POST | `/v2/store/vendor/orders/:id/cancel` | 416273816 |
## 📁 目录管理
### 当前状态
- ✅ 接口已上传到父目录：**门店端-新版** (ID: 78015216)
- ⚠️ 目录创建失败（Apifox API限制）
### 后续操作
**方案一：手动创建目录并移动接口（推荐）**
1. 在 Apifox Web UI 中：
- 进入项目：https://app.apifox.com/project/6037107
- 在"门店端-新版"目录下创建新目录：**供应链采购管理**
- 获取新目录的ID（从URL中获取，格式：`/apis/folder/{目录ID}`）
2. 运行移动脚本：
```bash
cd F:\karuo\yi-shi\Server\application\store
python move_vendor_to_folder.py
```
- 输入新创建的目录ID
- 脚本会自动将6个接口移动到该目录
**方案二：直接在 Apifox Web UI 中移动**
1. 在 Apifox Web UI 中创建"供应链采购管理"目录
2. 手动将以下接口移动到该目录：
- 416273809 - 获取供应商套餐列表
- 416273810 - 获取供应商套餐详情
- 416273813 - 创建供应商订单
- 416273814 - 获取订单列表
- 416273815 - 获取订单详情
- 416273816 - 取消订单
## 🔗 访问链接
- **项目首页**: https://app.apifox.com/project/6037107
- **父目录**: https://app.apifox.com/project/6037107/apis/folder/78015216
## 📝 接口说明
### 1. 获取供应商套餐列表
- **路径**: `GET /v2/store/vendor/list`
- **参数**:
- `page` (integer, 默认1) - 页码
- `limit` (integer, 默认10) - 每页数量
- `pageSize` (integer, 默认10) - 每页数量（兼容参数）
- `keyword` (string) - 关键词搜索
- `status` (integer) - 状态筛选：1=上架，0=下架
### 2. 获取供应商套餐详情
- **路径**: `GET /v2/store/vendor/detail`
- **参数**:
- `id` (integer, 必填) - 套餐ID
### 3. 创建供应商订单
- **路径**: `POST /v2/store/vendor/order`
- **请求体**:
- `packageId` (integer, 必填) - 套餐ID
- `remark` (string) - 备注
### 4. 获取订单列表
- **路径**: `GET /v2/store/vendor/orders`
- **参数**:
- `page` (integer, 默认1) - 页码
- `limit` (integer, 默认10) - 每页数量
- `pageSize` (integer, 默认10) - 每页数量（兼容参数）
- `status` (integer) - 订单状态：0=待支付，1=已支付，2=已完成，3=已取消
- `keyword` (string) - 关键词搜索（订单号或套餐名称）
### 5. 获取订单详情
- **路径**: `GET /v2/store/vendor/orders/:id`
- **参数**:
- `id` (integer, 路径参数) - 订单ID
### 6. 取消订单
- **路径**: `POST /v2/store/vendor/orders/:id/cancel`
- **参数**:
- `id` (integer, 路径参数) - 订单ID
## ✅ 完成状态
- [x] 接口定义完成
- [x] 接口上传到Apifox
- [ ] 目录创建（需手动完成）
- [ ] 接口移动到目录（需手动完成或运行脚本）

40
application/store/供应链采购接口上传成功.md Normal file
View File

@@ -0,0 +1,40 @@
# 供应链采购接口上传成功
## 目录信息
- 目录名称: 供应链采购管理
- 目录ID: 待确认
- 父目录ID: 78015216
## 接口列表
### 获取供应商套餐列表
- **接口ID**: 416279106
- **路径**: /v2/store/vendor/list
### 获取供应商套餐详情
- **接口ID**: 416279107
- **路径**: /v2/store/vendor/detail
### 创建供应商订单
- **接口ID**: 416279108
- **路径**: /v2/store/vendor/order
### 获取订单列表
- **接口ID**: 416279109
- **路径**: /v2/store/vendor/orders
### 获取订单详情
- **接口ID**: 416279112
- **路径**: /v2/store/vendor/orders/:id
### 取消订单
- **接口ID**: 416279113
- **路径**: /v2/store/vendor/orders/:id/cancel

40
application/store/供应链采购接口上传成功_目录78176561.md Normal file
View File

@@ -0,0 +1,40 @@
# 供应链采购接口上传成功
## 目录信息
- 目录名称: 供应链采购管理
- 目录ID: 78176561
- 项目ID: 6037107
## 接口列表
### 获取供应商套餐列表
- **接口ID**: 416281903
- **路径**: /v2/store/vendor/list
### 获取供应商套餐详情
- **接口ID**: 416281905
- **路径**: /v2/store/vendor/detail
### 创建供应商订单
- **接口ID**: 416281906
- **路径**: /v2/store/vendor/order
### 获取订单列表
- **接口ID**: 416281908
- **路径**: /v2/store/vendor/orders
### 获取订单详情
- **接口ID**: 416281911
- **路径**: /v2/store/vendor/orders/:id
### 取消订单
- **接口ID**: 416281912
- **路径**: /v2/store/vendor/orders/:id/cancel

104
application/store/供应链采购接口对接分析.md Normal file
View File

@@ -0,0 +1,104 @@
# 供应链采购接口对接分析
## 问题分析
### 1. 接口路径不匹配
**新版前端期望的路径**（`supply-chain-service.ts`）：
- `GET /api/store/supply-packages` - 获取套餐列表
- `GET /api/store/supply-packages/:id` - 获取套餐详情
- `POST /api/store/supply-purchase` - 购买套餐
- `GET /api/store/supply-orders` - 获取订单列表
**后端实际提供的路径**：
- `GET /v2/store/vendor/list` - 获取套餐列表
- `GET /v2/store/vendor/detail` - 获取套餐详情
- `POST /v2/store/vendor/order` - 创建订单
- `GET /v2/store/vendor/orders` - 获取订单列表
- `GET /v2/store/vendor/orders/:id` - 获取订单详情
- `POST /v2/store/vendor/orders/:id/cancel` - 取消订单
### 2. 参数名称不匹配
**前端传递的参数**：
- `page`, `pageSize` (订单列表)
**后端接收的参数**：
- `page`, `limit` (已兼容 `pageSize`)
### 3. 返回数据格式不匹配
**前端期望的格式**：
```json
{
"code": 0,
"message": "success",
"data": [...]
}
```
**后端返回的格式**：
```json
{
"code": 200,
"msg": "获取成功",
"data": {...}
}
```
### 4. 数据字段不匹配
**前端期望的字段**（`SupplyPackage` 接口）：
- `id`, `name`, `type`, `description`, `content`, `originalPrice`, `price`, `discount`, `savings`, `features`, `isHot`, `isRecommended`, `stock`, `soldCount`, `image`
**后端返回的字段**：
- `id`, `name`, `originalPrice`, `price`, `discount`, `advancePayment`, `tags`, `description`, `cover`, `status`, `createTime`, `updateTime`, `userId`, `companyId`
## 解决方案
### 方案一：修改 Next.js 路由代理（推荐）
在 `next.config.mjs` 中添加供应链采购的路由代理：
```javascript
{
source: '/api/store/supply-packages',
destination: 'https://yi.54word.com/v2/store/vendor/list',
},
{
source: '/api/store/supply-packages/:id',
destination: 'https://yi.54word.com/v2/store/vendor/detail?id=:id',
},
{
source: '/api/store/supply-purchase',
destination: 'https://yi.54word.com/v2/store/vendor/order',
},
{
source: '/api/store/supply-orders',
destination: 'https://yi.54word.com/v2/store/vendor/orders',
},
```
### 方案二：修改后端接口路径（不推荐）
修改后端路由以匹配前端期望的路径，但这会破坏现有的路由结构。
### 方案三：修改前端接口调用（推荐）
修改 `supply-chain-service.ts` 中的接口路径，直接调用后端V2接口。
## 需要调整的内容
1. ✅ **参数兼容**：后端已兼容 `pageSize` 参数
2. ⚠️ **返回格式**：需要统一 `code` 和 `msg`/`message` 字段
3. ⚠️ **数据字段映射**：需要将后端字段映射到前端期望的字段
4. ⚠️ **路由代理**：需要在 Next.js 配置中添加路由代理
## 建议
**最佳方案**：使用方案一（Next.js 路由代理）+ 数据适配层
1. 在 Next.js 中添加路由代理
2. 在后端添加数据适配层，将后端数据格式转换为前端期望的格式
3. 或者在前端添加数据适配层，将后端数据转换为前端期望的格式

127
application/store/供应链采购接口对接完成说明.md Normal file
View File

@@ -0,0 +1,127 @@
# 供应链采购接口对接完成说明
## ✅ 已完成的对接工作
### 1. 后端接口实现
- ✅ `VendorController` - 供应商套餐管理
- `GET /v2/store/vendor/list` - 获取套餐列表
- `GET /v2/store/vendor/detail` - 获取套餐详情
- `POST /v2/store/vendor/order` - 创建订单
- ✅ `VendorOrderController` - 订单管理
- `GET /v2/store/vendor/orders` - 获取订单列表
- `GET /v2/store/vendor/orders/:id` - 获取订单详情
- `POST /v2/store/vendor/orders/:id/cancel` - 取消订单
### 2. 参数兼容性
- ✅ 已兼容 `pageSize` 参数（订单列表同时支持 `limit` 和 `pageSize`）
- ✅ 已兼容 `page` 参数
### 3. Next.js 路由代理配置
已在 `next.config.mjs` 中添加以下路由代理：
- `/api/store/supply-packages` → `/v2/store/vendor/list`
- `/api/store/supply-packages/:id` → `/v2/store/vendor/detail`
- `/api/store/supply-purchase` → `/v2/store/vendor/order`
- `/api/store/supply-orders` → `/v2/store/vendor/orders`
## ⚠️ 需要注意的问题
### 1. 返回数据格式差异
**后端返回格式**：
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"list": [...],
"total": 100,
"page": 1,
"limit": 10
}
}
```
**前端期望格式**（部分接口）：
```json
{
"code": 0,
"message": "success",
"data": [...]
}
```
**解决方案**：
- 前端已有 Mock 数据兜底，如果接口调用失败会自动使用 Mock 数据
- 建议在前端添加数据适配层，将后端返回格式转换为前端期望格式
- 或者统一后端返回格式（将 `code: 200` 改为 `code: 0`，`msg` 改为 `message`）
### 2. 数据字段映射
**前端期望的字段**（`SupplyPackage`）：
- `id`, `name`, `type`, `description`, `content`, `originalPrice`, `price`, `discount`, `savings`, `features`, `isHot`, `isRecommended`, `stock`, `soldCount`, `image`
**后端返回的字段**：
- `id`, `name`, `originalPrice`, `price`, `discount`, `advancePayment`, `tags`, `description`, `cover`, `status`, `createTime`, `updateTime`, `userId`, `companyId`
**字段映射建议**：
- `cover` → `image`
- `tags` → `features`（需要转换）
- `discount` → 需要计算 `savings`（`originalPrice - price`）
- `status` → `isHot` / `isRecommended`（需要业务逻辑判断）
- 缺少 `type`, `content`, `stock`, `soldCount` 字段（需要数据库支持或默认值）
### 3. 订单状态映射
**后端订单状态**：
- `0` = 待支付 (STATUS_UNPAID)
- `1` = 已支付 (STATUS_PAID)
- `2` = 已完成 (STATUS_COMPLETED)
- `3` = 已取消 (STATUS_CANCELED)
**前端期望状态**：
- `"pending"` = 待支付
- `"completed"` = 已完成（已支付就是已完成）
- `"cancelled"` = 已取消
**映射关系**：
- `0` → `"pending"`
- `1` → `"completed"`
- `2` → `"completed"`
- `3` → `"cancelled"`
## 📋 测试清单
### 接口测试
- [ ] 测试获取套餐列表接口
- [ ] 测试获取套餐详情接口
- [ ] 测试创建订单接口
- [ ] 测试获取订单列表接口
- [ ] 测试获取订单详情接口
- [ ] 测试取消订单接口
### 数据格式测试
- [ ] 验证返回数据格式是否符合前端期望
- [ ] 验证字段映射是否正确
- [ ] 验证分页参数是否正确传递
### 路由代理测试
- [ ] 验证 Next.js 路由代理是否正确工作
- [ ] 验证动态参数是否正确传递
- [ ] 验证 CORS 问题是否解决
## 🔧 建议的后续优化
1. **统一返回格式**：将后端返回格式统一为前端期望的格式
2. **数据适配层**：在前端或后端添加数据适配层，处理字段映射
3. **补充缺失字段**：在数据库中添加 `type`, `content`, `stock`, `soldCount` 等字段
4. **错误处理**：完善错误处理和提示信息
5. **接口文档**：更新 Apifox 接口文档，确保接口说明完整
## 📝 总结
**当前状态**：✅ 基础对接已完成，接口路径已配置，参数已兼容
**待完善**：⚠️ 数据格式和字段映射需要进一步调整，建议在前端添加数据适配层
**建议**：先进行接口测试，根据实际返回数据调整前端的数据处理逻辑。

102
application/store/客户管理功能实施总结.md Normal file
View File

@@ -0,0 +1,102 @@
# 客户管理功能实施总结
## ✅ 完成状态
- [x] CustomerController 创建完成
- [x] 客户列表接口实现完成
- [x] 客户详情接口实现完成
- [x] 客户信息更新接口实现完成
- [x] 路由配置完成
- [x] 接口上传到Apifox
## 📋 接口列表
### 1. 获取客户列表
- **路径**: `GET /v2/store/customers`
- **接口ID**: 416332157
- **功能**:
- 支持分页（page, limit, pageSize）
- 支持关键词搜索（昵称、微信号、手机号）
- 支持状态筛选（潜在、活跃、沉默、流失）
- 支持价值筛选（高、中、低）
- 支持生命周期筛选
- 返回客户基本信息、状态、价值、标签、最后联系时间等
### 2. 获取客户详情
- **路径**: `GET /v2/store/customers/:id`
- **接口ID**: 416332159
- **功能**: 返回客户完整信息，包括：
- 好友概览（头像、昵称、微信号、转化状态、估值）
- 互动统计（聊天消息数、朋友圈互动数、红包转账总额、活跃度评分）
- 微信资料（昵称、备注名、微信号、地区、微信手机号）
- 基础信息（姓名、性别、年龄、手机号、邮箱、身份证号、住址）
- 客户标签（流量池标签、普通标签）
- 价值评估详情（RFM模型、CLV模型、社交裂变模型）
- 用户旅程（访问朋友圈、地理位置、点赞记录、成交记录等）
- 消费偏好（核心兴趣画像、偏好品类、最近消费）
- AI智能洞察（客户画像总结、预测与建议）
### 3. 更新客户信息
- **路径**: `PUT /v2/store/customers/:id`
- **接口ID**: 416332160
- **功能**: 支持更新：
- 微信资料（备注名）
- 基础信息（姓名、性别、年龄、手机号、邮箱、身份证号、住址）
- 客户标签
## 🗄️ 数据来源
### 主要数据表
- `ck_traffic_pool_company` - 公司流量详情表（客户主表）
- `ck_traffic_pool` - 流量池总表（客户基础信息）
- `s2_wechat_friend` - 微信好友表（关联微信信息）
- `ck_traffic_pool_tag` - 流量池标签表（客户标签）
- `ck_traffic_pool_source` - 流量来源表（来源渠道）
- `ck_traffic_pool_behavior` - 行为记录表（互动统计、用户旅程）
### 查询逻辑
1. **客户列表**: 从 `ck_traffic_pool_company` 表查询，关联 `ck_traffic_pool` 和 `s2_wechat_friend` 表
2. **客户详情**: 查询客户完整信息，包括标签、来源、互动统计、行为记录等
3. **数据归属**: 通过 `ownerAccountId` 和 `companyId` 确保数据归属正确
## 🔧 技术实现
### 1. 客户列表查询
- 使用 `BaseController` 自动获取设备信息和用户信息
- 通过 `ownerAccountId` 筛选归属当前微信账号的客户
- 支持多条件搜索和筛选
- 返回格式化的客户列表数据
### 2. 客户详情查询
- 关联多个表获取完整信息
- 计算互动统计（从行为记录表）
- 获取用户旅程（最近行为记录）
- 返回结构化的客户详情数据
### 3. 客户信息更新
- 支持按类型更新（微信资料、基础信息、标签）
- 标签更新：删除旧标签，添加新标签
- 数据验证和格式化
## 📝 注意事项
1. **数据归属**: 所有查询都通过 `ownerAccountId` 和 `companyId` 确保数据安全
2. **标签管理**: 系统标签（`isSystem=1`）不会被删除，只删除普通标签
3. **估值计算**: 当前使用模拟数据，后续需要实现真实的RFM、CLV等模型计算
4. **AI预测**: 当前使用模拟数据，后续需要实现真实的AI分析逻辑
## 🔗 访问链接
- **项目首页**: https://app.apifox.com/project/6037107
- **当前目录**: https://app.apifox.com/project/6037107/apis/folder/78015216
## 📌 后续优化建议
1. **估值计算**: 实现真实的RFM模型、CLV模型、社交裂变模型计算
2. **AI预测**: 集成真实的AI分析服务，提供客户画像和预测
3. **消费偏好分析**: 从订单和行为记录中分析真实的消费偏好
4. **性能优化**: 对于大量数据的查询，考虑添加缓存和索引优化
5. **批量操作**: 支持批量标记、批量分组等操作

24
application/store/客户管理接口上传成功.md Normal file
View File

@@ -0,0 +1,24 @@
# 客户管理接口上传成功
## 目录信息
- 目录ID: 78015216
- 项目ID: 6037107
## 接口列表
### 获取客户列表
- **接口ID**: 416332157
- **路径**: /v2/store/customers
### 获取客户详情
- **接口ID**: 416332159
- **路径**: /v2/store/customers/:id
### 更新客户信息
- **接口ID**: 416332160
- **路径**: /v2/store/customers/:id

417
application/store/流量采购功能实施总结.md Normal file
View File

@@ -0,0 +1,417 @@
# 流量采购功能实施总结
## 📋 功能概述
流量采购功能允许门店端（新版）查看和购买操盘手在 `cunkebao` 模块创建的流量池包。
## 🗄️ 数据库表结构
### 使用的旧版表（无需新建）
1. **ck_traffic_source_package_v1** - 流量池包表
- 操盘手创建的流量池包
- 字段：id, userId, name, description, pic, companyId, matchingRules, isSys, isDel, createTime, updateTime, deleteTime
2. **ck_traffic_source_package_item_v1** - 流量池包项表
- 流量池包中的具体流量项
- 字段：id, packageId, companyId, identifier, isDel, createTime, deleteTime
- 唯一索引：`uk_packageId_companyId_identifier_isDel`
### 新建表
3. **ck_traffic_purchase_record** - 流量采购购买记录表
- 记录每次购买操作的详细信息
- 字段：id, orderNo, companyId, userId, packageId, packageName, totalCount, successCount, skipCount, status, remark, createTime, updateTime, isDel, deleteTime
- 索引：订单号唯一索引，公司ID、用户ID、流量池包ID、创建时间等索引
### 关联表
- **ck_traffic_pool** - 流量池总表（新版）
- **s2_wechat_account** - 微信账号表
## 🔧 实现的功能
### 1. 获取可购买的流量池包列表
- **接口**: `GET /v2/store/traffic/packages`
- **功能**: 展示操盘手创建的所有可购买的流量池包
- **参数**:
- `page`: 页码（默认1）
- `limit`: 每页数量（默认10）
- `keyword`: 关键字搜索（可选）
- **返回**: 流量池包列表，包含名称、描述、图片、数量等信息
### 2. 获取流量池包详情
- **接口**: `GET /v2/store/traffic/packages/:id`
- **功能**: 查看指定流量池包的详细信息
- **返回**: 流量池包详情，包含基本信息、流量数量、示例流量等
### 3. 购买流量
- **接口**: `POST /v2/store/traffic/packages/:id/purchase`
- **功能**: 将流量池包中的流量添加到购买者的公司
- **逻辑**:
1. 检查流量池包是否存在
2. 获取流量池包中的所有流量项
3. 为购买者的公司创建新的流量池包项（companyId为购买者的公司ID）
4. 避免重复添加（检查是否已存在）
- **返回**: 购买结果，包含成功数量、跳过数量等
### 4. 获取已购买的流量列表
- **接口**: `GET /v2/store/traffic/purchased`
- **功能**: 查看已购买的流量列表
- **参数**:
- `page`: 页码
- `limit`: 每页数量
- `packageId`: 流量池包ID（可选，筛选特定包）
- `keyword`: 关键字搜索（可选）
- **返回**: 已购买的流量列表，包含流量信息和所属流量池包信息
### 5. 获取购买记录列表
- **接口**: `GET /v2/store/traffic/purchase-records`
- **功能**: 查看购买历史记录
- **参数**:
- `page`: 页码（默认1）
- `limit`: 每页数量（默认10）
- `packageId`: 流量池包ID（可选）
- `status`: 状态筛选（0=全部，1=成功，2=部分成功，3=失败）
- `startTime`: 开始时间戳（可选）
- `endTime`: 结束时间戳（可选）
- **返回**: 购买记录列表，包含订单号、购买数量、状态等信息
### 6. 获取购买记录详情
- **接口**: `GET /v2/store/traffic/purchase-records/:id`
- **功能**: 查看指定购买记录的详细信息
- **返回**: 购买记录详情
### 7. 获取统计信息
- **接口**: `GET /v2/store/traffic/statistics`
- **功能**: 获取流量采购的统计数据
- **返回**:
- 总览数据（总记录数、总购买数、总拥有数）
- 今日/本周/本月数据
- 按状态统计
- 热门流量池包（购买次数最多的前10个）
- 最近7天购买趋势
## 📁 文件结构
```
application/store/
├── controller/
│ └── TrafficPurchaseController.php # 流量采购控制器
├── config/
│ └── route.php # 路由配置（已更新）
└── database_traffic_purchase_record.sql # 购买记录表SQL（需执行）
```
## 🛣️ 路由配置
```php
// 流量采购模块
Route::group('traffic', function () {
Route::get('packages', 'TrafficPurchaseController@getPackages'); // 获取可购买的流量池包列表
Route::get('packages/:id', 'TrafficPurchaseController@getPackageDetail'); // 获取流量池包详情
Route::post('packages/:id/purchase', 'TrafficPurchaseController@purchase'); // 购买流量
Route::get('purchased', 'TrafficPurchaseController@getPurchasedList'); // 获取已购买的流量列表
Route::get('purchase-records', 'TrafficPurchaseController@getPurchaseRecords'); // 获取购买记录列表
Route::get('purchase-records/:id', 'TrafficPurchaseController@getPurchaseRecordDetail'); // 获取购买记录详情
Route::get('statistics', 'TrafficPurchaseController@getStatistics'); // 获取统计信息
});
```
## 🔐 认证说明
所有接口都需要JWT认证（通过 `auth` 中间件），用户信息通过 `$this->request->userInfo` 获取：
- `userInfo['companyId']` - 公司ID
- `userInfo['id']` - 用户ID
## 💡 业务逻辑说明
### 购买流程
1. **查看流量池包列表** - 门店端浏览可购买的流量池包
2. **查看详情** - 点击查看流量池包的详细信息
3. **购买流量** - 点击购买，系统将流量添加到购买者的公司，并创建购买记录
4. **查看已购买** - 在"已购买"列表中查看已购买的流量
5. **查看购买记录** - 在"购买记录"中查看历史购买记录
6. **查看统计** - 在"统计"中查看购买数据和分析
### 数据隔离
- 流量池包（`traffic_source_package_v1`）的 `companyId` 为 0 表示系统/公共流量池，或操盘手公司的ID
- 购买后，会在 `traffic_source_package_item_v1` 表中创建新记录，`companyId` 为购买者的公司ID
- 这样实现了数据隔离：每个公司只能看到自己购买的流量
### 重复购买处理
- 系统会检查是否已存在相同的流量项（基于 `packageId + companyId + identifier`）
- 如果已存在，则跳过，避免重复添加
- 返回成功数量和跳过数量
- 购买记录会记录状态：1=成功，2=部分成功，3=失败
### 购买记录功能
- 每次购买都会生成唯一的订单号（格式：TP + 日期时间 + 随机数 + 用户ID）
- 记录购买详情：总数量、成功数量、跳过数量、状态等
- 支持按流量池包、状态、时间范围筛选
- 提供购买记录详情查询
### 统计功能
- **总览统计**：总购买记录数、总购买流量数、总拥有流量数
- **时间维度**：今日、本周、本月的数据统计
- **状态统计**：按购买状态分类统计
- **热门流量池包**：购买次数最多的前10个流量池包
- **趋势分析**：最近7天的购买趋势数据
## ⚠️ 注意事项
1. **数据库表**:
- 使用旧版表 `traffic_source_package_v1` 和 `traffic_source_package_item_v1`
- **需要创建新表** `ck_traffic_purchase_record`（执行 `database_traffic_purchase_record.sql`）
2. **认证**: 需要确保JWT中间件正确设置 `userInfo` 信息
3. **权限**: 所有接口都需要登录认证
4. **数据一致性**: 购买操作使用事务，确保数据一致性
5. **订单号生成**: 订单号格式为 `TP + YYYYMMDDHHMMSS + 4位随机数 + 用户ID`，确保唯一性
## 🚀 后续优化建议
1. ✅ **购买记录表**: 已实现，记录购买历史、购买时间、购买数量等
2. ✅ **统计功能**: 已实现，包含总览、时间维度、状态、热门包、趋势等统计
3. **价格系统**: 如果需要，可以添加价格字段和支付功能
4. **购买限制**: 可以添加购买限制（如每个公司最多购买多少流量）
5. **流量使用统计**: 可以添加流量使用情况统计（如已使用、剩余等）
6. **导出功能**: 可以添加购买记录导出功能
## 📝 API文档
### 1. 获取流量池包列表
**请求**:
```
GET /v2/store/traffic/packages?page=1&limit=10&keyword=测试
```
**响应**:
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"list": [
{
"id": 1,
"name": "测试流量池",
"description": "这是一个测试流量池",
"pic": "https://example.com/pic.jpg",
"type": 0,
"createTime": "2026-02-05 10:00:00",
"num": 100
}
],
"total": 1,
"page": 1,
"limit": 10
}
}
```
### 2. 获取流量池包详情
**请求**:
```
GET /v2/store/traffic/packages/1
```
**响应**:
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"id": 1,
"name": "测试流量池",
"description": "这是一个测试流量池",
"pic": "https://example.com/pic.jpg",
"type": 0,
"createTime": "2026-02-05 10:00:00",
"num": 100,
"samples": [
{
"id": 1,
"identifier": "wxid_test",
"nickname": "测试用户",
"avatar": "https://example.com/avatar.jpg",
"mobile": "13800138000",
"phone": "13800138000"
}
]
}
}
```
### 3. 购买流量
**请求**:
```
POST /v2/store/traffic/packages/1/purchase
```
**响应**:
```json
{
"code": 200,
"msg": "购买成功",
"data": {
"recordId": 1,
"orderNo": "TP202602051430251234567",
"packageId": 1,
"packageName": "测试流量池",
"successCount": 95,
"skipCount": 5,
"totalCount": 100,
"status": 2
}
}
```
### 5. 获取购买记录列表
**请求**:
```
GET /v2/store/traffic/purchase-records?page=1&limit=10&status=1&packageId=1
```
**响应**:
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"list": [
{
"id": 1,
"orderNo": "TP202602051430251234567",
"packageId": 1,
"packageName": "测试流量池",
"totalCount": 100,
"successCount": 95,
"skipCount": 5,
"status": 2,
"statusText": "部分成功",
"createTime": "2026-02-05 14:30:25"
}
],
"total": 10,
"page": 1,
"limit": 10
}
}
```
### 6. 获取统计信息
**请求**:
```
GET /v2/store/traffic/statistics
```
**响应**:
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"overview": {
"totalRecords": 50,
"totalPurchased": 5000,
"totalOwned": 4800
},
"today": {
"records": 5,
"purchased": 500
},
"week": {
"records": 20,
"purchased": 2000
},
"month": {
"records": 45,
"purchased": 4500
},
"status": {
"success": 40,
"partial": 8,
"failed": 2
},
"topPackages": [
{
"packageId": 1,
"packageName": "测试流量池",
"purchaseCount": 10,
"totalPurchased": 1000
}
],
"trend": [
{
"date": "2026-01-29",
"records": 2,
"purchased": 200
},
{
"date": "2026-01-30",
"records": 3,
"purchased": 300
}
]
}
}
```
### 4. 获取已购买的流量列表
**请求**:
```
GET /v2/store/traffic/purchased?page=1&limit=10&packageId=1&keyword=测试
```
**响应**:
```json
{
"code": 200,
"msg": "获取成功",
"data": {
"list": [
{
"id": 1,
"identifier": "wxid_test",
"wechatId": "wxid_test",
"nickname": "测试用户",
"avatar": "https://example.com/avatar.jpg",
"phone": "13800138000",
"packageName": "测试流量池",
"packageId": 1
}
],
"total": 100,
"page": 1,
"limit": 10
}
}
```
## ✅ 完成状态
- [x] 分析旧版数据库表结构
- [x] 创建流量采购控制器
- [x] 实现流量池包列表接口
- [x] 实现流量池包详情接口
- [x] 实现购买流量接口（含购买记录）
- [x] 实现已购买流量列表接口
- [x] 实现购买记录列表接口
- [x] 实现购买记录详情接口
- [x] 实现统计信息接口
- [x] 创建购买记录表SQL
- [x] 添加路由配置
- [ ] 执行数据库表创建SQL（需手动执行）
- [ ] 上传接口到Apifox（待完成）

102
application/store/流量采购接口上传成功.md Normal file
View File

@@ -0,0 +1,102 @@
# 流量采购接口上传成功 ✅
## 📋 上传信息
- **项目ID**: 6037107
- **目录ID**: 78121195（流量采购管理）
- **上传时间**: 2026-02-05
- **状态**: ✅ 全部成功
---
## ✅ 已上传接口列表
| 接口名称 | 方法 | 路径 | API ID | 状态 |
|---------|------|------|--------|------|
| 获取流量套餐列表 | GET | `/v2/store/flow-packages` | 415993783 | ✅ |
| 获取流量套餐详情 | GET | `/v2/store/flow-packages/:id` | 415993789 | ✅ |
| 获取剩余流量 | GET | `/v2/store/flow-packages/remaining-flow` | 415993808 | ✅ |
| 创建流量采购订单 | POST | `/v2/store/flow-packages/order` | 415993815 | ✅ |
| 获取订单列表 | GET | `/v2/store/flow-packages/orders` | 415993816 | ✅ |
---
## 📊 接口说明
### 1. 获取流量套餐列表
- **路径**: `GET /v2/store/flow-packages`
- **功能**: 获取所有可购买的流量套餐列表
- **说明**: 只返回启用状态的套餐，按排序字段排序
### 2. 获取流量套餐详情
- **路径**: `GET /v2/store/flow-packages/:id`
- **功能**: 获取指定流量套餐的详细信息
- **参数**: `id` - 套餐ID
### 3. 获取剩余流量
- **路径**: `GET /v2/store/flow-packages/remaining-flow`
- **功能**: 获取当前用户的有效流量套餐剩余流量信息
- **说明**: 自动从JWT Token获取用户ID
### 4. 创建流量采购订单
- **路径**: `POST /v2/store/flow-packages/order`
- **功能**: 创建流量套餐购买订单
- **请求参数**:
- `packageId` (必填) - 套餐ID
- `payType` (可选) - 支付方式，默认wechat
- `remark` (可选) - 备注
- **说明**:
- 金额为0的套餐会自动完成购买
- 需要支付的订单返回订单信息供前端跳转支付
### 5. 获取订单列表
- **路径**: `GET /v2/store/flow-packages/orders`
- **功能**: 获取当前用户的流量套餐订单列表
- **查询参数**:
- `page` (可选) - 页码，默认1
- `limit` (可选) - 每页数量，默认10
- `status` (可选) - 订单状态筛选
---
## 🔗 访问链接
**Apifox 项目地址**: https://app.apifox.com/project/6037107
**流量采购目录**: https://app.apifox.com/project/6037107/apis/folder/78121195
---
## 📝 相关文件
- **控制器**: `application/store/controller/FlowPackageController.php`
- **模型**:
- `application/store/model/FlowPackageModel.php`
- `application/store/model/FlowPackageOrderModel.php`
- `application/store/model/UserFlowPackageModel.php`
- **路由**: `application/store/config/route.php`
- **上传脚本**: `upload_flow_packages_simple.py`
---
## ✨ 功能说明
**流量采购功能**是门店端购买流量套餐的功能：
1. **流量套餐**：由操盘手创建，包含价格、月流量、时长等属性
2. **门店端购买**：查看套餐 → 创建订单 → 支付 → 获得流量配额
3. **流量使用**：查看剩余流量、已使用流量、订单记录
**数据库表**：
- `ck_flow_package` - 流量套餐表（操盘手创建）
- `ck_flow_package_order` - 流量套餐订单表
- `ck_user_flow_package` - 用户流量套餐表（购买后的记录）
---
## ✅ 完成状态
- ✅ 所有5个接口已成功上传
- ✅ 接口已正确放置在"流量采购管理"目录（ID: 78121195）
- ✅ 接口路径和参数已正确配置

143
application/store/流量采购目录创建指南.md Normal file
View File

@@ -0,0 +1,143 @@
# 流量采购管理目录创建指南 📁
## 📋 当前状态
- ✅ **流量采购接口已全部创建**（7个接口）
- ❌ **目录未创建**（Apifox API限制）
- ⏳ **需要手动操作**（约2分钟）
---
## 🎯 快速操作步骤（2分钟）
### 步骤1：打开Apifox项目
访问：https://app.apifox.com/project/6037107
### 步骤2：创建"流量采购管理"目录
1. 在左侧目录树中找到 **"门店端-新版"** 目录
2. 右键点击 **"门店端-新版"** 目录
3. 选择 **"新建文件夹"** 或 **"新建目录"**
4. 输入名称：**流量采购管理**
5. 按回车确认
### 步骤3：移动流量采购接口
找到以下7个接口（在"门店端-新版"根目录下）：
| 接口名称 | API ID |
|---------|--------|
| 获取可购买的流量池包列表 | 415976880 |
| 获取流量池包详情 | 415976882 |
| 购买流量 | 415977273 |
| 获取已购买的流量列表 | 415976885 |
| 获取购买记录列表 | 415976886 |
| 获取购买记录详情 | 415976889 |
| 获取流量采购统计 | 415976892 |
**移动方式（任选一种）：**
#### 方式一：拖拽（推荐）
1. 选中这7个接口（按住Ctrl键多选）
2. 直接拖拽到 **"流量采购管理"** 目录
3. 松开鼠标完成移动
#### 方式二：右键移动
1. 选中接口（可多选）
2. 右键 → 选择 **"移动到"** 或 **"Move to"**
3. 选择 **"流量采购管理"** 目录
4. 确认移动
---
## 📊 最终目录结构
```
门店端-新版 (78015216)
├── 登录相关 (78092117)
│ ├── POST /v2/store/auth/login
│ ├── GET /v2/store/auth/login
│ ├── POST /v2/store/auth/send-code
│ └── POST /v2/store/auth/mobile-login
├── Agent管理 (78106557)
│ ├── GET /v2/store/agent/modules
│ └── PUT /v2/store/agent/modules/{moduleCode}/status
└── 流量采购管理 (待创建) ⬅️ 新建目录
├── GET /v2/store/traffic/packages (415976880)
├── GET /v2/store/traffic/packages/{id} (415976882)
├── POST /v2/store/traffic/packages/{id}/purchase (415977273)
├── GET /v2/store/traffic/purchased (415976885)
├── GET /v2/store/traffic/purchase-records (415976886)
├── GET /v2/store/traffic/purchase-records/{id} (415976889)
└── GET /v2/store/traffic/statistics (415976892)
```
---
## 🔍 如何快速找到接口
### 方法1：按API ID搜索
1. 在Apifox中按 `Ctrl+F` 或点击搜索框
2. 输入API ID（如：415976880）
3. 找到对应的接口
### 方法2：按路径搜索
1. 在搜索框中输入：`/v2/store/traffic`
2. 会显示所有流量采购相关接口
### 方法3：在目录中查找
1. 展开 **"门店端-新版"** 目录
2. 接口会按创建时间排序
3. 找到最近创建的7个接口（都是流量采购相关的）
---
## ✅ 验证完成
移动完成后，检查：
- ✅ "流量采购管理"目录已创建
- ✅ 目录下有7个接口
- ✅ 接口路径都包含 `/v2/store/traffic`
---
## 🛠️ 如果遇到问题
### 问题1：找不到接口
- **解决**：使用搜索功能，输入API ID或路径
### 问题2：无法拖拽
- **解决**：使用右键菜单的"移动到"功能
### 问题3：目录创建失败
- **解决**：确保有编辑权限，刷新页面重试
### 问题4：接口移动后消失
- **解决**：检查是否移动到了错误的目录，使用撤销功能恢复
---
## 📝 相关文件
- **接口上传脚本**: `update_and_upload_apis.py`
- **上传总结**: `API_UPLOAD_SUMMARY.md`
- **流量采购接口文档**: `流量采购功能实施总结.md`
---
## 🔗 快速链接
- **Apifox项目**: https://app.apifox.com/project/6037107
- **门店端-新版目录**: https://app.apifox.com/project/6037107/apis/folder/78015216
---
## ⏱️ 预计时间
- 创建目录：30秒
- 移动接口：1分钟
- **总计：约2分钟**
完成！🎉

129
application/store/用户管理和算力中心接口上传完成.md Normal file
View File

@@ -0,0 +1,129 @@
# 用户管理和算力中心接口上传完成
## ✅ 上传结果
**上传时间**: 2025-02-05
**项目ID**: 6037107
**当前目录**: 门店端-新版 (ID: 78015216)
### 接口列表（7个接口全部上传成功）
#### 用户管理接口（2个）
| 序号 | 接口名称 | 方法 | 路径 | 接口ID |
|------|---------|------|------|--------|
| 1 | 获取用户资料 | GET | `/v2/store/user/profile` | 416301911 |
| 2 | 更新用户资料 | PUT | `/v2/store/user/profile` | 416301915 |
#### 算力中心接口（5个）
| 序号 | 接口名称 | 方法 | 路径 | 接口ID |
|------|---------|------|------|--------|
| 1 | 获取算力套餐列表 | GET | `/v2/store/tokens/packages` | 416301919 |
| 2 | 购买算力 | POST | `/v2/store/tokens/pay` | 416301920 |
| 3 | 查询订单状态 | GET | `/v2/store/tokens/order` | 416301922 |
| 4 | 获取订单列表 | GET | `/v2/store/tokens/orders` | 416301923 |
| 5 | 获取算力统计 | GET | `/v2/store/tokens/statistics` | 416301924 |
## 📋 接口功能说明
### 用户管理
#### 1. 获取用户资料
- **功能**: 获取当前用户的详细资料
- **返回数据**:
- 基本信息：id, account, username, phone, avatar, companyId, typeId, status, createTime
- 算力信息：remainingTokens（剩余算力）、totalRecharged（总算力）、todayUsed（今日使用）、monthUsed（本月使用）
#### 2. 更新用户资料
- **功能**: 更新用户资料，支持修改头像、昵称、密码
- **请求参数**:
- `username` (string, 可选) - 昵称
- `avatar` (string, 可选) - 头像URL
- `oldPassword` (string, 可选) - 旧密码（修改密码时必填）
- `newPassword` (string, 可选) - 新密码（修改密码时必填，长度不能少于6位）
### 算力中心
#### 1. 获取算力套餐列表
- **功能**: 获取所有可购买的算力套餐列表
- **参数**: page, limit
- **返回**: 套餐列表，包含价格、算力数量、折扣等信息
#### 2. 购买算力
- **功能**: 购买算力套餐或自定义购买算力
- **请求参数**:
- `id` (integer, 可选) - 套餐ID（购买套餐时必填）
- `price` (number, 可选) - 自定义购买金额（元，自定义购买时必填）
- `payType` (string, 可选) - 支付方式：wechat=微信，alipay=支付宝，qrCode=二维码
#### 3. 查询订单状态
- **功能**: 查询算力购买订单的支付状态
- **参数**: orderNo（订单号）
#### 4. 获取订单列表
- **功能**: 获取当前用户的算力购买订单列表
- **参数**: page, limit, status, keyword, orderType, payType, startTime, endTime
#### 5. 获取算力统计
- **功能**: 获取当前用户的算力统计信息
- **返回数据**:
- totalTokens（总算力/累计充值）
- todayUsed（今日使用）
- monthUsed（本月使用）
- remainingTokens（剩余算力）
- totalConsumed（累计消费）
- estimatedDays（预计可用天数）
## 📁 目录管理
### 当前状态
- ✅ 接口已上传到父目录：**门店端-新版** (ID: 78015216)
- ⚠️ 需要创建子目录并移动接口
### 后续操作
**方案一：手动创建目录并移动接口（推荐）**
1. 在 Apifox Web UI 中：
- 进入项目：https://app.apifox.com/project/6037107
- 在"门店端-新版"目录下创建以下目录：
- **用户管理**
- **算力中心**
- 获取新目录的ID（从URL中获取）
2. 使用移动脚本：
```bash
# 修改脚本中的目录ID，然后运行
python move_user_tokens_to_folders.py
```
**方案二：直接在 Apifox Web UI 中移动**
1. 创建"用户管理"和"算力中心"目录
2. 手动将接口移动到对应目录：
- **用户管理目录**：
- 416301911 - 获取用户资料
- 416301915 - 更新用户资料
- **算力中心目录**：
- 416301919 - 获取算力套餐列表
- 416301920 - 购买算力
- 416301922 - 查询订单状态
- 416301923 - 获取订单列表
- 416301924 - 获取算力统计
## 🔗 访问链接
- **项目首页**: https://app.apifox.com/project/6037107
- **当前目录**: https://app.apifox.com/project/6037107/apis/folder/78015216
## ✅ 完成状态
- [x] UserController 创建完成
- [x] TokensController 创建完成
- [x] 相关Model创建完成
- [x] 路由配置完成
- [x] 接口上传到Apifox
- [ ] 目录创建（需手动完成）
- [ ] 接口移动到目录（需手动完成或运行脚本）

84
application/store/用户管理和算力中心接口上传成功.md Normal file
View File

@@ -0,0 +1,84 @@
# 用户管理和算力中心接口上传成功
## 目录信息
- 用户管理目录ID: 78015216
- 算力中心目录ID: 78015216
- 项目ID: 6037107
## 接口列表
### 用户管理
#### 获取用户资料
- **接口ID**: 416301911
- **路径**: /v2/store/user/profile
#### 更新用户资料
- **接口ID**: 416301915
- **路径**: /v2/store/user/profile
#### 获取算力套餐列表
- **接口ID**: 416301919
- **路径**: /v2/store/tokens/packages
#### 购买算力
- **接口ID**: 416301920
- **路径**: /v2/store/tokens/pay
#### 查询订单状态
- **接口ID**: 416301922
- **路径**: /v2/store/tokens/order
#### 获取订单列表
- **接口ID**: 416301923
- **路径**: /v2/store/tokens/orders
#### 获取算力统计
- **接口ID**: 416301924
- **路径**: /v2/store/tokens/statistics
### 算力中心
#### 获取用户资料
- **接口ID**: 416301911
- **路径**: /v2/store/user/profile
#### 更新用户资料
- **接口ID**: 416301915
- **路径**: /v2/store/user/profile
#### 获取算力套餐列表
- **接口ID**: 416301919
- **路径**: /v2/store/tokens/packages
#### 购买算力
- **接口ID**: 416301920
- **路径**: /v2/store/tokens/pay
#### 查询订单状态
- **接口ID**: 416301922
- **路径**: /v2/store/tokens/order
#### 获取订单列表
- **接口ID**: 416301923
- **路径**: /v2/store/tokens/orders
#### 获取算力统计
- **接口ID**: 416301924
- **路径**: /v2/store/tokens/statistics

19
application/store/设备和微信接口上传成功.md Normal file
View File

@@ -0,0 +1,19 @@
# 设备和微信接口上传成功
## 目录信息
- 目录ID: 78015216
- 项目ID: 6037107
## 接口列表
### 获取设备和微信信息
- **接口ID**: 416318959
- **路径**: /v2/store/device-wechat/info
### 获取动态记录
- **接口ID**: 416318961
- **路径**: /v2/store/device-wechat/dynamic-records

205
application/store/阿里云短信配置说明.md Normal file
View File

@@ -0,0 +1,205 @@
# 阿里云短信配置说明
## 📋 配置流程
### 1. 开通阿里云短信服务
1. 登录[阿里云控制台](https://www.aliyun.com/)
2. 进入[短信服务控制台](https://dysms.console.aliyun.com/)
3. 开通短信服务
### 2. 申请短信签名
1. 进入"国内消息" → "签名管理"
2. 点击"添加签名"
3. 填写签名信息：
- **签名名称**：AI数智员工（根据实际情况填写）
- **签名来源**：选择"企事业单位的全称或简称"
- **上传证明材料**：营业执照等
4. 等待审核通过（通常1个工作日）
### 3. 申请短信模板
1. 进入"国内消息" → "模板管理"
2. 点击"添加模板"
3. 填写模板信息：
- **模板类型**：验证码
- **模板名称**：登录验证码
- **模板内容**：`您的验证码是${code}，5分钟内有效。`
- **申请说明**：用于用户登录验证
4. 等待审核通过（通常1个工作日）
5. 记录模板CODE（如：`SMS_123456789`）
### 4. 获取AccessKey
1. 点击右上角头像 → "AccessKey管理"
2. 创建AccessKey（建议使用子账号并授权短信权限）
3. 记录 **AccessKey ID** 和 **AccessKey Secret**
⚠️ **安全提示**：请妥善保管AccessKey，不要泄露或提交到代码仓库！
---
## ⚙️ 配置到项目
### 方式1：修改 .env 文件（推荐）
在 `Server/.env` 文件中添加以下配置：
```env
# 阿里云短信配置
ALIYUN_SMS_ACCESS_KEY_ID = LTAI5tXXXXXXXXXXXXXX
ALIYUN_SMS_ACCESS_KEY_SECRET = 9qYXXXXXXXXXXXXXXXXXXXXXXXXX
ALIYUN_SMS_SIGN_NAME = AI数智员工
ALIYUN_SMS_TEMPLATE_CODE = SMS_123456789
ALIYUN_SMS_REGION_ID = cn-hangzhou
```
### 方式2：直接修改配置文件（不推荐）
在 `Server/config/aliyun_sms.php` 文件中：
```php
return [
'access_key_id' => 'LTAI5tXXXXXXXXXXXXXX',
'access_key_secret' => '9qYXXXXXXXXXXXXXXXXXXXXXXXXX',
'sign_name' => 'AI数智员工',
'template_code' => 'SMS_123456789',
'region_id' => 'cn-hangzhou',
];
```
⚠️ **不建议**：配置文件可能被提交到代码仓库，存在安全风险！
---
## 🧪 测试配置
### 开发模式测试（无需真实配置）
**未配置AccessKey时自动进入开发模式**：
```bash
# 1. 调用发送验证码接口
curl -X POST http://localhost/v2/store/auth/send-code \
-H "Content-Type: application/json" \
-d '{"mobile":"13800138000","type":"login"}'
# 2. 查看日志获取验证码
tail -f runtime/log/$(date +%Y%m)/$(date +%d).log
```
**日志示例**：
```
[2026-02-05 10:30:00] INFO 短信验证码发送成功 {"mobile":"13800138000","type":"login","code":"123456"}
```
### 生产模式测试（配置真实密钥）
```bash
# 1. 发送验证码
curl -X POST https://yi.54word.com/v2/store/auth/send-code \
-H "Content-Type: application/json" \
-d '{"mobile":"13800138000","type":"login"}'
# 2. 手机收到验证码后测试登录
curl -X POST https://yi.54word.com/v2/store/auth/mobile-login \
-H "Content-Type: application/json" \
-d '{"mobile":"13800138000","code":"123456","is_encrypted":false}'
```
---
## 📊 配置参数说明
| 参数名 | 环境变量 | 说明 | 示例值 |
|-------|---------|------|--------|
| **access_key_id** | `ALIYUN_SMS_ACCESS_KEY_ID` | 阿里云AccessKey ID | `LTAI5tXXXXXXXXXXXXXX` |
| **access_key_secret** | `ALIYUN_SMS_ACCESS_KEY_SECRET` | 阿里云AccessKey Secret | `9qYXXXXXXXXXXXXXXXXXXXXXXXXX` |
| **sign_name** | `ALIYUN_SMS_SIGN_NAME` | 短信签名（需审核通过） | `AI数智员工` |
| **template_code** | `ALIYUN_SMS_TEMPLATE_CODE` | 短信模板CODE（需审核通过） | `SMS_123456789` |
| **region_id** | `ALIYUN_SMS_REGION_ID` | 短信服务地域 | `cn-hangzhou` |
---
## 🔍 常见问题
### Q1：如何查看验证码是否发送成功？
**开发模式**：查看日志文件
```bash
tail -f runtime/log/$(date +%Y%m)/$(date +%d).log | grep "短信验证码"
```
**生产模式**：
- 检查手机是否收到验证码
- 查看阿里云控制台 → 短信服务 → 发送记录
### Q2：提示"AccessKey不存在"怎么办？
1. 检查 `.env` 文件中的配置是否正确
2. 确认AccessKey是否有效（未禁用）
3. 确认AccessKey是否有短信发送权限
### Q3：提示"签名不存在"怎么办？
1. 检查签名名称是否与控制台完全一致（包括空格）
2. 确认签名审核状态为"审核通过"
3. 检查 `ALIYUN_SMS_SIGN_NAME` 配置
### Q4：提示"模板不存在"怎么办？
1. 检查模板CODE是否正确
2. 确认模板审核状态为"审核通过"
3. 检查 `ALIYUN_SMS_TEMPLATE_CODE` 配置
### Q5：如何限制验证码发送频率？
系统已内置限制：
- ✅ **60秒内只能发送1次**（同一手机号）
- ✅ 验证码**5分钟有效**
- ✅ 验证后**自动失效**
可在 `SmsService.php` 中修改：
```php
// 修改发送频率（秒）
Cache::set($cacheKey, time(), 60); // 60秒
// 修改有效期（秒）
Cache::set($verifyKey, $code, 300); // 300秒 = 5分钟
```
### Q6：如何在开发环境使用真实短信？
在 `.env` 文件中配置真实的AccessKey即可，系统会自动切换到生产模式。
---
## 💰 费用说明
- **按量计费**：约 0.045元/条（国内短信）
- **免费额度**：新用户赠送100条测试额度
- **套餐包**：可购买短信包（价格更优惠）
**查看费用**：阿里云控制台 → 短信服务 → 用量统计
---
## 🔒 安全建议
1. ✅ 使用子账号并最小化权限（只授予短信发送权限）
2. ✅ 定期更换AccessKey
3. ✅ 不要将AccessKey提交到代码仓库
4. ✅ 使用 `.env` 文件管理敏感配置
5. ✅ 将 `.env` 文件加入 `.gitignore`
6. ✅ 生产环境关闭日志中的验证码记录
---
## 📞 技术支持
如有问题，请联系：
- **阿里云工单**：https://workorder.console.aliyun.com/
- **短信服务文档**：https://help.aliyun.com/product/44282.html
- **项目技术支持**：联系开发团队

49
application/store_old/config/route.php Normal file
View File

@@ -0,0 +1,49 @@
<?php
// store_old模块路由配置
use think\facade\Route;
// 定义RESTful风格的API路由
Route::group('v1/store_old', function () {
// 流量套餐相关路由
Route::group('flow-packages', function () {
Route::get('', 'app\store_old\controller\FlowPackageController@getList'); // 获取流量套餐列表
Route::get('remaining-flow', 'app\store_old\controller\FlowPackageController@remainingFlow'); // 获取用户剩余流量
Route::get(':id', 'app\store_old\controller\FlowPackageController@detail'); // 获取流量套餐详情
Route::post('order', 'app\store_old\controller\FlowPackageController@createOrder'); // 创建流量采购订单
});
// 流量订单相关路由
Route::group('flow-orders', function () {
Route::get('list', 'app\store_old\controller\FlowPackageController@getOrderList'); // 获取订单列表
Route::get(':orderNo', 'app\store_old\controller\FlowPackageController@getOrderDetail'); // 获取订单详情
});
// 客户相关路由
Route::group('customers', function () {
Route::get('list', 'app\store_old\controller\CustomerController@getList'); // 获取客户列表
});
// 系统配置相关路由
Route::group('system-config', function () {
Route::get('switch-status', 'app\store_old\controller\SystemConfigController@getSwitchStatus'); // 获取系统开关状态
Route::post('update-switch-status', 'app\store_old\controller\SystemConfigController@updateSwitchStatus'); // 更新系统开关状态
});
// 数据统计相关路由
Route::group('statistics', function () {
Route::get('overview', 'app\store_old\controller\StatisticsController@getOverview'); // 获取数据概览
Route::get('comprehensive-analysis', 'app\store_old\controller\StatisticsController@getComprehensiveAnalysis'); // 获取综合分析数据
});
// 供应商相关路由
Route::group('vendor', function () {
Route::get('list', 'app\store_old\controller\VendorController@getList'); // 获取供应商列表
Route::get('detail', 'app\store_old\controller\VendorController@detail'); // 获取供应商详情
Route::post('order', 'app\store_old\controller\VendorController@createOrder'); // 创建订单
});
})->middleware(['jwt']);
Route::get('v1/store_old/login', 'app\store_old\controller\LoginController@index');

65
application/store_old/controller/BaseController.php Normal file
View File

@@ -0,0 +1,65 @@
<?php
namespace app\store_old\controller;
use think\Controller;
use think\facade\Config;
use think\facade\Request;
use think\facade\Response;
use think\facade\Log;
use app\common\controller\Api;
use think\Db;
use think\facade\Cache;
/**
* 基础控制器
*/
class BaseController extends Api
{
protected $device = [];
protected $userInfo = [];
protected $cacheExpire = 3600; // 缓存过期时间：1小时
/**
* 构造方法
*/
public function __construct()
{
parent::__construct();
$this->userInfo = request()->userInfo;
// 生成缓存key
$cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId'];
// 尝试从缓存获取设备信息
$device = Cache::get($cacheKey);
// 如果缓存不存在，则从数据库获取
if (!$device) {
$device = Db::name('device_user')
->alias('du')
->join('device d', 'd.id = du.deviceId','left')
->join('device_wechat_login dwl', 'dwl.deviceId = du.deviceId','left')
->join('wechat_account wa', 'dwl.wechatId = wa.wechatId','left')
->where([
'du.userId' => $this->userInfo['id'],
'du.companyId' => $this->userInfo['companyId']
])
->field('d.*,wa.wechatId,wa.alias,wa.s2_wechatAccountId as wechatAccountId')
->find();
// 将设备信息存入缓存
if ($device) {
Cache::set($cacheKey, $device, $this->cacheExpire);
}
}
$this->device = $device;
}
/**
* 清除设备信息缓存
*/
protected function clearDeviceCache()
{
$cacheKey = 'device_info_' . $this->userInfo['id'] . '_' . $this->userInfo['companyId'];
Cache::rm($cacheKey);
}
}

93
application/store_old/controller/CustomerController.php Normal file
View File

@@ -0,0 +1,93 @@
<?php
namespace app\store_old\controller;
use app\common\controller\Api;
use think\Db;
/**
* 客户管理控制器
*/
class CustomerController extends Api
{
protected $noNeedLogin = [];
protected $noNeedRight = ['*'];
/**
* 获取客户列表
*
* @return \think\Response
*/
public function getList()
{
$params = $this->request->param();
// 获取分页参数
$page = isset($params['page']) ? intval($params['page']) : 1;
$pageSize = isset($params['pageSize']) ? intval($params['pageSize']) : 10;
$userInfo = request()->userInfo;
$where = [];
// 必要的查询条件
$userId = $userInfo['id'];
$companyId = $userInfo['companyId'];
if (empty($userId) || empty($companyId)) {
return errorJson('缺少必要参数');
}
// 构建查询条件
$deviceIds = Db::name('device_user')->where(['userId' => $userId, 'companyId' => $companyId])->order('id DESC')->column('deviceId');
if (empty($deviceIds)) {
return errorJson('设备不存在');
}
$wechatIds = [];
foreach ($deviceIds as $deviceId) {
$wechatIds[] = Db::name('device_wechat_login')
->where(['deviceId' => $deviceId])
->order('id DESC')
->value('wechatId');
}
// 搜索条件
if (!empty($params['keyword'])) {
$where['alias|nickname|wechatId'] = ['like', '%' . $params['keyword'] . '%'];
}
// if (!empty($params['email'])) {
// $where['wa.bindEmail'] = ['like', '%' . $params['email'] . '%'];
// }
// if (!empty($params['name'])) {
// $where['wa.accountRealName|wa.accountUserName|wa.nickname'] = ['like', '%' . $params['name'] . '%'];
// }
// 构建查询
$query = Db::table('s2_wechat_friend')
->where($where)
->whereIn('ownerWechatId',$wechatIds)
->group('wechatId'); // 防止重复数据
// 克隆查询对象，用于计算总数
$countQuery = clone $query;
$total = $countQuery->count();
// 获取分页数据
$list = $query->page($page, $pageSize)
->order('id DESC')
->select();
// 格式化数据
foreach ($list as &$item) {
$item['labels'] = json_decode($item['labels'], true);
$item['createTime'] = date('Y-m-d H:i:s', $item['createTime']);
}
unset($item);
return successJson([
'list' => $list,
'total' => $total
], '获取成功');
}
}

295
application/store_old/controller/FlowPackageController.php Normal file
View File

@@ -0,0 +1,295 @@
<?php
namespace app\store_old\controller;
use app\common\controller\Api;
use app\store\model\FlowPackageModel;
use app\store\model\UserFlowPackageModel;
use app\store\model\FlowPackageOrderModel;
use think\facade\Config;
/**
* 流量套餐控制器
*/
class FlowPackageController extends Api
{
protected $noNeedLogin = [];
protected $noNeedRight = ['*'];
/**
* 获取流量套餐列表
*
* @return \think\Response
*/
public function getList()
{
$params = $this->request->param();
// 查询条件
$where = [];
// 只获取未删除的数据
$where[] = ['isDel', '=', 0];
// 套餐模型
$model = new FlowPackageModel();
// 查询数据
$list = $model->where($where)
->field('id, name, tag, originalPrice, price, monthlyFlow, duration, privileges')
->order('sort', 'asc')
->select();
// 格式化返回数据，添加计算字段
$result = [];
foreach ($list as $item) {
$result[] = [
'id' => $item['id'],
'name' => $item['name'],
'tag' => $item['tag'],
'originalPrice' => $item['originalPrice'],
'price' => $item['price'],
'monthlyFlow' => $item['monthlyFlow'],
'duration' => $item['duration'],
'discount' => $item->discount,
'totalFlow' => $item->totalFlow,
'privileges' => $item['privileges'],
];
}
return successJson($result, '获取成功');
}
/**
* 获取流量套餐详情
*
* @param int $id 套餐ID
* @return \think\Response
*/
public function detail($id)
{
if (empty($id)) {
return errorJson('参数错误');
}
// 套餐模型
$model = new FlowPackageModel();
// 查询数据
$info = $model->where('id', $id)->where('isDel', 0)->find();
if (empty($info)) {
return errorJson('套餐不存在');
}
// 格式化返回数据，添加计算字段
$result = [
'id' => $info['id'],
'name' => $info['name'],
'tag' => $info['tag'],
'originalPrice' => $info['originalPrice'],
'price' => $info['price'],
'monthlyFlow' => $info['monthlyFlow'],
'duration' => $info['duration'],
'discount' => $info->discount,
'totalFlow' => $info->totalFlow,
'privileges' => $info['privileges'],
];
return successJson($result, '获取成功');
}
/**
* 展示用户流量套餐使用情况
*
* @return \think\Response
*/
public function remainingFlow()
{
$params = $this->request->param();
$userInfo = request()->userInfo;
// 获取用户ID，通常应该从会话或令牌中获取
$userId = $userInfo['id'];
if (empty($userId)) {
return errorJson('请先登录');
}
// 获取用户当前有效的流量套餐
$userPackage = UserFlowPackageModel::getUserActivePackage($userId);
if (empty($userPackage)) {
return errorJson('您没有有效的流量套餐');
}
// 获取套餐详情
$packageId = $userPackage['packageId'];
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($flowPackage)) {
return errorJson('套餐信息不存在');
}
// 计算剩余流量
$totalFlow = $userPackage['totalFlow'] ?? $flowPackage->totalFlow; // 总流量
$usedFlow = $userPackage['usedFlow'] ?? 0; // 已使用流量
$remainingFlow = $totalFlow - $usedFlow; // 剩余流量
$remainingFlow = $remainingFlow > 0 ? $remainingFlow : 0; // 确保不为负数
// 计算剩余天数
$now = time();
$expireTime = $userPackage['expireTime'];
$remainingDays = ceil(($expireTime - $now) / 86400); // 向上取整，剩余天数
$remainingDays = $remainingDays > 0 ? $remainingDays : 0; // 确保不为负数
// 剩余百分比
$flowPercentage = $totalFlow > 0 ? round(($remainingFlow / $totalFlow) * 100, 1) : 0;
$timePercentage = $userPackage['duration'] > 0 ?
round(($remainingDays / ($userPackage['duration'] * 30)) * 100, 1) : 0;
// 返回数据
$result = [
'packageName' => $flowPackage['name'], // 套餐名称
'remainingFlow' => $remainingFlow, // 剩余流量(人)
'totalFlow' => $totalFlow, // 总流量(人)
'flowPercentage' => $flowPercentage, // 剩余流量百分比
'remainingDays' => $remainingDays, // 剩余天数
'totalDays' => $userPackage['duration'] * 30, // 总天数(按30天/月计算)
'timePercentage' => $timePercentage, // 剩余时间百分比
'expireTime' => date('Y-m-d', $expireTime), // 到期日期
'startTime' => date('Y-m-d', $userPackage['startTime']), // 开始日期
];
return successJson($result, '获取成功');
}
/**
* 创建流量采购订单
*
* @return \think\Response
*/
public function createOrder()
{
$params = $this->request->param();
$userInfo = request()->userInfo;
// 获取用户ID，通常应该从会话或令牌中获取
$userId = $userInfo['id'];
if (empty($userId)) {
return errorJson('请先登录');
}
// 获取套餐ID
$packageId = isset($params['packageId']) ? intval($params['packageId']) : 0;
if (empty($packageId)) {
return errorJson('请选择套餐');
}
// 查询套餐信息
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($flowPackage)) {
return errorJson('套餐不存在');
}
// 获取支付方式（可选）
$payType = isset($params['payType']) ? $params['payType'] : 'wechat';
// 套餐价格和信息
$amount = floatval($flowPackage['price']);
$packageName = $flowPackage['name'];
$duration = intval($flowPackage['duration']);
$remark = isset($params['remark']) ? $params['remark'] : '';
// 处理金额为0的特殊情况
if ($amount <= 0) {
// 金额为0，无需支付，直接创建订单并设置为已支付
$order = FlowPackageOrderModel::createOrder(
$userId,
$packageId,
$packageName,
0,
$duration,
'nopay',
$remark
);
if (!$order) {
return errorJson('订单创建失败');
}
// 创建用户流量套餐记录
$this->createUserFlowPackage($userId, $packageId, $order['id']);
// 返回成功信息
return successJson(['orderNo' => $order['orderNo'],'status' => 'success'], '购买成功');
} else {
// 创建正常需要支付的订单
$order = FlowPackageOrderModel::createOrder(
$userId,
$packageId,
$packageName,
$amount,
$duration,
$payType,
$remark
);
if (!$order) {
return errorJson('订单创建失败');
}
// 返回订单信息，前端需要跳转到支付页面
return successJson([
'orderNo' => $order['orderNo'],
'amount' => $amount,
'payType' => $payType,
'status' => 'pending'
], '订单创建成功');
}
}
/**
* 创建用户流量套餐记录
*
* @param int $userId 用户ID
* @param int $packageId 套餐ID
* @param int $orderId 订单ID
* @return bool
*/
private function createUserFlowPackage($userId, $packageId, $orderId)
{
// 获取套餐信息
$flowPackage = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($flowPackage)) {
return false;
}
// 计算到期时间（当前时间 + 套餐时长(月) * 30天）
$now = time();
$expireTime = $now + (intval($flowPackage['duration']) * 30 * 86400);
// 用户流量套餐数据
$data = [
'userId' => $userId,
'packageId' => $packageId,
'orderId' => $orderId,
'packageName' => $flowPackage['name'],
'monthlyFlow' => $flowPackage['monthlyFlow'],
'duration' => $flowPackage['duration'],
'totalFlow' => $flowPackage->totalFlow, // 使用计算属性获取总流量
'usedFlow' => 0,
'startTime' => $now,
'expireTime' => $expireTime,
'status' => 1, // 1:有效 0:无效
'isDel' => 0
];
// 创建用户流量套餐记录
return UserFlowPackageModel::create($data) ? true : false;
}
}

2
application/store/controller/LoginController.php → application/store_old/controller/LoginController.php
View File

@@ -1,6 +1,6 @@
<?php <?php
namespace app\store\controller; namespace app\store_old\controller;
use app\common\util\JwtUtil; use app\common\util\JwtUtil;
use think\Db; use think\Db;

2
application/store/controller/StatisticsController.php → application/store_old/controller/StatisticsController.php
View File

@@ -1,6 +1,6 @@
<?php <?php
namespace app\store\controller; namespace app\store_old\controller;
use app\store\model\WechatFriendModel; use app\store\model\WechatFriendModel;
use app\store\model\WechatMessageModel; use app\store\model\WechatMessageModel;

2
application/store/controller/SystemConfigController.php → application/store_old/controller/SystemConfigController.php
View File

@@ -1,6 +1,6 @@
<?php <?php
namespace app\store\controller; namespace app\store_old\controller;
use think\Db; use think\Db;
use think\facade\Log; use think\facade\Log;

2
application/store/controller/TrafficPackage.php → application/store_old/controller/TrafficPackage.php
View File

@@ -1,5 +1,5 @@
<?php <?php
namespace app\store\controller; namespace app\store_old\controller;
use app\store\model\TrafficPackage as TrafficPackageModel; use app\store\model\TrafficPackage as TrafficPackageModel;
use think\Controller; use think\Controller;

534
application/store_old/controller/VendorController.php Normal file
View File

@@ -0,0 +1,534 @@
<?php
namespace app\store_old\controller;
use app\store\model\VendorPackageModel;
use app\store\model\VendorProjectModel;
use app\store\model\VendorOrderModel;
use think\facade\Log;
use think\Db;
/**
* 套餐控制器
*/
class VendorController extends BaseController
{
/**
* 获取套餐列表
*
* @return \think\response\Json
*/
public function getList()
{
try {
$page = $this->request->param('page', 1);
$limit = $this->request->param('limit', 10);
$keyword = $this->request->param('keyword', '');
$status = $this->request->param('status', '');
$where = [
['isDel', '=', 0]
];
// 关键词搜索
if (!empty($keyword)) {
$where[] = ['name', 'like', "%{$keyword}%"];
}
// 状态筛选
if ($status !== '') {
$where[] = ['status', '=', $status];
}
$list = VendorPackageModel::where($where)
->order('id', 'desc')
->page($page, $limit)
->select();
$total = VendorPackageModel::where($where)->count();
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $list,
'total' => $total,
]
]);
} catch (\Exception $e) {
Log::error('获取套餐列表失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 获取套餐详情
*
* @return \think\response\Json
*/
public function detail()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 查询套餐基本信息
$package = VendorPackageModel::where([
['id', '=', $id],
['isDel', '=', 0]
])->find();
if (empty($package)) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
// 查询项目列表
$projects = VendorProjectModel::where([
['packageId', '=', $id],
['isDel', '=', 0]
])->select();
$package['projects'] = $projects;
return json(['code' => 200, 'msg' => '获取成功', 'data' => $package]);
} catch (\Exception $e) {
Log::error('获取套餐详情失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 添加套餐
*
* @return \think\response\Json
*/
public function add()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '套餐名称不能为空']);
}
// 检查名称是否已存在
$exists = VendorPackageModel::where([
['name', '=', $param['name']],
['isDel', '=', 0]
])->find();
if ($exists) {
return json(['code' => 400, 'msg' => '该套餐名称已存在']);
}
Db::startTrans();
try {
// 创建套餐
$package = new VendorPackageModel;
$package->name = $param['name'];
$package->originalPrice = $param['originalPrice'] ?? 0;
$package->price = $param['price'] ?? 0;
$package->discount = $param['discount'] ?? 0;
$package->advancePayment = $param['advancePayment'] ?? 0;
$package->tags = $param['tags'] ?? '';
$package->description = $param['description'] ?? '';
$package->cover = $param['cover'] ?? '';
$package->status = $param['status'] ?? 1;
$package->createTime = time();
$package->updateTime = time();
$package->save();
// 处理项目信息
if (!empty($param['projects']) && is_array($param['projects'])) {
foreach ($param['projects'] as $projectData) {
if (empty($projectData['name'])) {
continue;
}
// 创建项目
$project = new VendorProjectModel;
$project->packageId = $package->id;
$project->name = $projectData['name'];
$project->originalPrice = $projectData['originalPrice'] ?? 0;
$project->price = $projectData['price'] ?? 0;
$project->duration = $projectData['duration'] ?? 0;
$project->image = $projectData['image'] ?? '';
$project->detail = $projectData['detail'] ?? '';
$project->createTime = time();
$project->updateTime = time();
$project->save();
}
}
Db::commit();
return json(['code' => 200, 'msg' => '添加成功', 'data' => ['id' => $package->id]]);
} catch (\Exception $e) {
Db::rollback();
Log::error('添加套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('添加套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加异常：' . $e->getMessage()]);
}
}
/**
* 编辑套餐
*
* @return \think\response\Json
*/
public function edit()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '参数错误']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '套餐名称不能为空']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $param['id']],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
// 检查名称是否已存在
$exists = VendorPackageModel::where([
['name', '=', $param['name']],
['id', '<>', $param['id']],
['isDel', '=', 0]
])->find();
if ($exists) {
return json(['code' => 400, 'msg' => '该套餐名称已存在']);
}
Db::startTrans();
try {
// 更新套餐
$package->name = $param['name'];
$package->originalPrice = $param['originalPrice'] ?? $package->originalPrice;
$package->price = $param['price'] ?? $package->price;
$package->discount = $param['discount'] ?? $package->discount;
$package->advancePayment = $param['advancePayment'] ?? $package->advancePayment;
$package->tags = $param['tags'] ?? $package->tags;
$package->description = $param['description'] ?? $package->description;
$package->cover = $param['cover'] ?? $package->cover;
$package->status = $param['status'] ?? $package->status;
$package->updateTime = time();
$package->save();
Db::commit();
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Db::rollback();
Log::error('更新套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('编辑套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '编辑异常：' . $e->getMessage()]);
}
}
/**
* 删除套餐
*
* @return \think\response\Json
*/
public function delete()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $id],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
Db::startTrans();
try {
// 软删除套餐
$package->isDel = 1;
$package->updateTime = time();
$package->save();
// 软删除关联的项目
VendorProjectModel::where('packageId', $id)
->update([
'isDel' => 1,
'updateTime' => time()
]);
Db::commit();
return json(['code' => 200, 'msg' => '删除成功']);
} catch (\Exception $e) {
Db::rollback();
Log::error('删除套餐失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('删除套餐异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除异常：' . $e->getMessage()]);
}
}
/**
* 添加项目
*
* @return \think\response\Json
*/
public function addProject()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['packageId'])) {
return json(['code' => 400, 'msg' => '套餐ID不能为空']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '项目名称不能为空']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $param['packageId']],
['isDel', '=', 0]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在']);
}
try {
// 创建项目
$project = new VendorProjectModel;
$project->packageId = $param['packageId'];
$project->name = $param['name'];
$project->originalPrice = $param['originalPrice'] ?? 0;
$project->price = $param['price'] ?? 0;
$project->duration = $param['duration'] ?? 0;
$project->image = $param['image'] ?? '';
$project->detail = $param['detail'] ?? '';
$project->createTime = time();
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '添加成功', 'data' => ['id' => $project->id]]);
} catch (\Exception $e) {
Log::error('添加项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('添加项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '添加异常：' . $e->getMessage()]);
}
}
/**
* 编辑项目
*
* @return \think\response\Json
*/
public function editProject()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '项目ID不能为空']);
}
if (empty($param['name'])) {
return json(['code' => 400, 'msg' => '项目名称不能为空']);
}
// 检查项目是否存在
$project = VendorProjectModel::where([
['id', '=', $param['id']],
['isDel', '=', 0]
])->find();
if (!$project) {
return json(['code' => 404, 'msg' => '项目不存在']);
}
try {
// 更新项目
$project->name = $param['name'];
$project->originalPrice = $param['originalPrice'] ?? $project->originalPrice;
$project->price = $param['price'] ?? $project->price;
$project->duration = $param['duration'] ?? $project->duration;
$project->image = $param['image'] ?? $project->image;
$project->detail = $param['detail'] ?? $project->detail;
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Log::error('更新项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('编辑项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '编辑异常：' . $e->getMessage()]);
}
}
/**
* 删除项目
*
* @return \think\response\Json
*/
public function deleteProject()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 检查项目是否存在
$project = VendorProjectModel::where([
['id', '=', $id],
['isDel', '=', 0]
])->find();
if (!$project) {
return json(['code' => 404, 'msg' => '项目不存在']);
}
try {
// 软删除项目
$project->isDel = 1;
$project->updateTime = time();
$project->save();
return json(['code' => 200, 'msg' => '删除成功']);
} catch (\Exception $e) {
Log::error('删除项目失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('删除项目异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '删除异常：' . $e->getMessage()]);
}
}
/**
* 创建订单
*
* @return \think\response\Json
*/
public function createOrder()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['packageId'])) {
return json(['code' => 400, 'msg' => '套餐ID不能为空']);
}
// 检查套餐是否存在
$package = VendorPackageModel::where([
['id', '=', $param['packageId']],
['isDel', '=', 0],
['status', '=', 1]
])->find();
if (!$package) {
return json(['code' => 404, 'msg' => '套餐不存在或已下架']);
}
// 获取当前用户信息
$userId = $this->request->userInfo['id'];
if (empty($userId)) {
return json(['code' => 401, 'msg' => '请先登录']);
}
Db::startTrans();
try {
// 生成订单
$order = new VendorOrderModel;
$order->orderNo = VendorOrderModel::generateOrderNo();
$order->userId = $userId;
$order->packageId = $package->id;
$order->packageName = $package->name;
$order->totalAmount = $package->price;
$order->payAmount = $package->price;
$order->advancePayment = $package->advancePayment;
$order->status = VendorOrderModel::STATUS_UNPAID;
$order->remark = $param['remark'] ?? '';
$order->createTime = time();
$order->updateTime = time();
$order->save();
Db::commit();
return json([
'code' => 200,
'msg' => '订单创建成功',
'data' => [
'orderId' => $order->id,
'orderNo' => $order->orderNo
]
]);
} catch (\Exception $e) {
Db::rollback();
Log::error('创建订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '创建订单失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('创建订单异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '创建订单异常：' . $e->getMessage()]);
}
}
}

229
application/store_old/controller/VendorOrderController.php Normal file
View File

@@ -0,0 +1,229 @@
<?php
namespace app\store_old\controller;
use app\store\model\VendorPackageModel;
use app\store\model\VendorProjectModel;
use app\store\model\VendorOrderModel;
use think\facade\Log;
use think\Db;
/**
* 订单控制器
*/
class VendorOrderController extends BaseController
{
/**
* 获取订单列表
*
* @return \think\response\Json
*/
public function getList()
{
try {
$page = $this->request->param('page', 1);
$limit = $this->request->param('limit', 10);
$status = $this->request->param('status', '');
$keyword = $this->request->param('keyword', '');
// 获取当前用户信息
$userId = $this->request->userInfo['id'];
$where = [
['userId', '=', $userId]
];
// 关键词搜索
if (!empty($keyword)) {
$where[] = ['orderNo|packageName', 'like', "%{$keyword}%"];
}
// 状态筛选
if ($status !== '') {
$where[] = ['status', '=', $status];
}
$list = VendorOrderModel::with(['package'])
->where($where)
->order('id', 'desc')
->page($page, $limit)
->select();
$total = VendorOrderModel::where($where)->count();
return json([
'code' => 200,
'msg' => '获取成功',
'data' => [
'list' => $list,
'total' => $total,
'page' => $page,
'limit' => $limit
]
]);
} catch (\Exception $e) {
Log::error('获取订单列表失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 获取订单详情
*
* @return \think\response\Json
*/
public function detail()
{
try {
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 获取当前用户信息
$userId = $this->request->userInfo['id'];
// 查询订单
$order = VendorOrderModel::with(['package'])
->where([
['id', '=', $id],
['userId', '=', $userId]
])->find();
if (empty($order)) {
return json(['code' => 404, 'msg' => '订单不存在']);
}
// 查询套餐项目
if (!empty($order['package'])) {
$projects = VendorProjectModel::where([
['packageId', '=', $order['packageId']],
['isDel', '=', 0]
])->select();
$order['package']['projects'] = $projects;
}
return json(['code' => 200, 'msg' => '获取成功', 'data' => $order]);
} catch (\Exception $e) {
Log::error('获取订单详情失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '获取失败：' . $e->getMessage()]);
}
}
/**
* 更新订单状态
*
* @return \think\response\Json
*/
public function updateStatus()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$param = $this->request->post();
// 参数验证
if (empty($param['id'])) {
return json(['code' => 400, 'msg' => '订单ID不能为空']);
}
if (!isset($param['status'])) {
return json(['code' => 400, 'msg' => '订单状态不能为空']);
}
// 检查订单是否存在
$order = VendorOrderModel::where('id', $param['id'])->find();
if (!$order) {
return json(['code' => 404, 'msg' => '订单不存在']);
}
// 检查状态是否有效
$validStatus = [
VendorOrderModel::STATUS_UNPAID,
VendorOrderModel::STATUS_PAID,
VendorOrderModel::STATUS_COMPLETED,
VendorOrderModel::STATUS_CANCELED
];
if (!in_array($param['status'], $validStatus)) {
return json(['code' => 400, 'msg' => '无效的订单状态']);
}
// 更新订单状态
$updateData = [
'status' => $param['status'],
'updateTime' => time()
];
// 如果订单状态为已支付，记录支付时间
if ($param['status'] == VendorOrderModel::STATUS_PAID) {
$updateData['payTime'] = time();
}
try {
$order->save($updateData);
return json(['code' => 200, 'msg' => '更新成功']);
} catch (\Exception $e) {
Log::error('更新订单状态失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('更新订单状态异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '更新异常：' . $e->getMessage()]);
}
}
/**
* 取消订单
*
* @return \think\response\Json
*/
public function cancel()
{
try {
if (!$this->request->isPost()) {
return json(['code' => 400, 'msg' => '请求方式错误']);
}
$id = $this->request->param('id', 0);
if (empty($id)) {
return json(['code' => 400, 'msg' => '参数错误']);
}
// 获取当前用户信息
$userId = $this->request->userInfo['id'];
// 检查订单是否存在
$order = VendorOrderModel::where([
['id', '=', $id],
['userId', '=', $userId],
['status', '=', VendorOrderModel::STATUS_UNPAID]
])->find();
if (!$order) {
return json(['code' => 404, 'msg' => '订单不存在或状态不允许取消']);
}
try {
// 更新订单状态为已取消
$order->status = VendorOrderModel::STATUS_CANCELED;
$order->updateTime = time();
$order->save();
return json(['code' => 200, 'msg' => '取消成功']);
} catch (\Exception $e) {
Log::error('取消订单失败：' . $e->getMessage());
return json(['code' => 500, 'msg' => '取消失败：' . $e->getMessage()]);
}
} catch (\Exception $e) {
Log::error('取消订单异常：' . $e->getMessage());
return json(['code' => 500, 'msg' => '取消异常：' . $e->getMessage()]);
}
}
}

64
application/store_old/model/FlowPackageModel.php Normal file
View File

@@ -0,0 +1,64 @@
<?php
namespace app\store\model;
use think\Model;
class FlowPackageModel extends Model
{
protected $name = 'flow_package';
// 定义字段自动转换
protected $type = [
// 将特权字段从多行文本转换为数组
'privileges' => 'array',
];
/**
* 特权字段获取器 - 将多行文本转换为数组
* @param $value
* @return array
*/
public function getPrivilegesAttr($value)
{
if (empty($value)) {
return [];
}
// 如果已经是数组则直接返回
if (is_array($value)) {
return $value;
}
// 按行分割文本
return array_filter(explode("\n", $value));
}
/**
* 折扣获取器 - 根据原价和售价计算折扣
* @param $value
* @param $data
* @return string
*/
public function getDiscountAttr($value, $data)
{
if (empty($data['originalPrice']) || $data['originalPrice'] <= 0) {
return '原价';
}
$discount = round(($data['price'] / $data['originalPrice']) * 10, 1);
return $discount . '折';
}
/**
* 总流量获取器 - 计算套餐总流量
* @param $value
* @param $data
* @return int
*/
public function getTotalFlowAttr($value, $data)
{
return isset($data['monthlyFlow']) && isset($data['duration']) ?
intval($data['monthlyFlow']) * intval($data['duration']) : 0;
}
}

93
application/store_old/model/FlowPackageOrderModel.php Normal file
View File

@@ -0,0 +1,93 @@
<?php
namespace app\store\model;
use think\Model;
/**
* 流量订单模型
*/
class FlowPackageOrderModel extends Model
{
// 设置表名
protected $name = 'flow_package_order';
// 自动写入时间戳
protected $autoWriteTimestamp = true;
protected $createTime = 'createTime';
protected $updateTime = 'updateTime';
// 类型转换
protected $type = [
'id' => 'integer',
'userId' => 'integer',
'packageId' => 'integer',
'amount' => 'float',
'duration' => 'integer',
'createTime' => 'timestamp',
'updateTime' => 'timestamp',
'payTime' => 'timestamp',
'status' => 'integer',
'payStatus' => 'integer',
'isDel' => 'integer',
];
/**
* 生成订单号
* 规则：LL + 年月日时分秒 + 5位随机数
*
* @return string
*/
public static function generateOrderNo()
{
$prefix = 'LL';
$date = date('YmdHis');
$random = mt_rand(10000, 99999);
return $prefix . $date . $random;
}
/**
* 创建订单
*
* @param int $userId 用户ID
* @param int $packageId 套餐ID
* @param string $packageName 套餐名称
* @param float $amount 订单金额
* @param int $duration 购买时长(月)
* @param string $payType 支付类型 (wechat|alipay|nopay)
* @param string $remark 备注
* @return array|false
*/
public static function createOrder($userId, $packageId, $packageName, $amount, $duration, $payType = 'wechat', $remark = '')
{
// 生成订单号
$orderNo = self::generateOrderNo();
// 订单数据
$data = [
'userId' => $userId,
'packageId' => $packageId,
'packageName' => $packageName,
'orderNo' => $orderNo,
'amount' => $amount,
'duration' => $duration,
'payType' => $payType,
'createTime' => time(),
'status' => 0, // 0:待支付 1:已完成 2:已取消 3:已退款
'payStatus' => $payType == 'nopay' ? 10 : 0, // 0:未支付 1:已支付 10:无需支付
'remark' => $remark,
'isDel' => 0,
];
// 创建订单
$model = new self();
$result = $model->save($data);
if ($result) {
return $model->toArray();
} else {
return false;
}
}
}

0
application/store/model/TrafficOrderModel.php → application/store_old/model/TrafficOrderModel.php
View File

0
application/store/model/TrafficPackage.php → application/store_old/model/TrafficPackage.php
View File

0
application/store/model/TrafficPackageOrder.php → application/store_old/model/TrafficPackageOrder.php
View File

0
application/store/model/TrafficUsageLog.php → application/store_old/model/TrafficUsageLog.php
View File

103
application/store_old/model/UserFlowPackageModel.php Normal file
View File

@@ -0,0 +1,103 @@
<?php
namespace app\store\model;
use think\Model;
class UserFlowPackageModel extends Model
{
protected $name = 'user_flow_package';
/**
* 获取用户当前有效的流量套餐
*
* @param int $userId 用户ID
* @return array|null 用户套餐信息
*/
public static function getUserActivePackage($userId)
{
if (empty($userId)) {
return null;
}
return self::where('userId', $userId)
->where('status', 1) // 1表示有效
->where('expireTime', '>', time()) // 未过期
->order('expireTime', 'asc') // 按到期时间排序，最先到期的排在前面
->find();
}
/**
* 创建用户套餐订阅记录
*
* @param int $userId 用户ID
* @param int $packageId 套餐ID
* @param int $duration 套餐时长(月)
* @return bool 是否创建成功
*/
public static function createSubscription($userId, $packageId, $duration = 0)
{
if (empty($userId) || empty($packageId)) {
return false;
}
// 获取套餐信息
$package = FlowPackageModel::where('id', $packageId)->where('isDel', 0)->find();
if (empty($package)) {
return false;
}
// 如果未指定时长，则使用套餐默认时长
if (empty($duration)) {
$duration = $package['duration'];
}
// 计算开始时间和到期时间
$now = time();
$startTime = $now;
$expireTime = strtotime("+{$duration} month", $now);
// 创建新订阅
$data = [
'userId' => $userId,
'packageId' => $packageId,
'duration' => $duration,
'totalFlow' => $package->totalFlow,
'usedFlow' => 0,
'status' => 1, // 1表示有效
'startTime' => $startTime,
'expireTime' => $expireTime,
'createTime' => $now,
'updateTime' => $now
];
return self::create($data) ? true : false;
}
/**
* 更新用户已使用流量
*
* @param int $id 用户套餐ID
* @param int $usedFlow 已使用流量
* @return bool 是否更新成功
*/
public static function updateUsedFlow($id, $usedFlow)
{
if (empty($id)) {
return false;
}
$userPackage = self::where('id', $id)->find();
if (empty($userPackage)) {
return false;
}
// 确保使用量不超过总量
$maxFlow = $userPackage['totalFlow'];
$usedFlow = $usedFlow > $maxFlow ? $maxFlow : $usedFlow;
return self::where('id', $id)->update([
'usedFlow' => $usedFlow,
'updateTime' => time()
]) ? true : false;
}
}

Some files were not shown because too many files have changed in this diff Show More