Compare commits

...

23 Commits

Author SHA1 Message Date
q
1b357de2f3 Fixed 蓝奏优享解析,v019b21 2026-02-02 16:02:36 +08:00
q
cf76a5ddd6 fixed: 修复蓝奏优享 #159, #158 2026-02-02 15:59:44 +08:00
q
4e27bf0dc4 蓝奏云规则更新 2026-02-01 10:33:25 +08:00
qaiu
39c082e4ee Clean up launch configurations in launch.json,run AppMain
Removed unused Java launch configurations from launch.json.
2026-01-27 07:53:20 +08:00
qaiu
95193fc8f9 更新 README.md, 添加接口文档https://nfdparser.apifox.cn 2026-01-27 00:05:56 +08:00
qaiu
4f3131979f 189.qaiu.top 大文件解析体验版,支持天翼云盘,移动云盘等
#153 #156 #119 #92
2026-01-26 13:47:37 +08:00
qaiu
ad9a8ab0b0 更新 README.md
天翼云盘演示站限时体验
2026-01-26 13:09:49 +08:00
q
1f3161216a fix(LeTool): 修复子目录 fileId URL 编码问题
- 在构建 parserUrl 时对 fileId 进行 URL 编码
- 避免 %2B 等特殊字符被前端 axios 自动解码导致请求失败
- 添加异常处理和降级方案
2026-01-23 17:59:19 +08:00
q
e5f7b164a3 fix(LeTool): 修复联想乐云目录解析失败问题
- 添加统一的 HEADERS 定义,包含完整的浏览器请求头
- 修复 API_URL_PREFIX 路径(share -> mshare)
- 添加 getCleanShareId() 方法处理 URL 中的查询参数
- 所有请求统一使用 putHeaders(HEADERS)
- 增加调试日志输出
2026-01-23 13:24:11 +08:00
q
7974c92382 联想乐云文件夹解析 2026-01-23 12:45:51 +08:00
qaiu
b51add45f1 LeTool乐云目录解析 2026-01-23 03:26:35 +08:00
qaiu
cb132359fd 启用在线脚本解析器 2026-01-06 02:21:19 +08:00
q
b58b3658b5 更新Playground和JsHttpClient相关功能,整理文档结构 2026-01-06 00:00:37 +08:00
q
9f25aca242 Merge branch 'main' of github.com:qaiu/netdisk-fast-download 2026-01-04 09:30:54 +08:00
q
343c017c79 fixed. 演练场静态打包问题 2026-01-04 09:29:20 +08:00
qaiu
83af09cf58 升级前端版本 2026-01-04 01:14:26 +08:00
qaiu
449475785f Update README.md 2026-01-03 21:20:54 +08:00
q
047a8eab89 更新代码和文档 2026-01-03 21:11:04 +08:00
q
93835bd990 Add functional test report
- Document all completed tests and fixes
- Verify BUG1, BUG2, BUG3 fixes
- Confirm TypeScript removal
- Confirm text updates (JS演练场 → 脚本演练场)
- Service startup verification
2026-01-02 19:40:26 +08:00
q
93ab3f3f3f Remove TypeScript-related code and documentation
- Remove TypeScript API endpoints from PlaygroundApi
- Remove TypeScript methods from DbService interface and implementation
- Delete PlaygroundTypeScriptCode model class
- Delete TypeScript documentation files
- Clean up unused imports
2026-01-02 19:27:21 +08:00
q
de7703be83 Merge branch 'copilot/add-playground-enhancements' 2026-01-02 19:25:05 +08:00
qaiu
c60d9fdd61 更新 README.md 2025-12-23 07:55:59 +08:00
qaiu
2033542f49 更新 README.md 2025-12-08 23:46:58 +08:00
46 changed files with 2774 additions and 2341 deletions

17
.github/dependabot.yml vendored Normal file
View File

@@ -0,0 +1,17 @@
version: 2
updates:
- package-ecosystem: "maven"
directory: "/"
open-pull-requests-limit: 10
ignore:
# 忽略通过 BOM 管理的 Vert.x 依赖
# 这些依赖的版本通过 vertx-dependencies BOM 统一管理
# 应该通过更新 pom.xml 中的 vertx.version 属性来更新这些依赖
- dependency-name: "io.vertx:vertx-web"
- dependency-name: "io.vertx:vertx-codegen"
- dependency-name: "io.vertx:vertx-config"
- dependency-name: "io.vertx:vertx-config-yaml"
- dependency-name: "io.vertx:vertx-service-proxy"
- dependency-name: "io.vertx:vertx-web-proxy"
- dependency-name: "io.vertx:vertx-web-client"

2
.gitignore vendored
View File

@@ -29,6 +29,8 @@ target/
/src/logs/
*.zip
sdkTest.log
app.yml
app-local.yml
#some local files

52
.vscode/launch.json vendored
View File

@@ -1,7 +1,4 @@
{
// 使用 IntelliSense 了解相关属性。
// 悬停以查看现有属性的描述。
// 欲了解更多信息,请访问: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
@@ -10,61 +7,12 @@
"request": "launch",
"mainClass": "${file}"
},
{
"type": "java",
"name": "StringCase",
"request": "launch",
"mainClass": "cn.qaiu.vx.core.util.StringCase",
"projectName": "core"
},
{
"type": "java",
"name": "FCURLParser",
"request": "launch",
"mainClass": "cn.qaiu.parser.FCURLParser",
"projectName": "parser"
},
{
"type": "java",
"name": "QkTool",
"request": "launch",
"mainClass": "cn.qaiu.parser.impl.QkTool",
"projectName": "parser"
},
{
"type": "java",
"name": "WebClientExample",
"request": "launch",
"mainClass": "qaiu.web.test.WebClientExample",
"projectName": "parser"
},
{
"type": "java",
"name": "AppMain",
"request": "launch",
"mainClass": "cn.qaiu.lz.AppMain",
"projectName": "web-service"
},
{
"type": "java",
"name": "TestJs",
"request": "launch",
"mainClass": "cn.qaiu.web.test.TestJs",
"projectName": "web-service"
},
{
"type": "java",
"name": "TestOS",
"request": "launch",
"mainClass": "cn.qaiu.web.test.TestOS",
"projectName": "web-service"
},
{
"type": "java",
"name": "WebProxyExamples",
"request": "launch",
"mainClass": "cn.qaiu.web.test.WebProxyExamples",
"projectName": "web-service"
}
]
}

View File

@@ -14,7 +14,7 @@
# netdisk-fast-download 网盘分享链接云解析服务
QQ群1017480890
QQ交流1017480890
netdisk-fast-download网盘直链云解析(nfd云解析)能把网盘分享下载链接转化为直链,支持多款云盘,已支持蓝奏云/蓝奏云优享/奶牛快传/移动云云空间/小飞机盘/亿方云/123云盘/Cloudreve等支持加密分享以及部分网盘文件夹分享。
@@ -44,8 +44,8 @@ https://nfd-parser.github.io/nfd-preview/preview.html?src=https%3A%2F%2Flz.qaiu.
## 预览地址
[预览地址1](https://lz.qaiu.top)
[预览地址2](https://lzzz.qaiu.top)
[移动/联通/天翼云盘大文件试用](https://189.qaiu.top)
[预览地址2](https://lz0.qaiu.top)
[天翼云盘/移动云盘限时体验](https://189.qaiu.top)
main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/netdisk-fast-download/tree/main-jdk11)
**0.1.8及以上版本json接口格式有调整 参考json返回数据格式示例**
@@ -61,7 +61,7 @@ main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/
- [蓝奏云-lz](https://pc.woozooo.com/)
- [蓝奏云优享-iz](https://www.ilanzou.com/)
- ~[奶牛快传-cow(即将停服)](https://cowtransfer.com/)~
- [奶牛快传-cow](https://cowtransfer.com/)
- [移动云云空间-ec](https://www.ecpan.cn/web)
- [小飞机网盘-fj](https://www.feijipan.com/)
- [亿方云-fc](https://www.fangcloud.com/)
@@ -95,6 +95,8 @@ main分支依赖JDK17, 提供了JDK11分支[main-jdk11](https://github.com/qaiu/
## API接口
[api接口文档](https://nfdparser.apifox.cn/)
### 服务端口
- **6400**: API 服务端口(建议使用 Nginx 代理)
- **6401**: 内置 Web 解析工具(个人使用可直接开放此端口)
@@ -473,10 +475,11 @@ Core模块集成Vert.x实现类似spring的注解式路由API
</p>
### 关于专属版
99元, 提供对小飞机,蓝奏优享大文件解析的支持, 提供天翼云盘,移动云盘,联通云盘的解析支持
199元, 包含部署服务, 需提供宝塔环境
提供功能定制开发, 添加以下任意一个联系方式详谈:
### 关于赞助定制专属版
1. 专属版提供对小飞机,蓝奏优享大文件解析的支持, 提供天翼云盘/移动云盘/联通云盘的解析支持
2. 可提供托管服务:包含部署服务和云服务器环境
3. 可提供功能定制开发
您可能需要提供一定的资金赞助支持定制专属版, 请添加以下任意一个联系方式详谈赞助模式:
<p>qq: 197575894</p>
<p>wechat: imcoding_</p>

View File

@@ -1,293 +0,0 @@
# TypeScript编译器集成 - 实现总结
## 概述
成功为JavaScript解析器演练场添加了完整的TypeScript支持。用户现在可以使用现代TypeScript语法编写解析器代码系统会自动编译为ES5并在后端执行。
## 实现范围
### ✅ 前端实现
1. **TypeScript编译器集成**
- 添加 `typescript` npm 包依赖
- 创建 `tsCompiler.js` 编译器工具类
- 支持所有标准 TypeScript 特性
- 编译目标ES5与后端Nashorn引擎兼容
2. **用户界面增强**
- 工具栏语言选择器JavaScript ⟷ TypeScript
- 实时编译错误提示
- TypeScript 示例模板(包含 async/await
- 语言偏好本地存储
3. **编译逻辑**
```
用户输入TS代码 → 自动编译为ES5 → 发送到后端执行
```
### ✅ 后端实现
1. **数据库模型**
- 新表:`playground_typescript_code`
- 存储原始 TypeScript 代码
- 存储编译后的 ES5 代码
- 通过 `parserId` 关联到 `playground_parser`
2. **API端点**
- `POST /v2/playground/typescript` - 保存TS代码
- `GET /v2/playground/typescript/:parserId` - 获取TS代码
- `PUT /v2/playground/typescript/:parserId` - 更新TS代码
3. **数据库服务**
- `DbService` 新增 TypeScript 相关方法
- `DbServiceImpl` 实现具体的数据库操作
- 支持自动建表
### ✅ 文档
1. **用户指南** (`TYPESCRIPT_PLAYGROUND_GUIDE.md`)
- 快速开始教程
- TypeScript 特性说明
- API 参考
- 最佳实践
- 故障排除
2. **代码示例**
- JavaScript 示例ES5
- TypeScript 示例(包含类型注解和 async/await
## 架构设计
```
┌─────────────────────────────────────────────┐
│ 浏览器前端 (Vue 3) │
├─────────────────────────────────────────────┤
│ 1. 用户编写 TypeScript 代码 │
│ 2. TypeScript 编译器编译为 ES5 │
│ 3. 显示编译错误(如有) │
│ 4. 发送 ES5 代码到后端 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 后端服务器 (Java + Vert.x) │
├─────────────────────────────────────────────┤
│ 1. 接收 ES5 代码 │
│ 2. 注入 fetch-runtime.js (已实现) │
│ 3. Nashorn 引擎执行 │
│ 4. 返回执行结果 │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ 数据库 (SQLite) │
├─────────────────────────────────────────────┤
│ playground_parser (ES5代码) │
│ playground_typescript_code (TS源代码) │
└─────────────────────────────────────────────┘
```
## 技术细节
### TypeScript 编译配置
```javascript
{
target: 'ES5', // 目标ES5Nashorn兼容
module: 'None', // 不使用模块系统
noEmitOnError: true, // 有错误时不生成代码
downlevelIteration: true, // 支持迭代器降级
esModuleInterop: true, // ES模块互操作
lib: ['es5', 'dom'] // 类型库
}
```
### 支持的 TypeScript 特性
- ✅ 类型注解 (Type Annotations)
- ✅ 接口 (Interfaces)
- ✅ 类型别名 (Type Aliases)
- ✅ 枚举 (Enums)
- ✅ 泛型 (Generics)
- ✅ async/await → Promise 转换
- ✅ 箭头函数
- ✅ 模板字符串
- ✅ 解构赋值
- ✅ 可选链 (Optional Chaining)
- ✅ 空值合并 (Nullish Coalescing)
### 代码示例对比
#### 输入 (TypeScript)
```typescript
async function parse(
shareLinkInfo: any,
http: any,
logger: any
): Promise<string> {
const url: string = shareLinkInfo.getShareUrl();
logger.info(`开始解析: ${url}`);
const response = await fetch(url);
const html: string = await response.text();
return html.match(/url="([^"]+)"/)?.[1] || "";
}
```
#### 输出 (ES5)
```javascript
function parse(shareLinkInfo, http, logger) {
return __awaiter(this, void 0, void 0, function () {
var url, response, html, _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
url = shareLinkInfo.getShareUrl();
logger.info("开始解析: " + url);
return [4, fetch(url)];
case 1:
response = _b.sent();
return [4, response.text()];
case 2:
html = _b.sent();
return [2, ((_a = html.match(/url="([^"]+)"/)) === null || _a === void 0 ? void 0 : _a[1]) || ""];
}
});
});
}
```
## 代码质量改进
基于代码审查反馈,进行了以下改进:
1. **编译器配置优化**
- ✅ `noEmitOnError: true` - 防止执行有错误的代码
2. **代码可维护性**
- ✅ 使用常量替代魔术字符串
- ✅ 添加 `LANGUAGE` 常量对象
3. **用户体验优化**
- ✅ 优先使用显式语言选择
- ✅ TypeScript语法检测作为辅助提示
- ✅ 清晰的错误消息
4. **代码清理**
- ✅ 移除无关的生成文件
## 测试结果
### 构建测试
- ✅ Maven 编译:成功
- ✅ npm 构建:成功(预期的大小警告)
- ✅ TypeScript 编译:正常工作
- ✅ 数据库模型:有效
### 功能测试(需手动验证)
- [ ] UI 语言选择器
- [ ] TypeScript 编译
- [ ] 数据库表自动创建
- [ ] API 端点
- [ ] 发布工作流TS → 数据库 → ES5执行
- [ ] 错误处理
## 安全性
- ✅ 输入验证代码长度限制128KB
- ✅ SQL注入防护参数化查询
- ✅ IP日志记录审计追踪
- ✅ 继承现有SSRF防护
- ✅ 无新安全漏洞
## 数据库结构
### playground_typescript_code 表
| 字段 | 类型 | 说明 |
|------|------|------|
| id | BIGINT | 主键 |
| parser_id | BIGINT | 关联解析器ID外键 |
| ts_code | TEXT | TypeScript源代码 |
| es5_code | TEXT | 编译后ES5代码 |
| compile_errors | VARCHAR(2000) | 编译错误 |
| compiler_version | VARCHAR(32) | 编译器版本 |
| compile_options | VARCHAR(1000) | 编译选项JSON |
| create_time | DATETIME | 创建时间 |
| update_time | DATETIME | 更新时间 |
| is_valid | BOOLEAN | 编译是否成功 |
| ip | VARCHAR(64) | 创建者IP |
### 关系
- `playground_typescript_code.parser_id` → `playground_parser.id` (外键)
- 一对一关系一个解析器对应一个TypeScript代码记录
## 文件清单
### 新增文件 (3)
1. `web-front/src/utils/tsCompiler.js` - TS编译器工具
2. `web-service/src/main/java/cn/qaiu/lz/web/model/PlaygroundTypeScriptCode.java` - 数据模型
3. `parser/doc/TYPESCRIPT_PLAYGROUND_GUIDE.md` - 用户文档
### 修改文件 (5)
1. `web-front/package.json` - 添加typescript依赖
2. `web-front/src/views/Playground.vue` - UI和编译逻辑
3. `web-front/src/utils/playgroundApi.js` - TS API方法
4. `web-service/src/main/java/cn/qaiu/lz/web/service/DbService.java` - 接口定义
5. `web-service/src/main/java/cn/qaiu/lz/web/service/impl/DbServiceImpl.java` - 实现
6. `web-service/src/main/java/cn/qaiu/lz/web/controller/PlaygroundApi.java` - API端点
## 未来改进计划
- [ ] 显示编译后的ES5代码预览
- [ ] 添加专用的编译错误面板
- [ ] 提供完整的TypeScript类型定义文件.d.ts
- [ ] 支持代码自动补全
- [ ] TypeScript代码片段库
- [ ] 更多编译选项配置
## 使用方法
### 快速开始
1. **选择语言**
- 点击工具栏中的"TypeScript"按钮
2. **编写代码**
- 点击"加载示例"查看TypeScript示例
- 编写自己的TypeScript代码
3. **运行测试**
- 点击"运行"按钮
- 查看编译结果和执行结果
4. **发布脚本**
- 测试通过后点击"发布脚本"
- 系统自动保存TS源码和ES5编译结果
## 兼容性
- ✅ 与现有JavaScript功能完全兼容
- ✅ 不影响现有解析器
- ✅ 向后兼容
- ✅ 无破坏性更改
## 性能
- **编译时间**:几毫秒到几百毫秒(取决于代码大小)
- **运行时开销**:无(编译在前端完成)
- **存储开销**额外存储TypeScript源码TEXT类型
## 总结
成功实现了完整的TypeScript支持包括
- ✅ 前端编译器集成
- ✅ 后端数据存储
- ✅ API端点
- ✅ 用户界面
- ✅ 完整文档
- ✅ 代码质量优化
- ✅ 安全验证
**状态:生产就绪 ✅**
该功能已经过全面测试,所有代码审查问题已解决,可以安全地部署到生产环境。

View File

@@ -23,6 +23,8 @@ import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.*;
import io.vertx.ext.web.handler.sockjs.SockJSHandler;
import io.vertx.ext.web.handler.sockjs.SockJSHandlerOptions;
import io.vertx.ext.web.sstore.LocalSessionStore;
import io.vertx.ext.web.sstore.SessionStore;
import javassist.CtClass;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.Pair;
@@ -98,6 +100,16 @@ public class RouterHandlerFactory implements BaseHttpApi {
// 配置文件上传路径
mainRouter.route().handler(BodyHandler.create().setUploadsDirectory("uploads"));
// 配置Session管理 - 用于演练场登录状态持久化
// 30天过期时间毫秒
SessionStore sessionStore = LocalSessionStore.create(VertxHolder.getVertxInstance());
SessionHandler sessionHandler = SessionHandler.create(sessionStore)
.setSessionTimeout(30L * 24 * 60 * 60 * 1000) // 30天
.setSessionCookieName("SESSIONID") // Cookie名称
.setCookieHttpOnlyFlag(true) // 防止XSS攻击
.setCookieSecureFlag(false); // 非HTTPS环境设置为false
mainRouter.route().handler(sessionHandler);
// 拦截器
Set<Handler<RoutingContext>> interceptorSet = getInterceptorSet();
Route route0 = mainRouter.route("/*");

View File

@@ -128,7 +128,9 @@ public class ReverseProxyVerticle extends AbstractVerticle {
}
private HttpServer getHttpsServer(JsonObject proxyConf) {
HttpServerOptions httpServerOptions = new HttpServerOptions();
HttpServerOptions httpServerOptions = new HttpServerOptions()
.setCompressionSupported(true);
if (proxyConf.containsKey("ssl")) {
JsonObject sslConfig = proxyConf.getJsonObject("ssl");
@@ -182,6 +184,7 @@ public class ReverseProxyVerticle extends AbstractVerticle {
} else {
staticHandler = StaticHandler.create();
}
if (staticConf.containsKey("directory-listing")) {
staticHandler.setDirectoryListing(staticConf.getBoolean("directory-listing"));
} else if (staticConf.containsKey("index")) {

View File

@@ -1,378 +0,0 @@
# TypeScript/ES6+ 浏览器编译与Fetch API实现
## 项目概述
本实现提供了**纯前端TypeScript编译 + 后端ES5引擎 + Fetch API适配**的完整解决方案允许用户在浏览器中编写TypeScript/ES6+代码包括async/await编译为ES5后在后端Nashorn JavaScript引擎中执行。
## 架构图
```
┌─────────────────────────────────────────────────────────┐
│ 浏览器端 (计划中) │
├─────────────────────────────────────────────────────────┤
│ 用户编写 TypeScript/ES6+ 代码 (async/await) │
│ ↓ │
│ TypeScript.js 浏览器内编译为 ES5 │
│ ↓ │
│ 生成的 ES5 代码发送到后端 │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ 后端 (已实现) │
├─────────────────────────────────────────────────────────┤
│ 1. 接收 ES5 代码 │
│ 2. 注入 fetch-runtime.js (Promise + fetch polyfill) │
│ 3. 注入 JavaFetch 桥接对象 │
│ 4. Nashorn 引擎执行 ES5 代码 │
│ 5. fetch() → JavaFetch → JsHttpClient → Vert.x │
└─────────────────────────────────────────────────────────┘
```
## 已实现功能
### ✅ 后端 ES5 执行环境
#### 1. Promise Polyfill (完整的 Promise/A+ 实现)
文件: `parser/src/main/resources/fetch-runtime.js`
**功能特性:**
-`new Promise(executor)` 构造函数
-`promise.then(onFulfilled, onRejected)` 链式调用
-`promise.catch(onRejected)` 错误处理
-`promise.finally(onFinally)` 清理操作
-`Promise.resolve(value)` 静态方法
-`Promise.reject(reason)` 静态方法
-`Promise.all(promises)` 并行等待
-`Promise.race(promises)` 竞速等待
**实现细节:**
- 纯 ES5 语法无ES6+特性依赖
- 使用 `setTimeout(fn, 0)` 实现异步执行
- 支持 Promise 链式调用和错误传播
- 自动处理 Promise 嵌套和展开
#### 2. Fetch API Polyfill (标准 fetch 接口)
文件: `parser/src/main/resources/fetch-runtime.js`
**支持的 HTTP 方法:**
- ✅ GET
- ✅ POST
- ✅ PUT
- ✅ DELETE
- ✅ PATCH
- ✅ HEAD
**Request 选项支持:**
```javascript
fetch(url, {
method: 'POST', // HTTP 方法
headers: { // 请求头
'Content-Type': 'application/json',
'Authorization': 'Bearer token'
},
body: JSON.stringify({ // 请求体
key: 'value'
})
})
```
**Response 对象方法:**
-`response.text()` - 获取文本响应 (返回 Promise)
-`response.json()` - 解析 JSON 响应 (返回 Promise)
-`response.arrayBuffer()` - 获取字节数组
-`response.status` - HTTP 状态码
-`response.ok` - 请求是否成功 (2xx)
-`response.statusText` - 状态文本
-`response.headers.get(name)` - 获取响应头
#### 3. Java 桥接层
文件: `parser/src/main/java/cn/qaiu/parser/customjs/JsFetchBridge.java`
**核心功能:**
- 接收 JavaScript fetch API 调用
- 转换为 JsHttpClient 调用
- 处理请求头、请求体、HTTP 方法
- 返回 JsHttpResponse 对象
- 自动继承现有的 SSRF 防护机制
**代码示例:**
```java
public class JsFetchBridge {
private final JsHttpClient httpClient;
public JsHttpResponse fetch(String url, Map<String, Object> options) {
// 解析 method、headers、body
// 调用 httpClient.get/post/put/delete/patch
// 返回 JsHttpResponse
}
}
```
#### 4. 自动注入机制
文件:
- `parser/src/main/java/cn/qaiu/parser/customjs/JsParserExecutor.java`
- `parser/src/main/java/cn/qaiu/parser/customjs/JsPlaygroundExecutor.java`
**注入流程:**
1. 创建 JavaScript 引擎
2. 注入 JavaFetch 桥接对象
3. 加载 fetch-runtime.js
4. 执行用户 JavaScript 代码
**代码示例:**
```java
// 注入 JavaFetch
engine.put("JavaFetch", new JsFetchBridge(httpClient));
// 加载 fetch runtime
String fetchRuntime = loadFetchRuntime();
engine.eval(fetchRuntime);
// 现在 JavaScript 环境中可以使用 Promise 和 fetch
```
## 使用示例
### ES5 风格 (当前可用)
```javascript
function parse(shareLinkInfo, http, logger) {
logger.info("开始解析");
// 使用 fetch API
fetch("https://api.example.com/data")
.then(function(response) {
logger.info("状态码: " + response.status);
return response.json();
})
.then(function(data) {
logger.info("数据: " + JSON.stringify(data));
return data.downloadUrl;
})
.catch(function(error) {
logger.error("错误: " + error.message);
throw error;
});
// 或者继续使用传统的 http 对象
var response = http.get("https://api.example.com/data");
return response.body();
}
```
### TypeScript/ES6+ 风格 (需前端编译)
用户在浏览器中编写:
```typescript
async function parse(
shareLinkInfo: ShareLinkInfo,
http: JsHttpClient,
logger: JsLogger
): Promise<string> {
try {
logger.info("开始解析");
// 使用标准 fetch API
const response = await fetch("https://api.example.com/data");
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
const data = await response.json();
logger.info(`下载链接: ${data.downloadUrl}`);
return data.downloadUrl;
} catch (error) {
logger.error(`解析失败: ${error.message}`);
throw error;
}
}
```
浏览器编译为 ES5 后:
```javascript
function parse(shareLinkInfo, http, logger) {
return __awaiter(this, void 0, void 0, function() {
var response, data, error_1;
return __generator(this, function(_a) {
switch(_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
logger.info("开始解析");
return [4, fetch("https://api.example.com/data")];
case 1:
response = _a.sent();
if (!response.ok) {
throw new Error("HTTP " + response.status + ": " + response.statusText);
}
return [4, response.json()];
case 2:
data = _a.sent();
logger.info("下载链接: " + data.downloadUrl);
return [2, data.downloadUrl];
case 3:
error_1 = _a.sent();
logger.error("解析失败: " + error_1.message);
throw error_1;
case 4: return [2];
}
});
});
}
```
## 文件结构
```
parser/
├── src/main/
│ ├── java/cn/qaiu/parser/customjs/
│ │ ├── JsFetchBridge.java # Java 桥接层
│ │ ├── JsParserExecutor.java # 解析器执行器 (已更新)
│ │ └── JsPlaygroundExecutor.java # 演练场执行器 (已更新)
│ └── resources/
│ ├── fetch-runtime.js # Promise + fetch polyfill
│ └── custom-parsers/
│ └── fetch-demo.js # Fetch 示例解析器
├── src/test/java/cn/qaiu/parser/customjs/
│ └── JsFetchBridgeTest.java # 单元测试
└── doc/
└── TYPESCRIPT_FETCH_GUIDE.md # 详细使用指南
```
## 测试验证
### 运行测试
```bash
# 编译项目
mvn clean compile -pl parser
# 运行所有测试
mvn test -pl parser
# 运行 fetch 测试
mvn test -pl parser -Dtest=JsFetchBridgeTest
```
### 测试内容
文件: `parser/src/test/java/cn/qaiu/parser/customjs/JsFetchBridgeTest.java`
1. **testFetchPolyfillLoaded** - 验证 Promise 和 fetch 是否正确注入
2. **testPromiseBasicUsage** - 验证 Promise 基本功能
3. **示例解析器** - `fetch-demo.js` 展示完整用法
## 兼容性说明
### 支持的特性
- ✅ Promise/A+ 完整实现
- ✅ Fetch API 标准接口
- ✅ async/await (通过 TypeScript 编译)
- ✅ 所有 HTTP 方法
- ✅ Request headers 和 body
- ✅ Response 解析 (text, json, arrayBuffer)
- ✅ 错误处理和 Promise 链
- ✅ 与现有 http 对象共存
### 不支持的特性
- ❌ Blob 对象 (使用 arrayBuffer 替代)
- ❌ FormData 对象 (使用简单对象替代)
- ❌ Request/Response 构造函数
- ❌ Streams API
- ❌ Service Worker 相关 API
- ❌ AbortController (取消请求)
## 安全性
### SSRF 防护
继承自 `JsHttpClient` 的 SSRF 防护:
- ✅ 拦截内网 IP (127.0.0.1, 10.x.x.x, 192.168.x.x 等)
- ✅ 拦截云服务元数据 API (169.254.169.254 等)
- ✅ DNS 解析检查
- ✅ 危险域名黑名单
### 沙箱隔离
- ✅ SecurityClassFilter 限制类访问
- ✅ 禁用 Java 对象直接访问
- ✅ 限制文件系统操作
## 性能优化
1. **Fetch runtime 缓存**
- 首次加载后缓存在静态变量
- 避免重复读取文件
2. **Promise 异步执行**
- 使用 setTimeout(0) 实现非阻塞
- 避免阻塞 JavaScript 主线程
3. **工作线程池**
- JsParserExecutor: Vert.x 工作线程池
- JsPlaygroundExecutor: 独立线程池
- 避免阻塞 Event Loop
## 前端 TypeScript 编译 (计划中)
### 待实现步骤
1. **添加 TypeScript 编译器**
```bash
cd web-front
npm install typescript
```
2. **创建编译工具**
```javascript
// web-front/src/utils/tsCompiler.js
import * as ts from 'typescript';
export function compileToES5(sourceCode) {
return ts.transpileModule(sourceCode, {
compilerOptions: {
target: ts.ScriptTarget.ES5,
module: ts.ModuleKind.None,
lib: ['es5', 'dom']
}
});
}
```
3. **更新 Playground UI**
- 添加语言选择器 (JavaScript / TypeScript)
- 编译前先检查语法错误
- 显示编译后的 ES5 代码 (可选)
## 相关文档
- [详细使用指南](parser/doc/TYPESCRIPT_FETCH_GUIDE.md)
- [JavaScript 解析器开发指南](parser/doc/JAVASCRIPT_PARSER_GUIDE.md)
- [自定义解析器扩展指南](parser/doc/CUSTOM_PARSER_GUIDE.md)
## 总结
本实现成功提供了:
1. **无需 Node 环境** - 纯浏览器编译 + Java 后端执行
2. **标准 API** - 使用标准 fetch 和 Promise API
3. **向后兼容** - 现有 http 对象仍然可用
4. **安全可靠** - SSRF 防护和沙箱隔离
5. **易于使用** - 简单的 API无学习成本
用户可以用现代 JavaScript/TypeScript 编写代码,自动编译为 ES5 后在后端安全执行,同时享受 fetch API 的便利性。
## 许可证
本项目遵循主项目的许可证。

View File

@@ -1,451 +0,0 @@
# 浏览器TypeScript编译和Fetch API支持指南
## 概述
本项目实现了**纯前端TypeScript编译 + 后端ES5引擎 + Fetch API适配**的完整方案允许用户在浏览器中编写TypeScript/ES6+代码编译为ES5后在后端JavaScript引擎中执行。
## 架构设计
### 1. 浏览器端(前端编译)
```
用户编写TS/ES6+代码
TypeScript.js (浏览器内编译)
ES5 JavaScript代码
发送到后端执行
```
### 2. 后端ES5执行环境
```
接收ES5代码
注入fetch polyfill + Promise
注入JavaFetch桥接对象
Nashorn引擎执行ES5代码
fetch() 调用 → JavaFetch → JsHttpClient → Vert.x HTTP Client
```
## 已实现的功能
### ✅ 后端支持
1. **Promise Polyfill** (`fetch-runtime.js`)
- 完整的Promise/A+实现
- 支持 `then``catch``finally`
- 支持 `Promise.all``Promise.race`
- 支持 `Promise.resolve``Promise.reject`
2. **Fetch API Polyfill** (`fetch-runtime.js`)
- 标准fetch接口实现
- 支持所有HTTP方法GET、POST、PUT、DELETE、PATCH
- 支持headers、body等选项
- Response对象支持
- `text()` - 获取文本响应
- `json()` - 解析JSON响应
- `arrayBuffer()` - 获取字节数组
- `status` - HTTP状态码
- `ok` - 请求成功标志
- `headers` - 响应头访问
3. **Java桥接** (`JsFetchBridge.java`)
- 将fetch调用转换为JsHttpClient调用
- 自动处理请求头、请求体
- 支持代理配置
- 安全的SSRF防护
4. **自动注入** (`JsParserExecutor.java` & `JsPlaygroundExecutor.java`)
- 在JavaScript引擎初始化时自动注入fetch runtime
- 提供`JavaFetch`全局对象
- 与现有http对象共存
## 使用示例
### ES5风格当前支持
```javascript
function parse(shareLinkInfo, http, logger) {
// 使用fetch API
fetch("https://api.example.com/data")
.then(function(response) {
return response.json();
})
.then(function(data) {
logger.info("数据: " + JSON.stringify(data));
})
.catch(function(error) {
logger.error("错误: " + error.message);
});
// 或者使用传统的http对象
var response = http.get("https://api.example.com/data");
return response.body();
}
```
### TypeScript风格需要前端编译
用户在浏览器中编写:
```typescript
async function parse(shareLinkInfo: ShareLinkInfo, http: JsHttpClient, logger: JsLogger): Promise<string> {
try {
// 使用标准fetch API
const response = await fetch("https://api.example.com/data");
const data = await response.json();
logger.info(`获取到数据: ${data.downloadUrl}`);
return data.downloadUrl;
} catch (error) {
logger.error(`解析失败: ${error.message}`);
throw error;
}
}
```
浏览器内编译后的ES5代码简化示例
```javascript
function parse(shareLinkInfo, http, logger) {
return __awaiter(this, void 0, void 0, function() {
var response, data;
return __generator(this, function(_a) {
switch(_a.label) {
case 0:
return [4, fetch("https://api.example.com/data")];
case 1:
response = _a.sent();
return [4, response.json()];
case 2:
data = _a.sent();
logger.info("获取到数据: " + data.downloadUrl);
return [2, data.downloadUrl];
}
});
});
}
```
## 前端TypeScript编译待实现
### 计划实现步骤
#### 1. 添加TypeScript编译器
在前端项目中添加`typescript.js`
```bash
# 下载TypeScript编译器浏览器版本
cd webroot/static
wget https://cdn.jsdelivr.net/npm/typescript@latest/lib/typescript.js
```
或者在Vue项目中
```bash
npm install typescript
```
#### 2. 创建编译工具类
`web-front/src/utils/tsCompiler.js`:
```javascript
import * as ts from 'typescript';
export function compileToES5(sourceCode, fileName = 'script.ts') {
const result = ts.transpileModule(sourceCode, {
compilerOptions: {
target: ts.ScriptTarget.ES5,
module: ts.ModuleKind.None,
lib: ['es5', 'dom'],
experimentalDecorators: false,
emitDecoratorMetadata: false,
downlevelIteration: true
},
fileName: fileName
});
return {
js: result.outputText,
diagnostics: result.diagnostics,
sourceMap: result.sourceMapText
};
}
```
#### 3. 更新Playground组件
`Playground.vue`中添加编译选项:
```vue
<template>
<div>
<!-- 语言选择 -->
<el-radio-group v-model="language">
<el-radio label="javascript">JavaScript (ES5)</el-radio>
<el-radio label="typescript">TypeScript/ES6+</el-radio>
</el-radio-group>
<!-- 编辑器 -->
<monaco-editor
v-model="code"
:language="language"
@save="handleSave"
/>
<!-- 运行按钮 -->
<el-button @click="executeCode">运行</el-button>
</div>
</template>
<script>
import { compileToES5 } from '@/utils/tsCompiler';
export default {
data() {
return {
language: 'javascript',
code: ''
};
},
methods: {
async executeCode() {
let codeToExecute = this.code;
// 如果是TypeScript先编译
if (this.language === 'typescript') {
const result = compileToES5(this.code);
if (result.diagnostics && result.diagnostics.length > 0) {
this.$message.error('TypeScript编译错误');
console.error(result.diagnostics);
return;
}
codeToExecute = result.js;
console.log('编译后的ES5代码:', codeToExecute);
}
// 发送到后端执行
const response = await playgroundApi.testScript(
codeToExecute,
this.shareUrl,
this.pwd,
this.method
);
this.showResult(response);
}
}
};
</script>
```
## Fetch Runtime详解
### Promise实现特性
```javascript
// 基本用法
var promise = new SimplePromise(function(resolve, reject) {
setTimeout(function() {
resolve("成功");
}, 1000);
});
promise.then(function(value) {
console.log(value); // "成功"
});
// 链式调用
promise
.then(function(value) {
return value + " - 第一步";
})
.then(function(value) {
return value + " - 第二步";
})
.catch(function(error) {
console.error(error);
})
.finally(function() {
console.log("完成");
});
```
### Fetch API特性
```javascript
// GET请求
fetch("https://api.example.com/data")
.then(function(response) {
console.log("状态码:", response.status);
console.log("成功:", response.ok);
return response.json();
})
.then(function(data) {
console.log("数据:", data);
});
// POST请求
fetch("https://api.example.com/submit", {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({ key: "value" })
})
.then(function(response) {
return response.json();
})
.then(function(data) {
console.log("响应:", data);
});
```
## 兼容性说明
### 支持的特性
- ✅ Promise/A+ 完整实现
- ✅ Fetch API 标准接口
- ✅ async/await编译后
- ✅ 所有HTTP方法GET、POST、PUT、DELETE、PATCH
- ✅ Request headers配置
- ✅ Request bodystring、JSON、FormData
- ✅ Response.text()、Response.json()
- ✅ 与现有http对象共存
### 不支持的特性
- ❌ Blob对象返回字节数组替代
- ❌ FormData对象使用简单对象替代
- ❌ Request/Response对象构造函数
- ❌ Streams API
- ❌ Service Worker相关API
## 测试验证
### 1. 创建测试解析器
参考 `parser/src/main/resources/custom-parsers/fetch-demo.js`
### 2. 测试步骤
```bash
# 1. 编译项目
mvn clean package -DskipTests
# 2. 运行服务
java -jar web-service/target/netdisk-fast-download.jar
# 3. 访问演练场
浏览器打开: http://localhost:6401/playground
# 4. 加载fetch-demo.js并测试
```
### 3. 验证fetch功能
在演练场中运行:
```javascript
function parse(shareLinkInfo, http, logger) {
logger.info("测试fetch API");
var result = null;
fetch("https://httpbin.org/get")
.then(function(response) {
logger.info("状态码: " + response.status);
return response.json();
})
.then(function(data) {
logger.info("响应: " + JSON.stringify(data));
result = "SUCCESS";
})
.catch(function(error) {
logger.error("错误: " + error.message);
});
// 等待完成
var timeout = 5000;
var start = Date.now();
while (result === null && (Date.now() - start) < timeout) {
java.lang.Thread.sleep(10);
}
return result || "https://example.com/download";
}
```
## 安全性
### SSRF防护
JsHttpClient已实现SSRF防护
- 拦截内网IP访问127.0.0.1、10.x.x.x、192.168.x.x等
- 拦截云服务元数据API169.254.169.254等)
- DNS解析检查
### 沙箱隔离
- JavaScript引擎使用SecurityClassFilter
- 禁用Java对象访问
- 限制文件系统访问
## 性能优化
1. **Fetch runtime缓存**
- 首次加载后缓存在静态变量中
- 避免重复读取资源文件
2. **Promise异步执行**
- 使用setTimeout(0)实现异步
- 避免阻塞主线程
3. **工作线程池**
- JsParserExecutor使用Vert.x工作线程池
- JsPlaygroundExecutor使用独立线程池
## 相关文件
### 后端代码
- `parser/src/main/resources/fetch-runtime.js` - Fetch和Promise polyfill
- `parser/src/main/java/cn/qaiu/parser/customjs/JsFetchBridge.java` - Java桥接层
- `parser/src/main/java/cn/qaiu/parser/customjs/JsParserExecutor.java` - 解析器执行器
- `parser/src/main/java/cn/qaiu/parser/customjs/JsPlaygroundExecutor.java` - 演练场执行器
### 示例代码
- `parser/src/main/resources/custom-parsers/fetch-demo.js` - Fetch API演示
### 前端代码(待实现)
- `web-front/src/utils/tsCompiler.js` - TypeScript编译工具
- `web-front/src/views/Playground.vue` - 演练场界面
## 下一步计划
1. ✅ 实现后端fetch polyfill
2. ✅ 实现Promise polyfill
3. ✅ 集成到JsParserExecutor
4. ⏳ 前端添加TypeScript编译器
5. ⏳ 更新Playground UI支持TS/ES6+
6. ⏳ 添加Monaco编辑器类型提示
7. ⏳ 编写更多示例和文档
## 总结
通过这个方案,我们实现了:
1. **无需Node环境** - 纯浏览器编译 + Java后端执行
2. **标准API** - 使用标准fetch和Promise API
3. **向后兼容** - 现有http对象仍然可用
4. **安全可靠** - SSRF防护和沙箱隔离
5. **易于使用** - 简单的API无需学习成本
用户可以在浏览器中用现代JavaScript/TypeScript编写代码自动编译为ES5后在后端安全执行同时享受fetch API的便利性。

View File

@@ -1,483 +0,0 @@
# TypeScript 支持文档
## 概述
演练场现在支持 TypeScript您可以使用现代 TypeScript 语法编写解析器代码,系统会自动将其编译为 ES5 并在后端执行。
## 功能特性
### 🎯 核心功能
-**TypeScript 编译器集成**:内置 TypeScript 编译器,实时将 TS 代码编译为 ES5
-**语言选择器**:在演练场工具栏轻松切换 JavaScript 和 TypeScript
-**编译错误提示**:友好的编译错误提示和建议
-**双代码存储**:同时保存原始 TypeScript 代码和编译后的 ES5 代码
-**无缝集成**:与现有演练场功能完全兼容
### 📝 TypeScript 特性支持
支持所有标准 TypeScript 特性,包括但不限于:
- 类型注解Type Annotations
- 接口Interfaces
- 类型别名Type Aliases
- 枚举Enums
- 泛型Generics
- async/await编译为 Promise
- 箭头函数
- 模板字符串
- 解构赋值
- 可选链Optional Chaining
- 空值合并Nullish Coalescing
## 快速开始
### 1. 选择语言
在演练场工具栏中,点击 **JavaScript****TypeScript** 按钮选择您要使用的语言。
### 2. 编写代码
选择 TypeScript 后,点击"加载示例"按钮可以加载 TypeScript 示例代码。
#### TypeScript 示例
```typescript
// ==UserScript==
// @name TypeScript示例解析器
// @type ts_example_parser
// @displayName TypeScript示例网盘
// @description 使用TypeScript实现的示例解析器
// @match https?://example\.com/s/(?<KEY>\w+)
// @author yourname
// @version 1.0.0
// ==/UserScript==
/**
* 解析单个文件下载链接
*/
async function parse(
shareLinkInfo: any,
http: any,
logger: any
): Promise<string> {
const url: string = shareLinkInfo.getShareUrl();
logger.info(`开始解析: ${url}`);
// 使用fetch API (已在后端实现polyfill)
try {
const response = await fetch(url);
if (!response.ok) {
throw new Error(`请求失败: ${response.status}`);
}
const html: string = await response.text();
// 解析逻辑
const match = html.match(/download-url="([^"]+)"/);
if (match) {
return match[1];
}
return "https://example.com/download/file.zip";
} catch (error: any) {
logger.error(`解析失败: ${error.message}`);
throw error;
}
}
```
### 3. 运行测试
点击"运行"按钮(或按 Ctrl+Enter。系统会
1. 自动检测代码是否为 TypeScript
2. 将 TypeScript 编译为 ES5
3. 显示编译结果(成功/失败)
4. 如果编译成功,使用 ES5 代码执行测试
5. 显示测试结果
### 4. 发布解析器
编译成功后,点击"发布脚本"即可保存解析器。系统会自动:
- 保存原始 TypeScript 代码到 `playground_typescript_code`
- 保存编译后的 ES5 代码到 `playground_parser`
- 通过 `parserId` 关联两者
## 编译选项
TypeScript 编译器使用以下配置:
```javascript
{
target: 'ES5', // 目标版本ES5
module: 'None', // 不使用模块系统
lib: ['es5', 'dom'], // 包含ES5和DOM类型定义
removeComments: false, // 保留注释
downlevelIteration: true, // 支持ES5迭代器降级
esModuleInterop: true // 启用ES模块互操作性
}
```
## 类型定义
### 可用的 API 对象
虽然 TypeScript 支持类型注解,但由于后端运行时环境的限制,建议使用 `any` 类型:
```typescript
function parse(
shareLinkInfo: any, // 分享链接信息
http: any, // HTTP客户端
logger: any // 日志对象
): Promise<string> {
// ...
}
```
### 常用方法
#### shareLinkInfo 对象
```typescript
shareLinkInfo.getShareUrl(): string // 获取分享URL
shareLinkInfo.getShareKey(): string // 获取分享Key
shareLinkInfo.getSharePassword(): string // 获取分享密码
shareLinkInfo.getOtherParam(key: string): any // 获取其他参数
```
#### logger 对象
```typescript
logger.info(message: string): void // 记录信息日志
logger.debug(message: string): void // 记录调试日志
logger.error(message: string): void // 记录错误日志
logger.warn(message: string): void // 记录警告日志
```
#### fetch API后端 Polyfill
```typescript
async function fetchData(url: string): Promise<any> {
const response = await fetch(url, {
method: 'GET',
headers: {
'User-Agent': 'Mozilla/5.0...',
'Content-Type': 'application/json'
}
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
const data = await response.json();
return data;
}
```
## 最佳实践
### 1. 使用类型注解
虽然后端不强制类型检查,但类型注解可以提高代码可读性:
```typescript
function parseFileList(
shareLinkInfo: any,
http: any,
logger: any
): Promise<Array<{
fileName: string;
fileId: string;
size: number;
}>> {
// 实现...
}
```
### 2. 利用 async/await
TypeScript 的 async/await 会编译为 Promise后端已实现 Promise polyfill
```typescript
async function parse(
shareLinkInfo: any,
http: any,
logger: any
): Promise<string> {
try {
const response = await fetch(url);
const data = await response.json();
return data.downloadUrl;
} catch (error) {
logger.error(`错误: ${error.message}`);
throw error;
}
}
```
### 3. 使用模板字符串
模板字符串让代码更清晰:
```typescript
logger.info(`开始解析: ${url}, 密码: ${pwd}`);
const apiUrl = `https://api.example.com/file/${fileId}`;
```
### 4. 错误处理
使用类型化的错误处理:
```typescript
try {
const result = await parseUrl(url);
return result;
} catch (error: any) {
logger.error(`解析失败: ${error.message}`);
throw new Error(`无法解析链接: ${url}`);
}
```
## 编译错误处理
### 常见编译错误
#### 1. 类型不匹配
```typescript
// ❌ 错误
const count: number = "123";
// ✅ 正确
const count: number = 123;
```
#### 2. 缺少返回值
```typescript
// ❌ 错误
function parse(shareLinkInfo: any): string {
const url = shareLinkInfo.getShareUrl();
// 缺少 return
}
// ✅ 正确
function parse(shareLinkInfo: any): string {
const url = shareLinkInfo.getShareUrl();
return url;
}
```
#### 3. 使用未声明的变量
```typescript
// ❌ 错误
function parse() {
console.log(unknownVariable);
}
// ✅ 正确
function parse() {
const knownVariable = "value";
console.log(knownVariable);
}
```
### 查看编译错误
编译失败时,系统会显示详细的错误信息,包括:
- 错误类型Error/Warning
- 错误位置(行号、列号)
- 错误代码TS错误代码
- 错误描述
## 数据库结构
### playground_typescript_code 表
存储 TypeScript 源代码的表结构:
| 字段 | 类型 | 说明 |
|------|------|------|
| id | BIGINT | 主键,自增 |
| parser_id | BIGINT | 关联的解析器ID外键 |
| ts_code | TEXT | TypeScript原始代码 |
| es5_code | TEXT | 编译后的ES5代码 |
| compile_errors | VARCHAR(2000) | 编译错误信息 |
| compiler_version | VARCHAR(32) | 编译器版本 |
| compile_options | VARCHAR(1000) | 编译选项JSON格式 |
| create_time | DATETIME | 创建时间 |
| update_time | DATETIME | 更新时间 |
| is_valid | BOOLEAN | 编译是否成功 |
| ip | VARCHAR(64) | 创建者IP |
### 与 playground_parser 表的关系
- `playground_typescript_code.parser_id` 外键关联到 `playground_parser.id`
- 一个解析器parser可以有一个对应的 TypeScript 代码记录
- 编译后的 ES5 代码存储在 `playground_parser.js_code` 字段中
## API 端点
### 保存 TypeScript 代码
```http
POST /v2/playground/typescript
Content-Type: application/json
{
"parserId": 1,
"tsCode": "...",
"es5Code": "...",
"compileErrors": null,
"compilerVersion": "5.x",
"compileOptions": "{}",
"isValid": true
}
```
### 获取 TypeScript 代码
```http
GET /v2/playground/typescript/:parserId
```
### 更新 TypeScript 代码
```http
PUT /v2/playground/typescript/:parserId
Content-Type: application/json
{
"tsCode": "...",
"es5Code": "...",
"compileErrors": null,
"compilerVersion": "5.x",
"compileOptions": "{}",
"isValid": true
}
```
## 迁移指南
### 从 JavaScript 迁移到 TypeScript
1. **添加类型注解**
```typescript
// JavaScript
function parse(shareLinkInfo, http, logger) {
var url = shareLinkInfo.getShareUrl();
return url;
}
// TypeScript
function parse(
shareLinkInfo: any,
http: any,
logger: any
): string {
const url: string = shareLinkInfo.getShareUrl();
return url;
}
```
2. **使用 const/let 替代 var**
```typescript
// JavaScript
var url = "https://example.com";
var count = 0;
// TypeScript
const url: string = "https://example.com";
let count: number = 0;
```
3. **使用模板字符串**
```typescript
// JavaScript
var message = "URL: " + url + ", Count: " + count;
// TypeScript
const message: string = `URL: ${url}, Count: ${count}`;
```
4. **使用 async/await**
```typescript
// JavaScript
function parse(shareLinkInfo, http, logger) {
return new Promise(function(resolve, reject) {
fetch(url).then(function(response) {
resolve(response.text());
}).catch(reject);
});
}
// TypeScript
async function parse(
shareLinkInfo: any,
http: any,
logger: any
): Promise<string> {
const response = await fetch(url);
return await response.text();
}
```
## 常见问题
### Q: TypeScript 代码会在哪里编译?
A: TypeScript 代码在浏览器前端编译为 ES5然后发送到后端执行。这确保了后端始终执行标准的 ES5 代码。
### Q: 编译需要多长时间?
A: 通常在几毫秒到几百毫秒之间,取决于代码大小和复杂度。
### Q: 可以使用 npm 包吗?
A: 不可以。目前不支持 import/require 外部模块。所有代码必须自包含。
### Q: 类型检查严格吗?
A: 不严格。编译器配置为允许隐式 any 类型,不进行严格的 null 检查。主要目的是支持现代语法,而非严格的类型安全。
### Q: 编译后的代码可以查看吗?
A: 目前编译后的 ES5 代码存储在数据库中,但 UI 中暂未提供预览功能。这是未来的增强计划。
### Q: 原有的 JavaScript 代码会受影响吗?
A: 不会。JavaScript 和 TypeScript 模式完全独立,互不影响。
## 故障排除
### 编译失败
1. **检查语法**:确保 TypeScript 语法正确
2. **查看错误信息**:仔细阅读编译错误提示
3. **简化代码**:从简单的示例开始,逐步添加功能
4. **使用示例**:点击"加载示例"查看正确的代码结构
### 运行时错误
1. **检查 ES5 兼容性**:某些高级特性可能无法完全转换
2. **验证 API 使用**:确保正确使用 shareLinkInfo、http、logger 等对象
3. **查看日志**:使用 logger 对象输出调试信息
## 未来计划
- [ ] 显示编译后的 ES5 代码预览
- [ ] 添加专用的编译错误面板
- [ ] 支持更多 TypeScript 配置选项
- [ ] 提供完整的类型定义文件(.d.ts
- [ ] 支持代码自动补全和智能提示
- [ ] 添加 TypeScript 代码片段库
## 反馈与支持
如遇到问题或有建议,请在 GitHub Issues 中提出:
https://github.com/qaiu/netdisk-fast-download/issues

View File

@@ -104,7 +104,7 @@ public enum PanDomainTemplate {
"lanzoug|" +
"lanzoum" +
")\\.com/(.+/)?(?<KEY>.+)"),
"https://lanzoux.com/{shareKey}",
"https://w1.lanzn.com/{shareKey}",
LzTool.class),
// https://www.feijix.com/s/

View File

@@ -244,19 +244,17 @@ public class JsHttpClient {
if (data != null) {
if (data instanceof String) {
request.sendBuffer(Buffer.buffer((String) data));
return request.sendBuffer(Buffer.buffer((String) data));
} else if (data instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, String> mapData = (Map<String, String>) data;
request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
} else {
request.sendJson(data);
return request.sendJson(data);
}
} else {
request.send();
}
return request.send();
}
});
}
@@ -276,19 +274,17 @@ public class JsHttpClient {
if (data != null) {
if (data instanceof String) {
request.sendBuffer(Buffer.buffer((String) data));
return request.sendBuffer(Buffer.buffer((String) data));
} else if (data instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, String> mapData = (Map<String, String>) data;
request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
} else {
request.sendJson(data);
return request.sendJson(data);
}
} else {
request.send();
}
return request.send();
}
});
}
@@ -322,19 +318,17 @@ public class JsHttpClient {
if (data != null) {
if (data instanceof String) {
request.sendBuffer(Buffer.buffer((String) data));
return request.sendBuffer(Buffer.buffer((String) data));
} else if (data instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, String> mapData = (Map<String, String>) data;
request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
return request.sendForm(MultiMap.caseInsensitiveMultiMap().addAll(mapData));
} else {
request.sendJson(data);
return request.sendJson(data);
}
} else {
request.send();
}
return request.send();
}
});
}

View File

@@ -111,7 +111,7 @@ public class JsPlaygroundExecutor {
playgroundLogger.infoJava("✅ Fetch API和Promise polyfill注入成功");
}
playgroundLogger.infoJava("🔒 安全的JavaScript引擎初始化成功演练场");
playgroundLogger.infoJava("初始化成功");
// 执行JavaScript代码
engine.eval(jsCode);

View File

@@ -4,13 +4,15 @@ import cn.qaiu.entity.FileInfo;
import cn.qaiu.entity.ShareLinkInfo;
import cn.qaiu.parser.PanBase;
import cn.qaiu.util.AESUtils;
import cn.qaiu.util.AcwScV2Generator;
import cn.qaiu.util.FileSizeConverter;
import cn.qaiu.util.UUIDUtil;
import io.netty.handler.codec.http.cookie.DefaultCookie;
import io.vertx.core.Future;
import io.vertx.core.MultiMap;
import io.vertx.core.Promise;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.client.WebClientSession;
import io.vertx.uritemplate.UriTemplate;
import org.apache.commons.lang3.StringUtils;
@@ -18,10 +20,12 @@ import java.util.*;
/**
* 蓝奏云优享
*
* v019b22
*/
public class IzTool extends PanBase {
WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
private static final String API_URL_PREFIX = "https://api.ilanzou.com/unproved/";
private static final String FIRST_REQUEST_URL = API_URL_PREFIX + "recommend/list?devType=6&devModel=Chrome" +
@@ -70,6 +74,19 @@ public class IzTool extends PanBase {
super(shareLinkInfo);
}
private void setCookie(String html) {
int beginIndex = html.indexOf("arg1='") + 6;
String arg1 = html.substring(beginIndex, html.indexOf("';", beginIndex));
String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
// 创建一个 Cookie 并放入 CookieStore
DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
nettyCookie.setDomain(".ilanzou.com"); // 设置域名
nettyCookie.setPath("/"); // 设置路径
nettyCookie.setSecure(false);
nettyCookie.setHttpOnly(false);
webClientSession.cookieStore().put(nettyCookie);
}
public Future<String> parse() {
String shareId = shareLinkInfo.getShareKey();
@@ -80,19 +97,52 @@ public class IzTool extends PanBase {
// POST https://api.ilanzou.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
String url = StringUtils.isBlank(shareLinkInfo.getSharePassword()) ? FIRST_REQUEST_URL
: (FIRST_REQUEST_URL + "&code=" + shareLinkInfo.getSharePassword());
client.postAbs(UriTemplate.of(VIP_REQUEST_URL))
webClientSession.postAbs(UriTemplate.of(VIP_REQUEST_URL))
.setTemplateParam("uuid", uuid)
.setTemplateParam("ts", tsEncode)
.send().onSuccess(r0 -> { // 忽略res
// 第一次请求 获取文件信息
// POST https://api.feijipan.com/ws/recommend/list?devType=6&devModel=Chrome&extra=2&shareId=146731&type=0&offset=1&limit=60
client.postAbs(UriTemplate.of(url))
webClientSession.postAbs(UriTemplate.of(url))
.putHeaders(header)
.setTemplateParam("shareId", shareId)
.setTemplateParam("uuid", uuid)
.setTemplateParam("ts", tsEncode)
.send().onSuccess(res -> {
JsonObject resJson = asJson(res);
String resBody = asText(res);
// 检查是否包含 cookie 验证
if (resBody.contains("var arg1='")) {
webClientSession = WebClientSession.create(clientNoRedirects);
setCookie(resBody);
// 重新请求
webClientSession.postAbs(UriTemplate.of(url))
.putHeaders(header)
.setTemplateParam("shareId", shareId)
.setTemplateParam("uuid", uuid)
.setTemplateParam("ts", tsEncode)
.send().onSuccess(res2 -> {
handleParseResponse(asText(res2), shareId);
}).onFailure(handleFail(FIRST_REQUEST_URL));
return;
}
handleParseResponse(resBody, shareId);
}).onFailure(handleFail(FIRST_REQUEST_URL));
});
return promise.future();
}
private void handleParseResponse(String resBody, String shareId) {
JsonObject resJson;
try {
resJson = new JsonObject(resBody);
} catch (Exception e) {
fail(FIRST_REQUEST_URL + " 解析JSON失败: " + resBody);
return;
}
if (resJson.isEmpty()) {
fail(FIRST_REQUEST_URL + " 返回内容为空");
return;
}
if (resJson.getInteger("code") != 200) {
fail(FIRST_REQUEST_URL + " 返回异常: " + resJson);
return;
@@ -125,7 +175,7 @@ public class IzTool extends PanBase {
String fidEncode = AESUtils.encrypt2HexIz(fileId + "|" + userId);
String auth = AESUtils.encrypt2HexIz(fileId + "|" + nowTs);
// 第二次请求
clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
.setTemplateParam("fidEncode", fidEncode)
.setTemplateParam("uuid", uuid)
.setTemplateParam("ts", tsEncode)
@@ -139,9 +189,6 @@ public class IzTool extends PanBase {
}
promise.complete(headers.get("Location"));
}).onFailure(handleFail(SECOND_REQUEST_URL));
}).onFailure(handleFail(FIRST_REQUEST_URL));
});
return promise.future();
}
@Override
@@ -174,7 +221,7 @@ public class IzTool extends PanBase {
log.debug("开始解析目录: {}, shareId: {}, uuid: {}, ts: {}", id, shareId, uuid, tsEncode);
// 开始解析目录: 164312216, shareId: bPMsbg5K, uuid: 0fmVWTx2Ea4zFwkpd7KXf, ts: 20865d7b7f00828279f437cd1f097860
// 拿到目录ID
client.postAbs(UriTemplate.of(FILE_LIST_URL))
webClientSession.postAbs(UriTemplate.of(FILE_LIST_URL))
.putHeaders(header)
.setTemplateParam("shareId", shareId)
.setTemplateParam("uuid", uuid)
@@ -264,7 +311,7 @@ public class IzTool extends PanBase {
public Future<String> parseById() {
// 第二次请求
JsonObject paramJson = (JsonObject)shareLinkInfo.getOtherParam().get("paramJson");
clientNoRedirects.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
webClientSession.getAbs(UriTemplate.of(SECOND_REQUEST_URL))
.setTemplateParam("fidEncode", paramJson.getString("fidEncode"))
.setTemplateParam("uuid", paramJson.getString("uuid"))
.setTemplateParam("ts", paramJson.getString("ts"))

View File

@@ -1,30 +1,72 @@
package cn.qaiu.parser.impl;
import cn.qaiu.entity.FileInfo;
import cn.qaiu.entity.ShareLinkInfo;
import cn.qaiu.parser.PanBase;
import cn.qaiu.util.FileSizeConverter;
import io.vertx.core.Future;
import io.vertx.core.MultiMap;
import io.vertx.core.Promise;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.UUID;
/**
* <a href="https://lecloud.lenovo.com/">联想乐云</a>
*/
public class LeTool extends PanBase {
private static final String API_URL_PREFIX = "https://lecloud.lenovo.com/share/api/clouddiskapi/share/public/v1/";
private static final String API_URL_PREFIX = "https://lecloud.lenovo.com/mshare/api/clouddiskapi/share/public/v1/";
private static final String DEFAULT_FILE_TYPE = "file";
private static final int FILE_TYPE_DIRECTORY = 0; // 目录类型
private static final MultiMap HEADERS;
static {
HEADERS = MultiMap.caseInsensitiveMultiMap();
HEADERS.set("Accept", "application/json, text/plain, */*");
HEADERS.set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6");
HEADERS.set("Cache-Control", "no-cache");
HEADERS.set("Connection", "keep-alive");
HEADERS.set("Content-Type", "application/json");
HEADERS.set("DNT", "1");
HEADERS.set("Origin", "https://lecloud.lenovo.com");
HEADERS.set("Pragma", "no-cache");
HEADERS.set("Sec-Fetch-Dest", "empty");
HEADERS.set("Sec-Fetch-Mode", "cors");
HEADERS.set("Sec-Fetch-Site", "same-origin");
HEADERS.set("User-Agent", "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1 Edg/143.0.0.0");
}
public LeTool(ShareLinkInfo shareLinkInfo) {
super(shareLinkInfo);
}
/**
* 获取干净的 shareId去掉可能的查询参数
* URL 如 https://lecloud.lenovo.com/share/5eoN3RA5PLhQcH4zE?path=... 会导致 shareKey 包含查询参数
*/
private String getCleanShareId() {
String shareKey = shareLinkInfo.getShareKey();
if (shareKey != null && shareKey.contains("?")) {
return shareKey.split("\\?")[0];
}
return shareKey;
}
public Future<String> parse() {
final String dataKey = shareLinkInfo.getShareKey();
final String dataKey = getCleanShareId();
final String pwd = shareLinkInfo.getSharePassword();
// {"shareId":"xxx","password":"xxx","directoryId":"-1"}
String apiUrl1 = API_URL_PREFIX + "shareInfo";
client.postAbs(apiUrl1)
.sendJsonObject(JsonObject.of("shareId", dataKey, "password", pwd, "directoryId", -1))
.putHeaders(HEADERS)
.sendJsonObject(JsonObject.of("shareId", dataKey, "password", pwd, "directoryId", "-1"))
.onSuccess(res -> {
JsonObject resJson = asJson(res);
if (resJson.containsKey("result")) {
@@ -44,7 +86,19 @@ public class LeTool extends PanBase {
}
JsonObject fileInfoJson = files.getJsonObject(0);
if (fileInfoJson != null) {
// TODO 文件大小fileSize和文件名fileName
// Extract and populate FileInfo
FileInfo fileInfo = createFileInfo(fileInfoJson);
shareLinkInfo.getOtherParam().put("fileInfo", fileInfo);
// 判断是否为目录
Integer fileType = fileInfoJson.getInteger("fileType");
if (fileType != null && fileType == FILE_TYPE_DIRECTORY) {
// 如果是目录返回目录ID
String fileId = fileInfoJson.getString("fileId");
promise.complete(fileId);
return;
}
String fileId = fileInfoJson.getString("fileId");
// 根据文件ID获取跳转链接
getDownURL(dataKey, fileId);
@@ -59,12 +113,204 @@ public class LeTool extends PanBase {
return promise.future();
}
@Override
public Future<List<FileInfo>> parseFileList() {
Promise<List<FileInfo>> listPromise = Promise.promise();
String dataKey = getCleanShareId();
// 如果参数里的目录ID不为空则直接解析目录
String dirId = (String) shareLinkInfo.getOtherParam().get("dirId");
if (dirId == null || dirId.isEmpty()) {
// 如果没有指定目录ID使用根目录ID "-1"
dirId = "-1";
}
// 直接请求shareInfo接口解析目录
parseDirectory(dirId, dataKey, listPromise);
return listPromise.future();
}
/**
* 解析目录下的文件列表
*/
private void parseDirectory(String directoryId, String shareId, Promise<List<FileInfo>> promise) {
String pwd = shareLinkInfo.getSharePassword();
if (pwd == null) {
pwd = "";
}
String apiUrl = API_URL_PREFIX + "shareInfo";
JsonObject requestBody = JsonObject.of("shareId", shareId, "password", pwd, "directoryId", directoryId);
log.info("解析目录请求: url={}, body={}", apiUrl, requestBody.encode());
client.postAbs(apiUrl)
.putHeaders(HEADERS)
.sendJsonObject(requestBody)
.onSuccess(res -> {
JsonObject resJson = asJson(res);
if (!resJson.containsKey("result") || !resJson.getBoolean("result")) {
promise.fail("解析目录失败: " + resJson.encode());
return;
}
JsonObject dataJson = resJson.getJsonObject("data");
if (!dataJson.getBoolean("passwordVerified")) {
promise.fail("密码验证失败");
return;
}
JsonArray files = dataJson.getJsonArray("files");
if (files == null || files.isEmpty()) {
promise.complete(new ArrayList<>());
return;
}
List<FileInfo> fileList = new ArrayList<>();
for (int i = 0; i < files.size(); i++) {
JsonObject fileJson = files.getJsonObject(i);
FileInfo fileInfo = createFileInfoForList(fileJson, shareId);
fileList.add(fileInfo);
}
promise.complete(fileList);
})
.onFailure(err -> {
log.error("解析目录请求失败: {}", err.getMessage());
promise.fail(err);
});
}
/**
* 为文件列表创建 FileInfo 对象
*/
private FileInfo createFileInfoForList(JsonObject fileJson, String shareId) {
FileInfo fileInfo = new FileInfo();
try {
String fileId = fileJson.getString("fileId");
String fileName = fileJson.getString("fileName");
Long fileSize = fileJson.getLong("fileSize");
Integer fileType = fileJson.getInteger("fileType");
fileInfo.setFileId(fileId);
fileInfo.setFileName(fileName);
fileInfo.setPanType(shareLinkInfo.getType());
// 判断是否为目录
if (fileType != null && fileType == FILE_TYPE_DIRECTORY) {
// 目录类型
fileInfo.setFileType("folder");
fileInfo.setSize(0L);
fileInfo.setSizeStr("0B");
// 设置目录解析的URL - fileId 需要进行 URL 编码以保持特殊字符的编码状态
try {
String encodedFileId = URLEncoder.encode(fileId, "UTF-8");
fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s",
getDomainName(),
shareLinkInfo.getShareUrl(),
encodedFileId));
} catch (UnsupportedEncodingException e) {
log.error("URL编码失败: {}", e.getMessage());
// 降级方案:直接使用原始 fileId
fileInfo.setParserUrl(String.format("%s/v2/getFileList?url=%s&dirId=%s",
getDomainName(),
shareLinkInfo.getShareUrl(),
fileId));
}
} else {
// 文件类型
fileInfo.setFileType(fileType != null ? String.valueOf(fileType) : DEFAULT_FILE_TYPE);
fileInfo.setSize(fileSize);
fileInfo.setSizeStr(FileSizeConverter.convertToReadableSize(fileSize));
// 创建参数JSON并编码为Base64
JsonObject paramJson = JsonObject.of(
"shareId", shareId,
"fileId", fileId
);
String paramBase64 = Base64.getEncoder().encodeToString(paramJson.encode().getBytes());
// 设置解析URL和预览URL
fileInfo.setParserUrl(String.format("%s/v2/redirectUrl/%s/%s",
getDomainName(),
shareLinkInfo.getType(),
paramBase64))
.setPreviewUrl(String.format("%s/v2/viewUrl/%s/%s",
getDomainName(),
shareLinkInfo.getType(),
paramBase64));
}
} catch (Exception e) {
log.warn("创建文件信息失败: {}", e.getMessage());
}
return fileInfo;
}
@Override
public Future<String> parseById() {
Promise<String> parsePromise = Promise.promise();
try {
// 从参数中获取解析所需的信息
JsonObject paramJson = (JsonObject) shareLinkInfo.getOtherParam().get("paramJson");
String shareId = paramJson.getString("shareId");
String fileId = paramJson.getString("fileId");
// 调用获取下载链接
getDownURLForById(shareId, fileId, parsePromise);
} catch (Exception e) {
parsePromise.fail("解析参数失败: " + e.getMessage());
}
return parsePromise.future();
}
/**
* 根据文件ID获取下载URL (用于 parseById)
*/
private void getDownURLForById(String shareId, String fileId, Promise<String> promise) {
String uuid = UUID.randomUUID().toString();
JsonArray fileIds = JsonArray.of(fileId);
String apiUrl = API_URL_PREFIX + "packageDownloadWithFileIds";
client.postAbs(apiUrl)
.putHeaders(HEADERS)
.sendJsonObject(JsonObject.of("fileIds", fileIds, "shareId", shareId, "browserId", uuid))
.onSuccess(res -> {
JsonObject resJson = asJson(res);
if (resJson.containsKey("result")) {
if (resJson.getBoolean("result")) {
JsonObject dataJson = resJson.getJsonObject("data");
String downloadUrl = dataJson.getString("downloadUrl");
if (downloadUrl == null) {
promise.fail("Result JSON数据异常: downloadUrl不存在");
return;
}
// 获取重定向链接
clientNoRedirects.getAbs(downloadUrl).send()
.onSuccess(res2 -> promise.complete(res2.headers().get("Location")))
.onFailure(err -> promise.fail(err));
} else {
promise.fail(resJson.getString("errcode") + ": " + resJson.getString("errmsg"));
}
} else {
promise.fail("Result JSON数据异常: result字段不存在");
}
}).onFailure(err -> promise.fail(err));
}
private void getDownURL(String key, String fileId) {
String uuid = UUID.randomUUID().toString();
JsonArray fileIds = JsonArray.of(fileId);
String apiUrl2 = API_URL_PREFIX + "packageDownloadWithFileIds";
// {"fileIds":[123],"shareId":"xxx","browserId":"uuid"}
client.postAbs(apiUrl2)
.putHeaders(HEADERS)
.sendJsonObject(JsonObject.of("fileIds", fileIds, "shareId", key, "browserId", uuid))
.onSuccess(res -> {
JsonObject resJson = asJson(res);
@@ -89,4 +335,51 @@ public class LeTool extends PanBase {
}
}).onFailure(handleFail(apiUrl2));
}
/**
* Create FileInfo object from JSON response
* Uses exact field names from the API response without fallback checks
*/
private FileInfo createFileInfo(JsonObject fileInfoJson) {
FileInfo fileInfo = new FileInfo();
try {
// Set fileId
String fileId = fileInfoJson.getString("fileId");
if (fileId != null) {
fileInfo.setFileId(fileId);
}
// Set fileName
String fileName = fileInfoJson.getString("fileName");
if (fileName != null) {
fileInfo.setFileName(fileName);
}
// Set file size
Long fileSize = fileInfoJson.getLong("fileSize");
if (fileSize != null) {
fileInfo.setSize(fileSize);
// Convert to readable size string
fileInfo.setSizeStr(FileSizeConverter.convertToReadableSize(fileSize));
}
// Set fileType (API returns it as an integer)
Integer fileTypeInt = fileInfoJson.getInteger("fileType");
if (fileTypeInt != null) {
fileInfo.setFileType(String.valueOf(fileTypeInt));
} else {
// Default to generic file type if not available
fileInfo.setFileType(DEFAULT_FILE_TYPE);
}
// Set panType
fileInfo.setPanType(shareLinkInfo.getType());
} catch (Exception e) {
log.warn("Error extracting file info from JSON: {}", e.getMessage());
}
return fileInfo;
}
}

View File

@@ -11,14 +11,12 @@ import io.vertx.core.Promise;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.client.WebClient;
import io.vertx.ext.web.client.WebClientSession;
import org.apache.commons.lang3.RegExUtils;
import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
import javax.script.ScriptException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -29,13 +27,14 @@ import java.util.regex.Pattern;
*/
public class LzTool extends PanBase {
public static final String SHARE_URL_PREFIX = "https://wwww.lanzoum.com";
WebClientSession webClientSession = WebClientSession.create(clientNoRedirects);
public static final String SHARE_URL_PREFIX = "https://w1.lanzn.com/";
MultiMap headers0 = HeaderUtils.parseHeaders("""
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6
Cache-Control: max-age=0
Cookie: codelen=1; pc_ad1=1
DNT: 1
Priority: u=0, i
Sec-CH-UA: "Chromium";v="140", "Not=A?Brand";v="24", "Microsoft Edge";v="140"
@@ -63,6 +62,25 @@ public class LzTool extends PanBase {
.putHeaders(headers0)
.send().onSuccess(res -> {
String html = asText(res);
if (html.contains("var arg1='")) {
webClientSession = WebClientSession.create(clientNoRedirects);
setCookie(html);
webClientSession.getAbs(sUrl)
.putHeaders(headers0)
.send().onSuccess(res2 -> {
String html2 = asText(res2);
doParser(html2, pwd, sUrl);
});
} else {
doParser(html, pwd, sUrl);
}
}).onFailure(handleFail(sUrl));
return promise.future();
}
private void doParser(String html, String pwd, String sUrl) {
try {
setFileInfo(html, shareLinkInfo);
} catch (Exception e) {
@@ -76,40 +94,68 @@ public class LzTool extends PanBase {
try {
String jsText = getJsByPwd(pwd, html, "document.getElementById('rpt')");
ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, "down_p");
getDownURL(sUrl, client, scriptObjectMirror);
getDownURL(sUrl, scriptObjectMirror);
} catch (Exception e) {
fail(e, "js引擎执行失败");
}
} else {
}
else {
// 没有密码
String iframePath = matcher.group(1);
client.getAbs(SHARE_URL_PREFIX + iframePath).send().onSuccess(res2 -> {
String html2 = res2.bodyAsString();
// 去TMD正则
String absoluteURI = SHARE_URL_PREFIX + iframePath;
webClientSession.getAbs(absoluteURI).putHeaders(headers0).send().onSuccess(res2 -> {
String html2= asText(res2);
// Matcher matcher2 = Pattern.compile("'sign'\s*:\s*'(\\w+)'").matcher(html2);
String jsText = getJsText(html2);
if (jsText == null) {
fail(SHARE_URL_PREFIX + iframePath + " -> " + sUrl + ": js脚本匹配失败, 可能分享已失效");
headers0.add("Referer", absoluteURI);
setCookie(html2);
webClientSession.getAbs(absoluteURI).send().onSuccess(res3 -> {
String html3= asText(res3);
String jsText3 = getJsText(html3);
if (jsText3 != null) {
try {
ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText3, null);
getDownURL(sUrl, scriptObjectMirror);
} catch (ScriptException | NoSuchMethodException e) {
fail(e, "引擎执行失败");
}
} else {
fail(SHARE_URL_PREFIX + iframePath + " -> " + sUrl + ": 获取失败0, 可能分享已失效");
return;
}
});
} else {
try {
ScriptObjectMirror scriptObjectMirror = JsExecUtils.executeDynamicJs(jsText, null);
getDownURL(sUrl, client, scriptObjectMirror);
getDownURL(sUrl, scriptObjectMirror);
} catch (ScriptException | NoSuchMethodException e) {
fail(e, "js引擎执行失败");
}
}
}).onFailure(handleFail(SHARE_URL_PREFIX));
}
}).onFailure(handleFail(sUrl));
return promise.future();
}
private void setCookie(String html2) {
int beginIndex = html2.indexOf("arg1='") + 6;
String arg1 = html2.substring(beginIndex, html2.indexOf("';", beginIndex));
String acw_sc__v2 = AcwScV2Generator.acwScV2Simple(arg1);
// 创建一个 Cookie 并放入 CookieStore
DefaultCookie nettyCookie = new DefaultCookie("acw_sc__v2", acw_sc__v2);
nettyCookie.setDomain(".lanzn.com"); // 设置域名
nettyCookie.setPath("/"); // 设置路径
nettyCookie.setSecure(false);
nettyCookie.setHttpOnly(false);
webClientSession.cookieStore().put(nettyCookie);
}
private String getJsByPwd(String pwd, String html, String subText) {
String jsText = getJsText(html);
if (jsText == null) {
throw new RuntimeException("js脚本匹配失败, 可能分享已失效");
throw new RuntimeException("获取失败1, 可能分享已失效");
}
jsText = jsText.replace("document.getElementById('pwd').value", "\"" + pwd + "\"");
int i = jsText.indexOf(subText);
@@ -131,7 +177,7 @@ public class LzTool extends PanBase {
return html.substring(startPos, endPos).replaceAll("<!--.*-->", "");
}
private void getDownURL(String key, WebClient client, Map<String, ?> obj) {
private void getDownURL(String key, Map<String, ?> obj) {
if (obj == null) {
fail("需要访问密码");
return;
@@ -163,7 +209,7 @@ public class LzTool extends PanBase {
headers.set("referer", key);
// action=downprocess&signs=%3Fctdf&websignkey=I5gl&sign=BWMGOF1sBTRWXwI9BjZdYVA7BDhfNAIyUG9UawJtUGMIPlAhACkCa1UyUTAAYFxvUj5XY1E7UGFXaFVq&websign=&kd=1&ves=1
String url = SHARE_URL_PREFIX + url0;
client.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
webClientSession.postAbs(url).putHeaders(headers).sendForm(map).onSuccess(res2 -> {
try {
JsonObject urlJson = asJson(res2);
String name = urlJson.getString("inf");
@@ -178,7 +224,6 @@ public class LzTool extends PanBase {
String downUrl = urlJson.getString("dom") + "/file/" + urlJson.getString("url");
headers.remove("Referer");
WebClientSession webClientSession = WebClientSession.create(client);
webClientSession.getAbs(downUrl).putHeaders(headers).send()
.onSuccess(res3 -> {
String location = res3.headers().get("Location");
@@ -195,12 +240,13 @@ public class LzTool extends PanBase {
nettyCookie.setPath("/"); // 设置路径
nettyCookie.setSecure(false);
nettyCookie.setHttpOnly(false);
webClientSession.cookieStore().put(nettyCookie);
webClientSession.getAbs(downUrl).putHeaders(headers).send()
WebClientSession webClientSession2 = WebClientSession.create(clientNoRedirects);
webClientSession2.cookieStore().put(nettyCookie);
webClientSession2.getAbs(downUrl).putHeaders(headers).send()
.onSuccess(res4 -> {
String location0 = res4.headers().get("Location");
if (location0 == null) {
fail(downUrl + " -> 直链获取失败, 可能分享已失效");
fail(downUrl + " -> 直链获取失败2, 可能分享已失效");
} else {
setDateAndComplate(location0);
}

View File

@@ -549,6 +549,176 @@ public class JsHttpClientTest {
}
}
@Test
public void testPostWithJsonString() {
System.out.println("\n[测试16] POST请求JSON字符串 - httpbin.org/post");
System.out.println("测试修复POST请求发送JSON字符串时请求体是否正确发送");
try {
String url = "https://httpbin.org/post";
System.out.println("请求URL: " + url);
// 模拟阿里云盘登录请求格式
String jsonData = "{\"grant_type\":\"refresh_token\",\"refresh_token\":\"test_token_123\"}";
System.out.println("POST数据JSON字符串: " + jsonData);
// 设置Content-Type为application/json
httpClient.putHeader("Content-Type", "application/json");
System.out.println("设置Content-Type: application/json");
System.out.println("开始请求...");
long startTime = System.currentTimeMillis();
JsHttpClient.JsHttpResponse response = httpClient.post(url, jsonData);
long endTime = System.currentTimeMillis();
System.out.println("请求完成,耗时: " + (endTime - startTime) + "ms");
System.out.println("状态码: " + response.statusCode());
String body = response.body();
System.out.println("响应体前500字符: " + (body != null && body.length() > 500 ? body.substring(0, 500) + "..." : body));
// 验证结果
assertNotNull("响应不能为null", response);
assertEquals("状态码应该是200", 200, response.statusCode());
assertNotNull("响应体不能为null", body);
// 验证请求体是否正确发送httpbin会回显请求数据
assertTrue("响应体应该包含发送的JSON数据",
body.contains("grant_type") || body.contains("refresh_token"));
System.out.println("✓ 测试通过 - POST请求体已正确发送");
} catch (Exception e) {
System.err.println("✗ 测试失败: " + e.getMessage());
e.printStackTrace();
fail("POST JSON字符串请求测试失败: " + e.getMessage());
}
}
@Test
public void testAlipanTokenApi() {
System.out.println("\n[测试20] 阿里云盘Token接口测试 - auth.aliyundrive.com/v2/account/token");
System.out.println("参考 alipan.js 中的登录逻辑,测试请求格式是否正确");
try {
String tokenUrl = "https://auth.aliyundrive.com/v2/account/token";
System.out.println("请求URL: " + tokenUrl);
// 参考 alipan.js 中的请求格式
// setJsonHeaders(http) 设置 Content-Type: application/json 和 User-Agent
httpClient.putHeader("Content-Type", "application/json");
httpClient.putHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
// 参考 alipan.js: JSON.stringify({grant_type: "refresh_token", refresh_token: REFRESH_TOKEN})
String jsonData = "{\"grant_type\":\"refresh_token\",\"refresh_token\":\"\"}";
System.out.println("POST数据JSON字符串: " + jsonData);
System.out.println("注意使用无效token测试错误响应格式");
System.out.println("开始请求...");
long startTime = System.currentTimeMillis();
JsHttpClient.JsHttpResponse response = httpClient.post(tokenUrl, jsonData);
long endTime = System.currentTimeMillis();
System.out.println("请求完成,耗时: " + (endTime - startTime) + "ms");
System.out.println("状态码: " + response.statusCode());
String body = response.body();
System.out.println("响应体: " + body);
// 验证结果
assertNotNull("响应不能为null", response);
// 使用无效token应该返回400或401等错误状态码但请求格式应该是正确的
assertTrue("状态码应该是4xx无效token或200如果token有效",
response.statusCode() >= 200 && response.statusCode() < 500);
assertNotNull("响应体不能为null", body);
// 验证响应格式阿里云盘API通常返回JSON
try {
Object jsonResponse = response.json();
System.out.println("响应JSON解析成功: " + jsonResponse);
assertNotNull("JSON响应不能为null", jsonResponse);
} catch (Exception e) {
System.out.println("警告响应不是有效的JSON格式");
}
// 验证请求头是否正确设置
System.out.println("验证请求头设置...");
Map<String, String> headers = httpClient.getHeaders();
assertTrue("应该设置了Content-Type", headers.containsKey("Content-Type"));
assertEquals("Content-Type应该是application/json",
"application/json", headers.get("Content-Type"));
System.out.println("✓ 测试通过 - 请求格式正确已成功发送到阿里云盘API");
} catch (Exception e) {
System.err.println("✗ 测试失败: " + e.getMessage());
e.printStackTrace();
// 如果是超时或其他网络错误,说明请求格式可能有问题
if (e.getMessage() != null && e.getMessage().contains("超时")) {
fail("请求超时,可能是请求格式问题或网络问题: " + e.getMessage());
} else {
fail("阿里云盘Token接口测试失败: " + e.getMessage());
}
}
}
@Test
public void testAlipanTokenApiWithValidFormat() {
System.out.println("\n[测试21] 阿里云盘Token接口格式验证 - 使用httpbin验证请求格式");
System.out.println("通过httpbin回显验证请求格式是否与alipan.js中的格式一致");
try {
// 使用httpbin来验证请求格式
String testUrl = "https://httpbin.org/post";
System.out.println("测试URL: " + testUrl);
// 参考 alipan.js 中的请求格式
httpClient.clearHeaders(); // 清空之前的头
httpClient.putHeader("Content-Type", "application/json");
httpClient.putHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36");
// 完全模拟 alipan.js 中的请求体格式
String jsonData = "{\"grant_type\":\"refresh_token\",\"refresh_token\":\"test_refresh_token_12345\"}";
System.out.println("POST数据JSON字符串: " + jsonData);
System.out.println("开始请求...");
long startTime = System.currentTimeMillis();
JsHttpClient.JsHttpResponse response = httpClient.post(testUrl, jsonData);
long endTime = System.currentTimeMillis();
System.out.println("请求完成,耗时: " + (endTime - startTime) + "ms");
System.out.println("状态码: " + response.statusCode());
String body = response.body();
System.out.println("响应体前800字符: " + (body != null && body.length() > 800 ? body.substring(0, 800) + "..." : body));
// 验证结果
assertNotNull("响应不能为null", response);
assertEquals("状态码应该是200", 200, response.statusCode());
assertNotNull("响应体不能为null", body);
// httpbin会回显请求数据验证请求体是否正确发送
assertTrue("响应体应该包含grant_type字段", body.contains("grant_type"));
assertTrue("响应体应该包含refresh_token字段", body.contains("refresh_token"));
assertTrue("响应体应该包含发送的refresh_token值", body.contains("test_refresh_token_12345"));
// 验证Content-Type是否正确
assertTrue("响应体应该包含Content-Type信息", body.contains("application/json"));
// 验证User-Agent是否正确
assertTrue("响应体应该包含User-Agent信息", body.contains("Mozilla"));
System.out.println("✓ 测试通过 - 请求格式与alipan.js中的格式完全一致");
System.out.println(" - JSON请求体正确发送");
System.out.println(" - Content-Type正确设置");
System.out.println(" - User-Agent正确设置");
} catch (Exception e) {
System.err.println("✗ 测试失败: " + e.getMessage());
e.printStackTrace();
fail("阿里云盘Token接口格式验证失败: " + e.getMessage());
}
}
@Test
public void testSetTimeout() {
System.out.println("\n[测试15] 设置超时时间 - setTimeout方法");

View File

@@ -3,6 +3,7 @@ module.exports = {
'@vue/cli-plugin-babel/preset'
],
plugins: [
'@vue/babel-plugin-transform-vue-jsx'
'@vue/babel-plugin-transform-vue-jsx',
'@babel/plugin-transform-class-static-block'
]
}

View File

@@ -4,7 +4,7 @@
### 1. NPM包安装
已在 `package.json` 中安装:
- `monaco-editor`: ^0.45.0 - Monaco Editor核心包
- `monaco-editor`: ^0.55.1 - Monaco Editor核心包
- `@monaco-editor/loader`: ^1.4.0 - Monaco Editor加载器
- `monaco-editor-webpack-plugin`: ^7.1.1 - Webpack打包插件devDependencies
@@ -172,3 +172,5 @@ Monaco Editor 打包后会增加构建产物大小约2-3MB但这是正

View File

@@ -5,7 +5,8 @@
"scripts": {
"serve": "vue-cli-service serve",
"dev": "vue-cli-service serve",
"build": "vue-cli-service build",
"build": "vue-cli-service build && node scripts/compress-vs.js",
"build:no-compress": "vue-cli-service build",
"lint": "vue-cli-service lint"
},
"dependencies": {
@@ -16,7 +17,7 @@
"clipboard": "^2.0.11",
"core-js": "^3.8.3",
"element-plus": "2.11.3",
"monaco-editor": "^0.45.0",
"monaco-editor": "^0.55.1",
"qrcode": "^1.5.4",
"splitpanes": "^4.0.4",
"vue": "^3.5.12",
@@ -28,6 +29,7 @@
"@babel/core": "^7.26.0",
"@babel/eslint-parser": "^7.25.9",
"@babel/plugin-transform-class-properties": "^7.26.0",
"@babel/plugin-transform-class-static-block": "^7.26.0",
"@vue/babel-plugin-transform-vue-jsx": "^1.4.0",
"@vue/cli-plugin-babel": "~5.0.8",
"@vue/cli-plugin-eslint": "~5.0.8",
@@ -35,7 +37,8 @@
"compression-webpack-plugin": "^11.1.0",
"eslint": "^9.0.0",
"eslint-plugin-vue": "^9.30.0",
"filemanager-webpack-plugin": "8.0.0"
"filemanager-webpack-plugin": "8.0.0",
"monaco-editor-webpack-plugin": "^7.1.1"
},
"eslintConfig": {
"root": true,

View File

@@ -9,8 +9,8 @@
content="Netdisk fast download,网盘直链解析工具">
<meta name="description"
content="Netdisk fast download 网盘直链解析工具">
<!-- Font Awesome 图标库 -->
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<!-- Font Awesome 图标库 - 使用国内CDN -->
<link rel="stylesheet" href="https://cdn.bootcdn.net/ajax/libs/font-awesome/6.4.0/css/all.min.css">
<style>
.page-loading-wrap {
padding: 120px;
@@ -154,11 +154,26 @@
}
</style>
<script>
const saved = localStorage.getItem('isDarkMode') === 'true'
const systemDark = window.matchMedia('(prefers-color-scheme: dark)').matches
if (saved || (!saved && systemDark)) {
document.body.classList.add('dark-theme')
// 等待DOM加载完成后再操作
(function() {
function applyDarkTheme() {
const body = document.body;
if (body && body.classList) {
// 只在用户明确选择暗色模式时才应用,不自动检测系统偏好
if (localStorage.getItem('isDarkMode') === 'true') {
body.classList.add('dark-theme')
}
}
}
// 如果DOM已加载立即执行
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', applyDarkTheme);
} else {
// DOM已加载立即执行
applyDarkTheme();
}
})();
</script>
</head>
<body>

124
web-front/scripts/compress-vs.js Executable file
View File

@@ -0,0 +1,124 @@
#!/usr/bin/env node
const path = require("path");
const fs = require("fs");
const zlib = require("zlib");
const { promisify } = require("util");
const gzip = promisify(zlib.gzip);
const readdir = promisify(fs.readdir);
const stat = promisify(fs.stat);
const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);
// 递归压缩目录下的所有文件
async function compressDirectory(dirPath, threshold = 1024) {
if (!fs.existsSync(dirPath)) {
console.warn(`目录不存在: ${dirPath}`);
return;
}
const files = await readdir(dirPath, { withFileTypes: true });
let compressedCount = 0;
let totalOriginalSize = 0;
let totalCompressedSize = 0;
for (const file of files) {
const filePath = path.join(dirPath, file.name);
if (file.isDirectory()) {
await compressDirectory(filePath, threshold);
} else if (file.isFile()) {
const stats = await stat(filePath);
// 只压缩超过阈值且不是已压缩的文件
if (stats.size > threshold && !filePath.endsWith('.gz') && !filePath.endsWith('.map')) {
try {
const content = await readFile(filePath);
const compressed = await gzip(content);
await writeFile(filePath + '.gz', compressed);
compressedCount++;
totalOriginalSize += stats.size;
totalCompressedSize += compressed.length;
console.log(`${file.name} (${(stats.size / 1024).toFixed(2)}KB -> ${(compressed.length / 1024).toFixed(2)}KB)`);
} catch (error) {
console.warn(`⚠ 压缩失败: ${filePath}`, error.message);
}
}
}
}
if (compressedCount > 0) {
console.log(`\n压缩完成: ${compressedCount} 个文件`);
console.log(`原始大小: ${(totalOriginalSize / 1024 / 1024).toFixed(2)}MB`);
console.log(`压缩后大小: ${(totalCompressedSize / 1024 / 1024).toFixed(2)}MB`);
console.log(`压缩率: ${((1 - totalCompressedSize / totalOriginalSize) * 100).toFixed(1)}%`);
}
}
// 删除未使用的 worker 文件
function deleteUnusedWorkers() {
const jsDir = path.join(__dirname, '../nfd-front/js');
const workers = ['editor.worker.js', 'editor.worker.js.gz', 'json.worker.js', 'json.worker.js.gz', 'ts.worker.js', 'ts.worker.js.gz'];
let deletedCount = 0;
for (const worker of workers) {
const filePath = path.join(jsDir, worker);
if (fs.existsSync(filePath)) {
try {
fs.unlinkSync(filePath);
deletedCount++;
console.log(`✓ 已删除未使用的文件: ${worker}`);
} catch (error) {
console.warn(`⚠ 删除失败: ${worker}`, error.message);
}
}
}
if (deletedCount > 0) {
console.log(`\n已删除 ${deletedCount} 个未使用的 worker 文件\n`);
}
}
// 复制到 webroot
function copyToWebroot() {
const source = path.join(__dirname, '../nfd-front');
const dest = path.join(__dirname, '../../webroot/nfd-front');
// 使用 FileManagerPlugin 的方式,这里用简单的复制
const { execSync } = require('child_process');
try {
// 删除目标目录
if (fs.existsSync(dest)) {
execSync(`rm -rf "${dest}"`, { stdio: 'inherit' });
}
// 复制整个目录
execSync(`cp -R "${source}" "${dest}"`, { stdio: 'inherit' });
console.log('\n✓ 已复制到 webroot');
} catch (error) {
console.error('\n✗ 复制到 webroot 失败:', error.message);
process.exit(1);
}
}
// 主函数
async function main() {
// 先删除未使用的 worker 文件
deleteUnusedWorkers();
// 然后压缩 vs 目录
const vsPath = path.join(__dirname, '../nfd-front/js/vs');
console.log('开始压缩 vs 目录下的文件...\n');
try {
await compressDirectory(vsPath, 1024); // 只压缩超过1KB的文件
console.log('\n✓ vs 目录压缩完成');
} catch (error) {
console.error('\n✗ vs 目录压缩失败:', error);
process.exit(1);
}
// 最后复制到 webroot
copyToWebroot();
}
main();

View File

@@ -43,12 +43,16 @@ watch(darkMode, (newValue) => {
emit('theme-change', newValue)
// 应用主题到body
const html = document.documentElement;
const body = document.body;
if (html && body && html.classList && body.classList) {
if (newValue) {
document.body.classList.add('dark-theme')
document.documentElement.classList.add('dark-theme')
body.classList.add('dark-theme')
html.classList.add('dark-theme')
} else {
document.body.classList.remove('dark-theme')
document.documentElement.classList.remove('dark-theme')
body.classList.remove('dark-theme')
html.classList.remove('dark-theme')
}
}
})
@@ -57,9 +61,11 @@ onMounted(() => {
emit('theme-change', darkMode.value)
// 应用初始主题
if (darkMode.value) {
document.body.classList.add('dark-theme')
document.documentElement.classList.add('dark-theme')
const html = document.documentElement;
const body = document.body;
if (html && body && html.classList && body.classList && darkMode.value) {
body.classList.add('dark-theme')
html.classList.add('dark-theme')
}
})
</script>

View File

@@ -388,8 +388,14 @@ export default {
return date.toLocaleString('zh-CN')
},
checkTheme() {
this.isDarkTheme = document.body.classList.contains('dark-theme') ||
document.documentElement.classList.contains('dark-theme')
const html = document.documentElement;
const body = document.body;
if (html && body && html.classList && body.classList) {
this.isDarkTheme = body.classList.contains('dark-theme') ||
html.classList.contains('dark-theme')
} else {
this.isDarkTheme = false;
}
},
renderContent(h, { node, data, store }) {
const isFolder = data.fileType === 'folder'

View File

@@ -34,6 +34,7 @@ export default {
const editorContainer = ref(null);
let editor = null;
let monaco = null;
let touchHandlers = { start: null, move: null };
const defaultOptions = {
value: props.modelValue,
@@ -94,6 +95,19 @@ export default {
return;
}
// 配置Monaco Editor使用本地打包的文件而不是CDN
if (loader.config) {
const vsPath = process.env.NODE_ENV === 'production'
? './js/vs' // 生产环境使用相对路径
: '/js/vs'; // 开发环境使用绝对路径
loader.config({
paths: {
vs: vsPath
}
});
}
// 初始化Monaco Editor
monaco = await loader.init();
@@ -123,6 +137,46 @@ export default {
if (editorContainer.value) {
editorContainer.value.style.height = props.height;
}
// 移动端:添加触摸缩放来调整字体大小
if (window.innerWidth <= 768 && editorContainer.value) {
let initialDistance = 0;
let initialFontSize = defaultOptions.fontSize || 14;
const minFontSize = 8;
const maxFontSize = 24;
const getTouchDistance = (touch1, touch2) => {
const dx = touch1.clientX - touch2.clientX;
const dy = touch1.clientY - touch2.clientY;
return Math.sqrt(dx * dx + dy * dy);
};
touchHandlers.start = (e) => {
if (e.touches.length === 2 && editor) {
initialDistance = getTouchDistance(e.touches[0], e.touches[1]);
initialFontSize = editor.getOption(monaco.editor.EditorOption.fontSize);
}
};
touchHandlers.move = (e) => {
if (e.touches.length === 2 && editor) {
e.preventDefault(); // 防止页面缩放
const currentDistance = getTouchDistance(e.touches[0], e.touches[1]);
const scale = currentDistance / initialDistance;
const newFontSize = Math.round(initialFontSize * scale);
// 限制字体大小范围
const clampedFontSize = Math.max(minFontSize, Math.min(maxFontSize, newFontSize));
if (clampedFontSize !== editor.getOption(monaco.editor.EditorOption.fontSize)) {
editor.updateOptions({ fontSize: clampedFontSize });
}
}
};
editorContainer.value.addEventListener('touchstart', touchHandlers.start, { passive: false });
editorContainer.value.addEventListener('touchmove', touchHandlers.move, { passive: false });
}
} catch (error) {
console.error('Monaco Editor初始化失败:', error);
console.error('错误详情:', error.stack);
@@ -166,6 +220,11 @@ export default {
});
onBeforeUnmount(() => {
// 清理触摸事件监听器
if (editorContainer.value && touchHandlers.start && touchHandlers.move) {
editorContainer.value.removeEventListener('touchstart', touchHandlers.start);
editorContainer.value.removeEventListener('touchmove', touchHandlers.move);
}
if (editor) {
editor.dispose();
}
@@ -187,10 +246,26 @@ export default {
border: 1px solid #dcdfe6;
border-radius: 4px;
overflow: hidden;
/* 允许用户选择文本 */
-webkit-user-select: text;
user-select: text;
}
.monaco-editor-container :deep(.monaco-editor) {
border-radius: 4px;
}
/* 移动端:禁用页面缩放,只允许编辑器字体缩放 */
@media (max-width: 768px) {
.monaco-editor-container {
/* 禁用页面级别的缩放,只允许编辑器内部字体缩放 */
touch-action: pan-x pan-y;
}
.monaco-editor-container :deep(.monaco-editor) {
/* 禁用页面级别的缩放 */
touch-action: pan-x pan-y;
}
}
</style>

View File

@@ -10,7 +10,13 @@ const routes = [
{ path: '/showFile', component: ShowFile },
{ path: '/showList', component: ShowList },
{ path: '/clientLinks', component: ClientLinks },
{ path: '/playground', component: Playground }
{ path: '/playground', component: Playground },
// 404页面 - 必须放在最后
{
path: '/:pathMatch(.*)*',
name: 'NotFound',
component: () => import('@/views/NotFound.vue')
}
]
const router = createRouter({

View File

@@ -1,5 +1,10 @@
import axios from 'axios';
// 创建axios实例配置携带cookie
const axiosInstance = axios.create({
withCredentials: true // 重要允许跨域请求携带cookie
});
/**
* 演练场API服务
*/
@@ -10,7 +15,7 @@ export const playgroundApi = {
*/
async getStatus() {
try {
const response = await axios.get('/v2/playground/status');
const response = await axiosInstance.get('/v2/playground/status');
return response.data;
} catch (error) {
throw new Error(error.response?.data?.error || error.message || '获取状态失败');
@@ -24,7 +29,7 @@ export const playgroundApi = {
*/
async login(password) {
try {
const response = await axios.post('/v2/playground/login', { password });
const response = await axiosInstance.post('/v2/playground/login', { password });
return response.data;
} catch (error) {
throw new Error(error.response?.data?.error || error.message || '登录失败');
@@ -41,7 +46,7 @@ export const playgroundApi = {
*/
async testScript(jsCode, shareUrl, pwd = '', method = 'parse') {
try {
const response = await axios.post('/v2/playground/test', {
const response = await axiosInstance.post('/v2/playground/test', {
jsCode,
shareUrl,
pwd,
@@ -69,7 +74,7 @@ export const playgroundApi = {
*/
async getTypesJs() {
try {
const response = await axios.get('/v2/playground/types.js', {
const response = await axiosInstance.get('/v2/playground/types.js', {
responseType: 'text'
});
return response.data;
@@ -83,7 +88,7 @@ export const playgroundApi = {
*/
async getParserList() {
try {
const response = await axios.get('/v2/playground/parsers');
const response = await axiosInstance.get('/v2/playground/parsers');
// 框架会自动包装成JsonResult需要从data字段获取
if (response.data && response.data.data) {
return {
@@ -104,7 +109,7 @@ export const playgroundApi = {
*/
async saveParser(jsCode) {
try {
const response = await axios.post('/v2/playground/parsers', { jsCode });
const response = await axiosInstance.post('/v2/playground/parsers', { jsCode });
// 框架会自动包装成JsonResult
if (response.data && response.data.data) {
return {
@@ -130,7 +135,7 @@ export const playgroundApi = {
*/
async updateParser(id, jsCode, enabled = true) {
try {
const response = await axios.put(`/v2/playground/parsers/${id}`, { jsCode, enabled });
const response = await axiosInstance.put(`/v2/playground/parsers/${id}`, { jsCode, enabled });
return response.data;
} catch (error) {
throw new Error(error.response?.data?.error || error.message || '更新解析器失败');
@@ -142,7 +147,7 @@ export const playgroundApi = {
*/
async deleteParser(id) {
try {
const response = await axios.delete(`/v2/playground/parsers/${id}`);
const response = await axiosInstance.delete(`/v2/playground/parsers/${id}`);
return response.data;
} catch (error) {
throw new Error(error.response?.data?.error || error.message || '删除解析器失败');
@@ -154,7 +159,7 @@ export const playgroundApi = {
*/
async getParserById(id) {
try {
const response = await axios.get(`/v2/playground/parsers/${id}`);
const response = await axiosInstance.get(`/v2/playground/parsers/${id}`);
// 框架会自动包装成JsonResult
if (response.data && response.data.data) {
return {

View File

@@ -48,7 +48,7 @@
</div>
<!-- 项目简介移到卡片内 -->
<div class="project-intro">
<div class="intro-title">NFD网盘直链解析0.1.9_b12</div>
<div class="intro-title">NFD网盘直链解析0.1.9_b15</div>
<div class="intro-desc">
<div>支持网盘蓝奏云蓝奏云优享小飞机盘123云盘奶牛快传移动云空间QQ邮箱云盘QQ闪传等 <el-link style="color:#606cf5" href="https://github.com/qaiu/netdisk-fast-download?tab=readme-ov-file#%E7%BD%91%E7%9B%98%E6%94%AF%E6%8C%81%E6%83%85%E5%86%B5" target="_blank"> &gt;&gt; </el-link></div>
<div>文件夹解析支持蓝奏云蓝奏云优享小飞机盘123云盘</div>
@@ -218,7 +218,7 @@
<!-- 版本号显示 -->
<div class="version-info">
<span class="version-text">内部版本: {{ buildVersion }}</span>
<!-- <el-link :href="'/playground'" class="playground-link">JS演练场</el-link>-->
<el-link v-if="playgroundEnabled" :href="'/playground'" class="playground-link">脚本演练场</el-link>
</div>
<!-- 文件解析结果区下方加分享按钮 -->
@@ -248,6 +248,7 @@ import DirectoryTree from '@/components/DirectoryTree'
import parserUrl from '../parserUrl1'
import fileTypeUtils from '@/utils/fileTypeUtils'
import { ElMessage } from 'element-plus'
import { playgroundApi } from '@/utils/playgroundApi'
export const previewBaseUrl = 'https://nfd-parser.github.io/nfd-preview/preview.html?src=';
@@ -297,7 +298,10 @@ export default {
errorButtonVisible: false,
// 版本信息
buildVersion: ''
buildVersion: '',
// 演练场启用状态
playgroundEnabled: false
}
},
methods: {
@@ -316,7 +320,9 @@ export default {
// 主题切换
handleThemeChange(isDark) {
this.isDarkMode = isDark
if (document.body && document.body.classList) {
document.body.classList.toggle('dark-theme', isDark)
}
window.localStorage.setItem('isDarkMode', isDark)
},
@@ -394,7 +400,7 @@ export default {
const data = result.data
// 检查是否支持目录解析
const supportedPans = ["iz", "lz", "fj", "ye"]
const supportedPans = ["iz", "lz", "fj", "ye", "le"]
if (!supportedPans.includes(data.shareLinkInfo.type)) {
this.$message.error("当前网盘不支持目录解析")
return
@@ -552,6 +558,19 @@ export default {
}
},
// 检查演练场是否启用
async checkPlaygroundEnabled() {
try {
const result = await playgroundApi.getStatus()
if (result && result.data) {
this.playgroundEnabled = result.data.enabled === true
}
} catch (error) {
console.error('检查演练场状态失败:', error)
this.playgroundEnabled = false
}
},
// 新增切换目录树展示模式方法
setDirectoryViewMode(mode) {
this.directoryViewMode = mode
@@ -656,6 +675,9 @@ export default {
// 获取版本号
this.getBuildVersion()
// 检查演练场是否启用
this.checkPlaygroundEnabled()
// 自动读取剪切板
if (this.autoReadClipboard) {
this.getPaste()

View File

@@ -0,0 +1,135 @@
<template>
<div class="not-found-container">
<div class="not-found-content">
<div class="not-found-icon">
<el-icon :size="120"><DocumentDelete /></el-icon>
</div>
<h1 class="not-found-title">404</h1>
<p class="not-found-message">抱歉您访问的页面不存在</p>
<div class="not-found-actions">
<el-button type="primary" @click="goHome">返回首页</el-button>
<el-button @click="goBack">返回上一页</el-button>
</div>
</div>
</div>
</template>
<script>
import { useRouter } from 'vue-router'
import { DocumentDelete } from '@element-plus/icons-vue'
export default {
name: 'NotFound',
components: {
DocumentDelete
},
setup() {
const router = useRouter()
const goHome = () => {
router.push('/')
}
const goBack = () => {
if (window.history.length > 1) {
router.go(-1)
} else {
router.push('/')
}
}
return {
goHome,
goBack
}
}
}
</script>
<style scoped>
.not-found-container {
display: flex;
justify-content: center;
align-items: center;
min-height: 100vh;
/* background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); */
padding: 20px;
}
.not-found-content {
text-align: center;
background: white;
padding: 60px 40px;
border-radius: 20px;
box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
max-width: 500px;
width: 100%;
}
.not-found-icon {
color: #909399;
margin-bottom: 20px;
}
.not-found-title {
font-size: 72px;
font-weight: bold;
color: #303133;
margin: 0 0 20px 0;
line-height: 1;
}
.not-found-message {
font-size: 18px;
color: #606266;
margin: 0 0 40px 0;
}
.not-found-actions {
display: flex;
gap: 15px;
justify-content: center;
}
/* 暗色主题支持 */
.dark-theme .not-found-content {
background: #1d1e1f;
}
.dark-theme .not-found-title {
color: #e5eaf3;
}
.dark-theme .not-found-message {
color: #a3a6ad;
}
.dark-theme .not-found-icon {
color: #6c6e72;
}
/* 移动端适配 */
@media (max-width: 768px) {
.not-found-content {
padding: 40px 20px;
}
.not-found-title {
font-size: 48px;
}
.not-found-message {
font-size: 16px;
}
.not-found-actions {
flex-direction: column;
}
.not-found-actions .el-button {
width: 100%;
}
}
</style>

File diff suppressed because it is too large Load Diff

View File

@@ -61,12 +61,16 @@ export default {
}
},
toggleTheme(isDark) {
const html = document.documentElement;
const body = document.body;
if (html && body && html.classList && body.classList) {
if (isDark) {
document.body.classList.add('dark-theme')
document.documentElement.classList.add('dark-theme')
body.classList.add('dark-theme')
html.classList.add('dark-theme')
} else {
document.body.classList.remove('dark-theme')
document.documentElement.classList.remove('dark-theme')
body.classList.remove('dark-theme')
html.classList.remove('dark-theme')
}
}
}
},

View File

@@ -4,8 +4,10 @@ const path = require("path");
function resolve(dir) {
return path.join(__dirname, dir)
}
const CompressionPlugin = require('compression-webpack-plugin');
const FileManagerPlugin = require('filemanager-webpack-plugin')
const FileManagerPlugin = require('filemanager-webpack-plugin');
const MonacoEditorPlugin = require('monaco-editor-webpack-plugin');
module.exports = {
productionSourceMap: false, // 是否在构建生产包时生成sourceMap文件false将提高构建速度
@@ -43,7 +45,7 @@ module.exports = {
'@': resolve('src')
}
},
// Monaco Editor配置
// Monaco Editor配置 - 使用本地打包
module: {
rules: [
{
@@ -53,9 +55,18 @@ module.exports = {
]
},
plugins: [
new MonacoEditorPlugin({
languages: ['javascript', 'typescript', 'json'],
features: ['coreCommands', 'find', 'format', 'suggest', 'quickCommand'],
publicPath: process.env.NODE_ENV === 'production' ? './' : '/',
// Worker 文件输出路径
filename: 'js/[name].worker.js'
}),
new CompressionPlugin({
test: /\.js$|\.html$|\.css/, // 匹配文件
threshold: 10240 // 对超过10k文件压缩
threshold: 10240, // 对超过10k文件压缩
// 排除 js 目录下的 worker 文件Monaco Editor 使用 vs/assets 下的)
exclude: /js\/.*\.worker\.js$/
}),
new FileManagerPlugin({ //初始化 filemanager-webpack-plugin 插件实例
events: {
@@ -70,7 +81,11 @@ module.exports = {
{ source: '../webroot/nfd-front/view/.gitignore', options: { force: true } },
],
copy: [
{ source: './nfd-front', destination: '../webroot/nfd-front' }
// 复制 Monaco Editor 的 vs 目录到 js/vs
{
source: './node_modules/monaco-editor/min/vs',
destination: './nfd-front/js/vs'
}
],
archive: [ //然后我们选择dist文件夹将之打包成dist.zip并放在根目录
{

View File

@@ -0,0 +1,148 @@
# 脚本演练场功能测试报告
## 测试时间
2026-01-02 19:29
## 测试环境
- 服务地址: http://localhost:6401
- 后端版本: 0.1.8
- 前端版本: 0.1.9
## 测试结果总结
### ✅ 1. 服务启动测试
- **状态**: 通过
- **结果**: 服务成功启动监听端口6401
- **日志**:
```
演练场解析器加载完成,共加载 0 个解析器
数据库连接成功
启动成功: 本地服务地址: http://127.0.0.1:6401
```
### ✅ 2. 密码认证功能测试
- **状态**: 通过
- **测试项**:
- ✅ `/v2/playground/status` API正常响应
- ✅ `/v2/playground/login` 登录API正常响应
- ✅ 密码验证机制正常工作
- **结果**:
```json
{
"code": 200,
"msg": "登录成功",
"success": true
}
```
### ✅ 3. BUG1修复验证JS超时机制
- **状态**: 已修复
- **修复内容**:
- 在`JsPlaygroundExecutor`中实现了线程中断机制
- 使用`ScheduledExecutorService`和`Future.cancel(true)`确保超时后强制中断
- 超时时间设置为30秒
- **代码位置**: `parser/src/main/java/cn/qaiu/parser/customjs/JsPlaygroundExecutor.java`
- **验证**: 代码已编译通过,超时机制已实现
### ✅ 4. BUG2修复验证URL正则匹配验证
- **状态**: 已修复
- **修复内容**:
- 在`PlaygroundApi.test()`方法中添加了URL匹配验证
- 执行前检查分享链接是否匹配脚本的`@match`规则
- 不匹配时返回明确的错误提示
- **代码位置**: `web-service/src/main/java/cn/qaiu/lz/web/controller/PlaygroundApi.java:185-209`
- **验证**: 代码已编译通过,验证逻辑已实现
### ✅ 5. BUG3修复验证脚本注册功能
- **状态**: 已修复
- **修复内容**:
- 在`PlaygroundApi.saveParser()`中保存后立即注册到`CustomParserRegistry`
- 在`PlaygroundApi.updateParser()`中更新后重新注册
- 在`PlaygroundApi.deleteParser()`中删除时注销
- 在`AppMain`启动时加载所有已发布的解析器
- **代码位置**:
- `web-service/src/main/java/cn/qaiu/lz/web/controller/PlaygroundApi.java`
- `web-service/src/main/java/cn/qaiu/lz/AppMain.java`
- **验证**: 代码已编译通过,注册机制已实现
### ✅ 6. TypeScript功能移除
- **状态**: 已完成
- **移除内容**:
- ✅ 删除`web-front/src/utils/tsCompiler.js`
- ✅ 从`package.json`移除`typescript`依赖
- ✅ 从`Playground.vue`移除TypeScript相关UI和逻辑
- ✅ 删除后端TypeScript API端点
- ✅ 删除`PlaygroundTypeScriptCode`模型类
- ✅ 删除TypeScript相关文档文件
- **验证**: 代码已编译通过无TypeScript相关代码残留
### ✅ 7. 文本更新JS演练场 → 脚本演练场
- **状态**: 已完成
- **更新位置**:
- ✅ `Home.vue`: "JS演练场" → "脚本演练场"
- ✅ `Playground.vue`: "JS解析器演练场" → "脚本解析器演练场" (3处)
- **验证**: 前端已重新编译并部署到webroot
### ✅ 8. 移动端布局优化
- **状态**: 已保留
- **说明**: 移动端布局优化功能已从`copilot/add-playground-enhancements`分支合并,代码已保留
- **文档**: `web-front/PLAYGROUND_UI_UPGRADE.md`
## 编译验证
### 后端编译
```bash
mvn clean package -DskipTests -pl web-service -am
```
- **结果**: ✅ BUILD SUCCESS
- **时间**: 5.614秒
### 前端编译
```bash
npm run build
```
- **结果**: ✅ Build complete
- **输出**: `nfd-front`目录已自动复制到`../webroot/nfd-front`
## 待浏览器环境测试项
以下测试项需要在浏览器环境中进行完整验证需要session支持
1. **密码认证流程**
- 访问演练场页面
- 输入密码登录
- 验证登录后的访问权限
2. **BUG2完整测试**
- 在演练场输入脚本(带@match规则
- 输入不匹配的分享链接
- 验证是否显示匹配错误提示
3. **BUG3完整测试**
- 发布一个脚本
- 验证脚本是否立即可用
- 通过分享链接调用验证
4. **移动端布局测试**
- 使用移动设备或浏览器开发者工具
- 验证响应式布局是否正常
## 代码质量
- ✅ 无编译错误
- ✅ 无Linter错误
- ✅ 所有TODO任务已完成
- ✅ 代码已合并到main分支
## 总结
所有核心功能修复已完成并通过编译验证:
- ✅ BUG1: JS超时机制已实现
- ✅ BUG2: URL正则匹配验证已实现
- ✅ BUG3: 脚本注册功能已实现
- ✅ TypeScript功能已移除
- ✅ 文本更新已完成
- ✅ 代码已合并到main分支
服务已成功启动,可以进行浏览器环境下的完整功能测试。

View File

View File

@@ -122,13 +122,23 @@ public class AppMain {
if (parser.getBoolean("enabled", false)) {
try {
String jsCode = parser.getString("jsCode");
if (jsCode == null || jsCode.trim().isEmpty()) {
log.error("加载演练场解析器失败: {} - JavaScript代码为空", parser.getString("name"));
continue;
}
CustomParserConfig config = JsScriptMetadataParser.parseScript(jsCode);
CustomParserRegistry.register(config);
loadedCount++;
log.info("已加载演练场解析器: {} ({})",
config.getDisplayName(), config.getType());
} catch (Exception e) {
log.error("加载演练场解析器失败: {}", parser.getString("name"), e);
String parserName = parser.getString("name");
String errorMsg = e.getMessage();
log.error("加载演练场解析器失败: {} - {}", parserName, errorMsg, e);
// 如果是require相关错误提供更详细的提示
if (errorMsg != null && errorMsg.contains("require")) {
log.error("提示演练场解析器不支持CommonJS模块系统require请确保代码使用ES5.1语法");
}
}
}
}

View File

@@ -18,6 +18,12 @@ public class PlaygroundConfig {
*/
private static PlaygroundConfig instance;
/**
* 是否启用演练场
* 默认false不启用
*/
private boolean enabled = false;
/**
* 是否公开模式(不需要密码)
* 默认false需要密码访问
@@ -57,17 +63,20 @@ public class PlaygroundConfig {
PlaygroundConfig cfg = getInstance();
if (config != null && config.containsKey("playground")) {
JsonObject playgroundConfig = config.getJsonObject("playground");
cfg.enabled = playgroundConfig.getBoolean("enabled", false);
cfg.isPublic = playgroundConfig.getBoolean("public", false);
cfg.password = playgroundConfig.getString("password", "nfd_playground_2024");
log.info("Playground配置已加载: public={}, password={}",
cfg.isPublic, cfg.isPublic ? "N/A" : "已设置");
log.info("Playground配置已加载: enabled={}, public={}, password={}",
cfg.enabled, cfg.isPublic, cfg.isPublic ? "N/A" : "已设置");
if (!cfg.isPublic && "nfd_playground_2024".equals(cfg.password)) {
if (!cfg.enabled) {
log.info("演练场功能已禁用");
} else if (!cfg.isPublic && "nfd_playground_2024".equals(cfg.password)) {
log.warn("⚠️ 警告:您正在使用默认密码,建议修改配置文件中的 playground.password 以确保安全!");
}
} else {
log.info("未找到playground配置使用默认值: public=false");
log.info("未找到playground配置使用默认值: enabled=false, public=false");
}
}
}

View File

@@ -5,7 +5,6 @@ import cn.qaiu.lz.web.config.PlaygroundConfig;
import cn.qaiu.lz.web.model.PlaygroundTestResp;
import cn.qaiu.lz.web.service.DbService;
import cn.qaiu.parser.ParserCreate;
import cn.qaiu.parser.custom.CustomParserConfig;
import cn.qaiu.parser.custom.CustomParserRegistry;
import cn.qaiu.parser.customjs.JsPlaygroundExecutor;
import cn.qaiu.parser.customjs.JsPlaygroundLogger;
@@ -51,10 +50,23 @@ public class PlaygroundApi {
private static final String SESSION_AUTH_KEY = "playgroundAuthed";
private final DbService dbService = AsyncServiceUtil.getAsyncServiceInstance(DbService.class);
/**
* 检查Playground是否启用
*/
private boolean checkEnabled() {
PlaygroundConfig config = PlaygroundConfig.getInstance();
return config.isEnabled();
}
/**
* 检查Playground访问权限
*/
private boolean checkAuth(RoutingContext ctx) {
// 首先检查是否启用
if (!checkEnabled()) {
return false;
}
PlaygroundConfig config = PlaygroundConfig.getInstance();
// 如果是公开模式,直接允许访问
@@ -78,9 +90,11 @@ public class PlaygroundApi {
@RouteMapping(value = "/status", method = RouteMethod.GET)
public Future<JsonObject> getStatus(RoutingContext ctx) {
PlaygroundConfig config = PlaygroundConfig.getInstance();
boolean authed = checkAuth(ctx);
boolean enabled = config.isEnabled();
boolean authed = enabled && checkAuth(ctx);
JsonObject result = new JsonObject()
.put("enabled", enabled)
.put("public", config.isPublic())
.put("authed", authed);
@@ -92,6 +106,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/login", method = RouteMethod.POST)
public Future<JsonObject> login(RoutingContext ctx) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
Promise<JsonObject> promise = Promise.promise();
try {
@@ -143,6 +162,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/test", method = RouteMethod.POST)
public Future<JsonObject> test(RoutingContext ctx) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -346,6 +370,12 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/types.js", method = RouteMethod.GET)
public void getTypesJs(RoutingContext ctx, HttpServerResponse response) {
// 检查是否启用
if (!checkEnabled()) {
ResponseUtil.fireJsonResultResponse(response, JsonResult.error("演练场功能已禁用"));
return;
}
// 权限检查
if (!checkAuth(ctx)) {
ResponseUtil.fireJsonResultResponse(response, JsonResult.error("未授权访问"));
@@ -378,6 +408,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/parsers", method = RouteMethod.GET)
public Future<JsonObject> getParserList(RoutingContext ctx) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -390,6 +425,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/parsers", method = RouteMethod.POST)
public Future<JsonObject> saveParser(RoutingContext ctx) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -505,6 +545,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/parsers/:id", method = RouteMethod.PUT)
public Future<JsonObject> updateParser(RoutingContext ctx, Long id) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -586,6 +631,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/parsers/:id", method = RouteMethod.DELETE)
public Future<JsonObject> deleteParser(RoutingContext ctx, Long id) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -629,6 +679,11 @@ public class PlaygroundApi {
*/
@RouteMapping(value = "/parsers/:id", method = RouteMethod.GET)
public Future<JsonObject> getParserById(RoutingContext ctx, Long id) {
// 检查是否启用
if (!checkEnabled()) {
return Future.succeededFuture(JsonResult.error("演练场功能已禁用").toJsonObject());
}
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
@@ -636,146 +691,6 @@ public class PlaygroundApi {
return dbService.getPlaygroundParserById(id);
}
/**
* 保存TypeScript代码及其编译结果
*/
@RouteMapping(value = "/typescript", method = RouteMethod.POST)
public Future<JsonObject> saveTypeScriptCode(RoutingContext ctx) {
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
}
Promise<JsonObject> promise = Promise.promise();
try {
JsonObject body = ctx.body().asJsonObject();
Long parserId = body.getLong("parserId");
String tsCode = body.getString("tsCode");
String es5Code = body.getString("es5Code");
String compileErrors = body.getString("compileErrors");
String compilerVersion = body.getString("compilerVersion");
String compileOptions = body.getString("compileOptions");
Boolean isValid = body.getBoolean("isValid", true);
if (parserId == null) {
promise.complete(JsonResult.error("解析器ID不能为空").toJsonObject());
return promise.future();
}
if (StringUtils.isBlank(tsCode)) {
promise.complete(JsonResult.error("TypeScript代码不能为空").toJsonObject());
return promise.future();
}
if (StringUtils.isBlank(es5Code)) {
promise.complete(JsonResult.error("编译后的ES5代码不能为空").toJsonObject());
return promise.future();
}
// 代码长度验证
if (tsCode.length() > MAX_CODE_LENGTH || es5Code.length() > MAX_CODE_LENGTH) {
promise.complete(JsonResult.error("代码长度超过限制最大128KB").toJsonObject());
return promise.future();
}
JsonObject tsCodeInfo = new JsonObject();
tsCodeInfo.put("parserId", parserId);
tsCodeInfo.put("tsCode", tsCode);
tsCodeInfo.put("es5Code", es5Code);
tsCodeInfo.put("compileErrors", compileErrors);
tsCodeInfo.put("compilerVersion", compilerVersion);
tsCodeInfo.put("compileOptions", compileOptions);
tsCodeInfo.put("isValid", isValid);
tsCodeInfo.put("ip", getClientIp(ctx.request()));
dbService.saveTypeScriptCode(tsCodeInfo).onSuccess(result -> {
promise.complete(result);
}).onFailure(e -> {
log.error("保存TypeScript代码失败", e);
promise.complete(JsonResult.error("保存失败: " + e.getMessage()).toJsonObject());
});
} catch (Exception e) {
log.error("解析请求参数失败", e);
promise.complete(JsonResult.error("解析请求参数失败: " + e.getMessage()).toJsonObject());
}
return promise.future();
}
/**
* 根据parserId获取TypeScript代码
*/
@RouteMapping(value = "/typescript/:parserId", method = RouteMethod.GET)
public Future<JsonObject> getTypeScriptCode(RoutingContext ctx, Long parserId) {
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
}
return dbService.getTypeScriptCodeByParserId(parserId);
}
/**
* 更新TypeScript代码
*/
@RouteMapping(value = "/typescript/:parserId", method = RouteMethod.PUT)
public Future<JsonObject> updateTypeScriptCode(RoutingContext ctx, Long parserId) {
// 权限检查
if (!checkAuth(ctx)) {
return Future.succeededFuture(JsonResult.error("未授权访问").toJsonObject());
}
Promise<JsonObject> promise = Promise.promise();
try {
JsonObject body = ctx.body().asJsonObject();
String tsCode = body.getString("tsCode");
String es5Code = body.getString("es5Code");
String compileErrors = body.getString("compileErrors");
String compilerVersion = body.getString("compilerVersion");
String compileOptions = body.getString("compileOptions");
Boolean isValid = body.getBoolean("isValid", true);
if (StringUtils.isBlank(tsCode)) {
promise.complete(JsonResult.error("TypeScript代码不能为空").toJsonObject());
return promise.future();
}
if (StringUtils.isBlank(es5Code)) {
promise.complete(JsonResult.error("编译后的ES5代码不能为空").toJsonObject());
return promise.future();
}
// 代码长度验证
if (tsCode.length() > MAX_CODE_LENGTH || es5Code.length() > MAX_CODE_LENGTH) {
promise.complete(JsonResult.error("代码长度超过限制最大128KB").toJsonObject());
return promise.future();
}
JsonObject tsCodeInfo = new JsonObject();
tsCodeInfo.put("tsCode", tsCode);
tsCodeInfo.put("es5Code", es5Code);
tsCodeInfo.put("compileErrors", compileErrors);
tsCodeInfo.put("compilerVersion", compilerVersion);
tsCodeInfo.put("compileOptions", compileOptions);
tsCodeInfo.put("isValid", isValid);
dbService.updateTypeScriptCode(parserId, tsCodeInfo).onSuccess(result -> {
promise.complete(result);
}).onFailure(e -> {
log.error("更新TypeScript代码失败", e);
promise.complete(JsonResult.error("更新失败: " + e.getMessage()).toJsonObject());
});
} catch (Exception e) {
log.error("解析请求参数失败", e);
promise.complete(JsonResult.error("解析请求参数失败: " + e.getMessage()).toJsonObject());
}
return promise.future();
}
/**
* 获取客户端IP
*/

View File

@@ -1,55 +0,0 @@
package cn.qaiu.lz.web.model;
import cn.qaiu.db.ddl.Constraint;
import cn.qaiu.db.ddl.Length;
import cn.qaiu.db.ddl.Table;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
/**
* 演练场TypeScript代码实体
* 用于保存用户编写的TypeScript源代码
* 与PlaygroundParser关联存储原始TS代码和编译后的ES5代码
*/
@Data
@Table("playground_typescript_code")
public class PlaygroundTypeScriptCode {
private static final long serialVersionUID = 1L;
@Constraint(autoIncrement = true, notNull = true)
private Long id;
@Constraint(notNull = true)
private Long parserId; // 关联的解析器ID外键
@Length(varcharSize = 65535)
@Constraint(notNull = true)
private String tsCode; // TypeScript原始代码
@Length(varcharSize = 65535)
@Constraint(notNull = true)
private String es5Code; // 编译后的ES5代码
@Length(varcharSize = 2000)
private String compileErrors; // 编译错误信息(如果有)
@Length(varcharSize = 32)
private String compilerVersion; // 编译器版本
@Length(varcharSize = 1000)
private String compileOptions; // 编译选项JSON格式
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTime = new Date(); // 创建时间
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date updateTime; // 更新时间
private Boolean isValid = true; // 编译是否成功
@Length(varcharSize = 64)
private String ip; // 创建者IP
}

View File

@@ -50,19 +50,4 @@ public interface DbService extends BaseAsyncService {
*/
Future<JsonObject> getPlaygroundParserById(Long id);
/**
* 保存TypeScript代码及其编译结果
*/
Future<JsonObject> saveTypeScriptCode(JsonObject tsCodeInfo);
/**
* 根据parserId获取TypeScript代码
*/
Future<JsonObject> getTypeScriptCodeByParserId(Long parserId);
/**
* 更新TypeScript代码
*/
Future<JsonObject> updateTypeScriptCode(Long parserId, JsonObject tsCodeInfo);
}

View File

@@ -265,114 +265,4 @@ public class DbServiceImpl implements DbService {
return promise.future();
}
@Override
public Future<JsonObject> saveTypeScriptCode(JsonObject tsCodeInfo) {
JDBCPool client = JDBCPoolInit.instance().getPool();
Promise<JsonObject> promise = Promise.promise();
String sql = """
INSERT INTO playground_typescript_code
(parser_id, ts_code, es5_code, compile_errors, compiler_version,
compile_options, create_time, is_valid, ip)
VALUES (?, ?, ?, ?, ?, ?, NOW(), ?, ?)
""";
client.preparedQuery(sql)
.execute(Tuple.of(
tsCodeInfo.getLong("parserId"),
tsCodeInfo.getString("tsCode"),
tsCodeInfo.getString("es5Code"),
tsCodeInfo.getString("compileErrors"),
tsCodeInfo.getString("compilerVersion"),
tsCodeInfo.getString("compileOptions"),
tsCodeInfo.getBoolean("isValid", true),
tsCodeInfo.getString("ip")
))
.onSuccess(res -> {
promise.complete(JsonResult.success("保存TypeScript代码成功").toJsonObject());
})
.onFailure(e -> {
log.error("saveTypeScriptCode failed", e);
promise.fail(e);
});
return promise.future();
}
@Override
public Future<JsonObject> getTypeScriptCodeByParserId(Long parserId) {
JDBCPool client = JDBCPoolInit.instance().getPool();
Promise<JsonObject> promise = Promise.promise();
String sql = "SELECT * FROM playground_typescript_code WHERE parser_id = ? ORDER BY create_time DESC LIMIT 1";
client.preparedQuery(sql)
.execute(Tuple.of(parserId))
.onSuccess(rows -> {
if (rows.size() > 0) {
Row row = rows.iterator().next();
JsonObject tsCode = new JsonObject();
tsCode.put("id", row.getLong("id"));
tsCode.put("parserId", row.getLong("parser_id"));
tsCode.put("tsCode", row.getString("ts_code"));
tsCode.put("es5Code", row.getString("es5_code"));
tsCode.put("compileErrors", row.getString("compile_errors"));
tsCode.put("compilerVersion", row.getString("compiler_version"));
tsCode.put("compileOptions", row.getString("compile_options"));
var createTime = row.getLocalDateTime("create_time");
if (createTime != null) {
tsCode.put("createTime", createTime.toString().replace("T", " "));
}
var updateTime = row.getLocalDateTime("update_time");
if (updateTime != null) {
tsCode.put("updateTime", updateTime.toString().replace("T", " "));
}
tsCode.put("isValid", row.getBoolean("is_valid"));
tsCode.put("ip", row.getString("ip"));
promise.complete(JsonResult.data(tsCode).toJsonObject());
} else {
promise.complete(JsonResult.data(null).toJsonObject());
}
})
.onFailure(e -> {
log.error("getTypeScriptCodeByParserId failed", e);
promise.fail(e);
});
return promise.future();
}
@Override
public Future<JsonObject> updateTypeScriptCode(Long parserId, JsonObject tsCodeInfo) {
JDBCPool client = JDBCPoolInit.instance().getPool();
Promise<JsonObject> promise = Promise.promise();
String sql = """
UPDATE playground_typescript_code
SET ts_code = ?, es5_code = ?, compile_errors = ?, compiler_version = ?,
compile_options = ?, update_time = NOW(), is_valid = ?
WHERE parser_id = ?
""";
client.preparedQuery(sql)
.execute(Tuple.of(
tsCodeInfo.getString("tsCode"),
tsCodeInfo.getString("es5Code"),
tsCodeInfo.getString("compileErrors"),
tsCodeInfo.getString("compilerVersion"),
tsCodeInfo.getString("compileOptions"),
tsCodeInfo.getBoolean("isValid", true),
parserId
))
.onSuccess(res -> {
promise.complete(JsonResult.success("更新TypeScript代码成功").toJsonObject());
})
.onFailure(e -> {
log.error("updateTypeScriptCode failed", e);
promise.fail(e);
});
return promise.future();
}
}

View File

@@ -15,6 +15,8 @@ proxyConf: server-proxy
# JS演练场配置
playground:
# 是否启用演练场默认false不启用
enabled: true
# 公开模式默认false需要密码访问设为true则无需密码
public: false
# 访问密码,建议修改默认密码!

View File

@@ -4,7 +4,7 @@ server-name: Vert.x-proxy-server(v4.1.2)
proxy:
- listen: 6401
# 404的路径
page404: webroot/err/404.html
page404: webroot/nfd-front/index.html
static:
path: /
add-headers: