Compare commits

..
265 Commits
Author SHA1 Message Date
lu7213 1daf477899 添加提示 2026-11-15 10:32:23 -05:00
lu7213 4c4fd99fc4 去掉依赖 2026-11-15 09:54:17 -05:00
lu7213 7cb16bc84d 去掉依赖 2026-11-15 09:45:14 -05:00
lu7213 79183ee0d9 手续费说明 2026-11-12 02:54:44 -05:00
lu7213 72ad60cb60 添加测试 2026-11-07 06:50:14 -05:00
lu7213 68bb68b2b4 点击立即检查,没有及时更新时间 问题修复 2026-11-07 04:21:06 -05:00
lu7213 f55f4c2961 执行器检查逻辑修改 2026-11-07 03:23:30 -05:00
lu7213 f3f4a306e5 usdt-ui在全局配置那边显示执行器的可用状态显示,需要定期去检查,如果不在线,则只能通过输入配置密码,如果下线了又重新上线需要重新启用执行器功能。 2026-11-06 23:07:07 -05:00
lu7213 637be83684 添加详细日志 2026-11-06 22:35:49 -05:00
lu7213 21a23c9f55 https访问方式修改 2026-11-06 21:47:17 -05:00
lu7213 7202f0783a 错误处理 2026-11-06 21:32:26 -05:00
lu7213 cf68147d08 那执行器改成http,支付系统指定http调用和https调用,如果https,使用nginx转发,提供nginx配置文件。 2026-11-06 21:18:56 -05:00
lu7213 ee9b209e3d usdt-chain-executor 添加联通测试接口,如果CHAIN\_EXECUTOR\_ENABLED=true ,在系统启动时,添加调用验证,并打印调用日志,作为服务可用的日志 2026-11-06 20:24:08 -05:00
lu7213 5ca2cc5202 租赁配置 2026-11-05 11:05:09 -05:00
lu7213 1c2d15b2a9 接入租赁平台 2026-11-05 09:20:29 -05:00
lu7213 c035263bc6 模块拆分 2026-11-04 01:56:48 -05:00
lu7213 b2e3706553 去掉异常 2026-11-04 01:38:46 -05:00
lu7213 d0d4a2eeb6 方法调用 2026-11-04 01:37:09 -05:00
lu7213 ac66f98c6a 报送接口 2026-11-04 01:11:24 -05:00
lu7213 d92583d0e4 私库发布地址 2026-11-03 22:57:08 -05:00
lu7213 c94f0f14d2 如果归集任务下面的子项都取消了,归集任务可以直接关闭 2026-11-03 10:15:02 -05:00
lu7213 62f43056e2 usdt归集明细页面usdtTaskItem和USDTmanage/usdtTaskItem,添加取消归集明细任务功能。 2026-11-03 07:58:08 -05:00
lu7213 2870c3fb6c 在租赁用户和供应商用户首页,添加导出对账单功能。包括资金账号出入账汇总和明细。 2026-11-03 05:37:41 -05:00
lu7213 611e020f38 使用impeccable skill 开发和优化页面,之后的页面开发和优化也都使用impeccable ski,1.创建收益结算单,通过勾选租赁订单的方式,不要用输入,要过滤掉已经结算的。2.供应商usdt-ui\src\views\system\rentSettlement\下面新增供应商结算页面,添加结算申请按钮。要求页面美观,交互友好 2026-11-03 03:44:36 -05:00
lu7213 be6ac23844 建议统一成“收益结算 + 提现付款” 按建议的逻辑帮我实现。 2026-11-03 02:48:03 -05:00
lu7213 1151dc2535 回调问题处理 2026-11-02 22:34:18 -05:00
lu7213 43dec4c94b 405问题日志添加 2026-11-02 21:17:15 -05:00
lu7213 4818f25d8f 回调验证和调试日志 2026-11-02 20:25:09 -05:00
lu7213 f15f4162eb 允许http回调 2026-11-02 10:02:29 -05:00
lu7213 cfb6a9e389 允许内网回调 2026-11-02 09:12:50 -05:00
lu7213 d910c1afe8 时间问题处理 2026-11-02 02:20:47 -05:00
lu7213 41190a25ae 快照修复 跨区块时重新采集整套数据,最多尝试 3 次。
每次重试重新查询全部数据,不能拼接不同尝试的结果。
记录每次耗时、前后高度及最终失败原因。
全部失败后保留旧快照,等待下一轮。
如果持续跨区块,则检查 RPC 延迟;仅靠重试无法解决长期慢响应。
2026-11-02 01:23:42 -05:00
lu7213 b84675df3c 添加快照日志 2026-11-01 22:43:41 -05:00
lu7213 547a04d12b 租赁模块-地址上链下单成功,节点在线,设置也都正确,钱包资源也充足,但是节点没有接收这个类型的订单,无法上链成功。问题修复 2026-11-01 22:16:58 -05:00
lu7213 3ca5ff43ea 服务端添加一个webhook通用的调试免登接口,主要是打印数据,和校验webhook是否有生效用的 2026-11-01 21:45:33 -05:00
lu7213 285d08b00d 申请部分/全额退款 2026-10-31 20:46:07 -04:00
lu7213 acf461cec4 1. 优化管理员租赁订单页面proxyRent/rentOrder/index.vue,添加统计信息 2. 新增供应商和租赁用户租赁订单页面,要求只能查询到所属自己的订单,放在proxyRent/rentOrder/user/下面。 2026-10-31 20:31:23 -04:00
lu7213 90e74603bb 核验完成时已经超过23:16:54,租期已结束,这个要添加冗余时间,应为实际链上操作是需要时间的,默认冗余时间是3分钟,可以配置 2026-10-31 20:09:36 -04:00
lu7213 1538cd0819 尽量服用,和优化采样区块,交易所在区块的资源参数 获取不需要每次获取有下单租赁订单都获取一遍,应该是全局异步获取是不是就可以,帮我设计合理方案。 和清理逻辑 2026-10-31 19:10:27 -04:00
lu7213 13665668ac 1. rent-agent-java 添加订单调试日志和可以删除本地订单记录 2. 心跳消息不用这么频繁,接收订单即使一点即可。 2026-10-31 06:53:16 -04:00
lu7213 baffaefc67 本地广播和出租表示都开启了,帮我添加日志,方便排查问题,另外用户下租赁订单,到节点接收订单消息间隔时间太久了,帮我缩短,提供配置项,默认10左右要能收到订单。 2026-10-31 06:20:25 -04:00
lu7213 849aff5ee1 供应商节点认证的租赁地址,rent-agent-java 当节点启动时,需要认证本地的配置的私钥和云端认证的地址是否一致。 2026-10-31 01:20:53 -04:00
lu7213 4b6ea31e6a 1. 请在views/rental/nodeDetail 页面添加出租设置功能 2. 一个租赁节点只能绑定一个钱包地址,添加验证和页面布局,请修改views/rental/nodeDetail 页面,并添加换绑功能。 2026-10-30 20:25:31 -04:00
lu7213 624110e43c views/rental/nodeDetail 租赁地址,添加可以删除待验证的地址功能 2026-10-30 19:32:11 -04:00
lu7213 dafa5261bd 创建租赁订单,不要传递套餐id,改成选择网络和资源类型,修改对应的接口,和api-debugger调试页面,和套餐页面的立即租赁的页面入参。 2026-10-30 08:31:27 -04:00
lu7213 8605c946c9 签名问题处理 2026-10-30 07:34:07 -04:00
lu7213 e5820e36e7 创建地址上链订单,需要判断该地址是否已经是地址地址,如果是,不允许创建。 2026-10-30 05:31:19 -04:00
lu7213 22735b80c0 页面输入 API 地址、Key、Secret,无需配置文件。
支持全部7个商户接口及 JSON 参数编辑。
自动签名,展示响应、耗时、请求摘要和错误信息。
支持套餐→报价→下单→查询的连续调试。
Secret 仅保存在页面内存中,创建订单前需确认。
2026-10-30 04:39:27 -04:00
lu7213 f837befe99 提交冻结USDT,同一用户全网络仅允许一笔进行中提现。
支持后台、Telegram审核;拒绝后释放冻结。
支持管理员填写Hash核验到账、链上监听自动到账,记录到账方式和操作日志。
严格核对网络、付款方、收款方、金额及审核后交易时间,防止重复扣款。
已补齐前端申请、记录、审核、扫描状态和交易明细页面。
2026-10-30 03:44:03 -04:00
lu7213 dc2564b1d4 帮我把地址上链接口 单独分出来一个接口,同时修改对应文档 2026-10-29 21:50:00 -04:00
lu7213 fbc72b5b57 固定转入 1 TRX,费用为“本金折价 USDT + 固定服务费”。
下单冻结资金,链上独立确认后扣款并记录供应商收入。
支持 NILE、主网独立配置;未知交易不退款、不重复构建。
已补充清晰注释、分阶段脱敏日志和已确认交易哈希展示。
2026-10-29 19:52:51 -04:00
lu7213 1286f0df81 跳转到支付,请跳转新的窗口 2026-10-29 07:22:01 -04:00
lu7213 89e807828c 修改默认地址 2026-10-29 07:02:20 -04:00
lu7213 ac682a28c2 跳转到支付二维码页面 2026-10-29 06:39:48 -04:00
lu7213 98533d8c24 添加日志 2026-10-29 06:27:44 -04:00
lu7213 beb7f6de8a 添加调试日志 2026-10-29 05:21:55 -04:00
lu7213 36e3b046a0 支付客户端现在支持独立信任 nginx 的 TLS 证书,保留域名校验,不修改全局信任库 2026-10-29 05:12:09 -04:00
lu7213 d88ad8996a 添加日志 2026-10-29 04:07:57 -04:00
lu7213 b6b9120b85 创建充值单后立即调用 /api/v1/order/create-transaction。
成功后自动跳转 public/usdtCheckout?tradeId=...。
收银台按交易号展示网络、金额、二维码、地址及支付状态。
失败时显示处理阶段,支持使用原单重试,避免重复创建。
2026-10-29 03:46:59 -04:00
lu7213 76f9e62253 请添加日志输出定位排查。 2026-10-29 02:45:36 -04:00
lu7213 e73f099734 租赁资金账户资金充值功能,对接项目的支付接口,application-rental.yml添加配置NILE和主网的对接配置 2026-10-29 02:16:04 -04:00
lu7213 911a3634ee 修正RPC响应失败 2026-10-28 11:12:50 -04:00
lu7213 1e79e836e8 添加日志 2026-10-28 10:16:55 -04:00
lu7213 28d0517294 proxyRent/rentAccount 页面列表补充资金账户所属用户的用户名信息 2026-10-28 09:42:47 -04:00
lu7213 e14e7c51db 页面调整 2026-10-26 20:07:56 -04:00
lu7213 5bc5a91b3b 添加套餐计费模式 2026-10-26 11:23:58 -04:00
lu7213 829f357bae 超过512kib错误处理 2026-10-26 09:05:35 -04:00
lu7213 6358dff6e2 上限扩展到512kb 2026-10-26 08:50:52 -04:00
lu7213 02dd5668d5 供应商和租赁账户首页不合理,帮我重新设计,应该是包含各自角色相关的统计图表信息,和监控状态信息。 2026-10-26 00:36:07 -04:00
lu7213 8dcb313454 1.PROXY\_ACCOUNT 租赁账户,首页中的租赁套餐 ,立即租赁按钮不可操作,帮我完成这个功能,点击立即租赁,跳出输入地址,apiKey,apiSecret,时长,对接地址,回调地址等,然后显示预计费用,然后调用租赁api 2. 帮我实现回调地址同步和异步验证的demo的controller 2026-10-25 22:14:04 -04:00
lu7213 127d575a1c PROXY\_ACCOUNT 租赁账户,首页中的租赁套餐,不应该用列表的的方式,应为一个userId用户对应一个套餐,请修正,要求页面美观,用户交互友好 2026-10-25 11:41:36 -04:00
lu7213 0fd0450ddb 目前还缺少,套餐绑定关系的逻辑,请单独一张表,并且引导添加user\_id系统用户绑定套餐逻辑,并且在创建租赁订单,自动关联应用对应user\_id的套餐信息。 另外给我一个脚本,创建3个套餐的脚本。 2026-10-25 11:20:45 -04:00
lu7213 a83e1fef40 1.租赁应用详情创建凭证,第一次没有显示api Secret ,使用密码框,请修正 2. 提供凭证删除功能。 2026-10-25 10:31:57 -04:00
lu7213 6321cde4c0 1.应用详情页面时间显示不对,显0-0-0 0:0:0 2.提供应用删除功能,删除前需要判断应用下面没有任何关联订单和凭证等信息 2026-10-25 10:06:33 -04:00
lu7213 101140f3c2 租赁账户PROXY\_ACCOUNT中的rentApp租赁应用页面需要有引导用户创建应用功能,和应用详情,应用详情中需要能够创建对应的应用凭证,要求页面美观,用户交互友好。 2026-10-25 01:47:02 -04:00
lu7213 b3419aa389 自行建设,补充这部分功能,给出具体的表设计和代码实现,同云端服务端一起部署 2026-10-24 04:36:20 -04:00
lu7213 cab8056412 rentNode供应节点,没有注册功能,请帮我添加 2026-10-23 21:18:49 -04:00
lu7213 a2d33190ac 说明添加 2026-10-23 21:00:50 -04:00
lu7213 eb8fe3c83f 供应商登入后的页面rentAccount,是列表,应该一个供应商对应一个rentAccount,请帮我修改,如果该供应商没有rentAccount,页面需要引导创建。 2026-10-23 03:38:34 -04:00
lu7213 dcffc60d80 1.供应商角色是PROXY\_SUPPLIER,租赁账户角色编码是PROXY\_ACCOUNT,帮我实现供应商角色和租赁账户后台首页
2\. 给出供应商角色和租赁账户所有权限配置接口的插入sql。
2026-10-23 02:31:41 -04:00
lu7213 fcff9fa48d 文档调整 2026-10-22 23:21:24 -04:00
lu7213 2a9f1c4c7c 代理租赁实现 2026-10-22 19:58:57 -04:00
lu7213 1c0544afe0 基础代码生成 2026-10-22 11:09:36 -04:00
lu7213 352d7d023f 归集任务删除,只允许删除被拒绝状态的归集任务,删除归集任务,要同时删除归集任务下的明细数据 2026-10-21 09:41:41 -04:00
lu7213 33481ab6eb 归集任务删除,只允许删除被拒绝状态的归集任务,删除归集任务,要同时删除归集任务下的明细数据 2026-10-21 09:39:50 -04:00
lu7213 f6babe9358 usdt_orders 收款订单禁止修改,只允许删除过期的订单 2026-10-21 07:29:09 -04:00
lu7213 cc5fe279e9 添加登入添加Google Authenticator TOTP六位动态码 授权登。2. 保留Google登录并支持动态码登录 2026-10-21 04:03:06 -04:00
lu7213 42a06f7e4d 已修复 ID 精度丢失 2026-10-21 03:05:04 -04:00
lu7213 0f921d4d9f api/system/usdtTaskItem/user/2006935749495414800 报错Request method 'POST' not supported 2026-10-21 02:07:34 -04:00
lu7213 0708f6f1c8 google认证修改 2026-10-20 21:25:30 -04:00
lu7213 42d5a71314 添加日志 2026-10-19 11:53:46 -04:00
lu7213 13ba3a5fdb 添加日志 2026-10-19 11:06:33 -04:00
lu7213 9c29db1245 代码格式化 2026-10-19 10:44:24 -04:00
lu7213 e4ac32e8d7 address和USDTmanage/address token管理页面,参考归集任务页面布局和功能,添加统计功能,优化页面布局。 商户和管理员都去掉删除和修改,商户的详情页面去掉对地址的各种金额操作,只保留刷新链上数据功能。 2026-10-19 05:33:31 -04:00
lu7213 c516124eff address和USDTmanage/address token管理页面,参考归集任务页面布局和功能,添加统计功能,优化页面布局。 商户和管理员都去掉删除和修改,商户的详情页面去掉对地址的各种金额操作,只保留刷新链上数据功能 2026-10-19 04:42:18 -04:00
lu7213 37754f3af0 订单页面修改 2026-10-19 03:35:47 -04:00
lu7213 f5b1a9f638 商户也要可以配置所属apps的api_secret和api_key 2026-10-19 01:37:21 -04:00
lu7213 bdad69ba77 api/system/apps/user 商户创建应用报错 2026-10-18 22:46:17 -04:00
lu7213 6bdf96ab70 代码格式化 2026-10-18 10:26:02 -04:00
lu7213 64ba6cd28e 添加对账单 2026-10-18 09:37:46 -04:00
lu7213 e62e2fe969 管理员可以对apps应用的usdtBalance添加和减少,但是需要记录流水表,保证对账单正确。 2026-10-18 09:08:35 -04:00
lu7213 7a7222e69c 平台支付总览 ,可以统计所有应用,也可以选择某个应用,然后查看总览,请帮我添加该功能 2026-10-18 05:21:01 -04:00
lu7213 e987be3a03 平台支付总览,应该加上全局配置,主账号的账户信息。 2026-10-18 02:06:32 -04:00
lu7213 705609282f 首页优化 2026-10-17 22:22:05 -04:00
lu7213 c58e55a2e1 删除旧 PayoutOrderController,功能统一到 [UsdtPayoutOrderController.java (line 23)](D:/myprojects/usdt/myEpusdt/ruoyi-system/src/main/java/com/ruoyi/system/controller/UsdtPayoutOrderController.java:23)。
删除旧 system/payout 页面及 API。
管理员和商户页面统一使用共享组件 [PayoutOrderView.vue](D:/myprojects/usdt/usdt-ui/src/views/system/usdtPayoutOrder/components/PayoutOrderView.vue)。
管理员支持查询、统计、详情、导出、审核、密码广播和失败重试。
商户仅支持查询、统计和详情,无增删改、审核及执行权限。
增加状态统计、完成 USDT/TRX 金额、手续费汇总。
增加应用、用户、订单号、币种、状态、时间范围等查询条件。
后端关联返回应用名称和用户名。
通用新增、修改、删除接口已移除,防止绕过冻结余额和审核状态机。
更新 [usdt_payout_menu.sql](D:/myprojects/usdt/myEpusdt/sql/usdt_payout_menu.sql),可幂等迁移旧 system:payout:* 权限。
2026-10-17 12:43:47 -04:00
lu7213 1eca7a77bc 代付订单 2026-10-17 12:06:14 -04:00
lu7213 d81820c74f apps_balance_ledger.payout_order_id 已补充实体、Mapper、查询条件、流水写入及前端展示。
实现代付创建、余额冻结、后台/Telegram 审核、配置密码广播、链上确认。
链上成功后原子更新冻结余额,并幂等写入 PAYOUT_SUCCESS、PAYOUT_FEE 流水。
支持执行失败重新输入密码重试,并防止并发重复广播。
查询成功订单返回 RSA 签名 redirect_url,异步通知主动 POST,支持多实例防重复领取。
新增管理员代付页面,支持分页查询、审核、广播、失败重试和详情查看。
SysUsdtDemoController 已包含代付创建、查询、回调及跳转验签示例。
新增 [usdt_payout_order.sql](D:/myprojects/usdt/myEpusdt/sql/usdt_payout_order.sql) 和 [usdt_payout_menu.sql](D:/myprojects/usdt/myEpusdt/sql/usdt_payout_menu.sql)。
2026-10-17 10:54:08 -04:00
lu7213 9c879c1312 新增代付订单 SQL、实体和 Mapper。
开放接口增加 /api/v1/payout/create 和 /api/v1/payout/query。
pay_usdt_num 按 TRX 手续费处理。
USDT 代付冻结 USDT 本金和 TRX 手续费。
TRX 代付冻结 TRX 本金与手续费总额。
创建时锁定 apps 行,避免与代收入账并发覆盖余额。
支持 appId + order_id 幂等。
审核通过进入待执行,拒绝时原路解冻。
已提供 [usdt_payout_order.sql](D:/myprojects/usdt/myEpusdt/sql/usdt_payout_order.sql)。
JDK 8 多模块编译通过。
2026-10-17 09:59:49 -04:00
lu7213 14b3093177 支付页面返回地址修改 2026-10-17 01:56:45 -04:00
lu7213 3161365ec8 添加返回支付地址 2026-10-17 00:48:44 -04:00
lu7213 361bfd6421 同步跳转验签 2026-10-17 00:37:29 -04:00
lu7213 454da449c4 验签修改 2026-10-17 00:25:07 -04:00
lu7213 9daba4a98e 跳转验签 2026-10-17 00:11:59 -04:00
lu7213 bd1231c2dd apikey已经配置,请完成上卖弄检查,也校验gRPC 连通性 2026-10-16 23:07:48 -04:00
lu7213 d2abfd88af 代码格式化 2026-10-16 22:37:43 -04:00
lu7213 43f7decaa5 apikey 2026-10-16 22:36:05 -04:00
lu7213 0d0642d312 多域名兼容链上获取数据 2026-10-16 11:27:52 -04:00
lu7213 2601bc898a 获取链上信息兼容 2026-10-16 10:19:14 -04:00
lu7213 ceb8807273 支持http 2026-10-15 23:22:32 -04:00
lu7213 77eece5e90 feat: support notify url in checkout 2026-10-15 21:44:34 -04:00
lu7213 79f829c12e feat: add controlled aggregation task deletion 2026-10-15 10:42:05 -04:00
lu7213 2a85724613 feat: support payment redirect url 2026-10-15 04:56:00 -04:00
lu7213 ad965d086b feat: switch payment callbacks to rsa signatures 2026-10-15 04:37:41 -04:00
lu7213 a75869342c fix: verify payment callbacks 2026-10-15 04:06:20 -04:00
lu7213 6d868552eb 代码格式化 2026-10-15 03:18:20 -04:00
lu7213 b52c8d7dbf feat: add public usdt user registration 2026-10-15 02:54:25 -04:00
lu7213 2316d48224 回调路径修改 2026-10-15 02:22:09 -04:00
lu7213 9a1bc6b8dc feat: add telegram webhook registration 2026-10-15 00:15:06 -04:00
lu7213 dd28f3c0cb fix: prevent duplicate pending aggregation tasks 2026-10-14 22:49:52 -04:00
lu7213 0bad1e2a40 依赖调整 2026-10-14 21:15:21 -04:00
lu7213 d014cd15f0 google登入验证 2026-10-14 21:01:36 -04:00
lu7213 f69926dee6 基础代码生成 2026-10-14 11:22:52 -04:00
lu7213 5e63bb6add telegram审核功能 2026-10-14 10:58:41 -04:00
lu7213 2d88b77325 orders 添加字段wallet_user_name 2026-10-14 05:32:05 -04:00
lu7213 abdafd5c9d 流水记录优化 2026-10-14 04:47:06 -04:00
lu7213 dcd8eadd20 支付成功页面添加 2026-10-14 04:04:49 -04:00
lu7213 935307e9ca 定时间隔修改 2026-10-14 03:51:10 -04:00
lu7213 3bdaa080e3 添加日志 2026-10-14 03:40:48 -04:00
lu7213 d7bcbb4e1e 优化支付订单成功逻辑 2026-10-14 03:38:27 -04:00
lu7213 cef85b81ef USDT创建订单示例 2026-10-13 21:10:27 -04:00
lu7213 15cc537639 apps流水逻辑 2026-10-13 11:24:20 -04:00
lu7213 0ff174e872 订单支付成功时,事务化写入 USDT 收入流水。
归集明细成功时,事务化写入 USDT 支出流水。
使用唯一幂等键防止订单重扫、归集重试产生重复流水。
新增按应用、币种、时间范围以及日/月/年维度的统计接口。
管理员和商户接口均改为只读,移除流水新增、修改、删除入口。
商户查询由后端强制限定当前用户。
2026-10-13 10:32:18 -04:00
lu7213 8cc7bd0c17 流水表基础代码生成 2026-10-13 09:33:50 -04:00
lu7213 cdf32a86cb 添加冻结金额字段 2026-10-13 05:15:37 -04:00
lu7213 2602897c23 全局usdt,trx账户 2026-10-13 03:57:17 -04:00
lu7213 15a80de8a6 全局配置主账号详情和操作 2026-10-13 02:03:01 -04:00
lu7213 eeb108c963 比较直错误处理 2026-10-12 23:34:42 -04:00
lu7213 183bc87997 归集任务修改 2026-10-12 22:37:19 -04:00
lu7213 38d038115a 归集任务逻辑 2026-10-12 11:51:52 -04:00
lu7213 18e3eb8ff0 去掉无用代码 2026-10-12 09:41:53 -04:00
lu7213 430582253b 添加校验 2026-10-12 09:10:32 -04:00
lu7213 219bc724b2 添加校验和日志 2026-10-12 08:39:10 -04:00
lu7213 0ed50c6ddd 预估是否需要消耗trx 2026-10-12 05:26:59 -04:00
lu7213 40088cd0f0 添加日志打印 2026-10-12 04:21:28 -04:00
lu7213 1202a7a9d3 代码优化 2026-10-12 04:04:07 -04:00
lu7213 3f161c86d1 添加一场处理 2026-10-12 03:32:57 -04:00
lu7213 df5512838b 新增代理明细列表 2026-10-12 03:26:55 -04:00
lu7213 81febe2c56 添加代理记录相关表 2026-10-12 02:18:23 -04:00
lu7213 b2ab430eb6 新增字段 2026-10-11 23:56:56 -04:00
lu7213 ffbacce650 优化sql 2026-10-11 12:02:58 -04:00
lu7213 0bc37fc5cc 钱包逻辑调整 2026-10-11 11:38:27 -04:00
lu7213 5530885c79 钱包操作 2026-10-11 01:29:23 -04:00
lu7213 becfbd230b 自动获取信息 2026-10-10 21:50:24 -04:00
lu7213 4048428169 优化代码 2026-10-10 20:57:36 -04:00
lu7213 ed738d3da6 改成十分钟国企 2026-10-10 11:51:19 -04:00
lu7213 32e7466615 定时人物迁移 2026-10-10 11:50:35 -04:00
lu7213 c0868f9d8f 添加比率 2026-10-10 11:36:20 -04:00
lu7213 5be292c009 添加免登入 2026-10-10 10:55:10 -04:00
lu7213 8ebf5f383d 新增接口 2026-10-10 10:54:12 -04:00
lu7213 a2be79377b api开放钱包创建接口 2026-10-10 08:46:53 -04:00
lu7213 658e6ccf1e 添加子账号逻辑 2026-10-10 05:22:05 -04:00
lu7213 35c7bcc8aa apps添加私钥 2026-10-10 03:33:51 -04:00
lu7213 051f78b59c 新增apiKey和相关逻辑 2026-10-09 10:58:25 -04:00
lu7213 bc772b8b15 api key功能开发 2026-10-09 03:12:37 -04:00
lu7213 e6ad3bd85c 公钥、私钥现已统一使用标准 PEM 格式显示 2026-10-08 23:34:36 -04:00
lu7213 410d777c0b apps创建唯一性调整 2026-10-08 21:18:59 -04:00
lu7213 221b7c4f96 去掉用户接口 2026-10-08 11:20:05 -04:00
lu7213 f5801dc84a 接口新增 2026-10-08 11:18:22 -04:00
lu7213 02664623f7 商户应用管理 2026-10-08 09:45:11 -04:00
lu7213 71035c7fa0 字段新增 2026-10-08 05:26:34 -04:00
lu7213 cf8220edbd 全局配置逻辑实现 2026-10-08 04:36:53 -04:00
lu7213 da4af93a1e 去掉无用代码 2026-10-07 23:55:16 -04:00
lu7213 b5c2050ca9 去掉无用代码 2026-10-07 23:50:49 -04:00
lu7213 4bcb64383f 路径调整 2026-10-07 23:28:43 -04:00
lu7213 ce9d974b57 添加全局配置代码 2026-10-07 23:25:47 -04:00
lu7213 00a4a08c70 新增tron加密逻辑 2026-10-07 23:03:33 -04:00
lu7213 009955d560 123 2026-09-27 19:18:44 -04:00
lu7213 0df6716cc3 234 2026-09-26 21:40:53 -04:00
lu7213 05b5a3d3cc 123 2026-09-26 11:31:17 -04:00
lu7213 8d2c4e0159 域名修改 2026-09-15 10:15:01 -04:00
lu7213 06830916f6 123 2026-08-13 12:10:15 -04:00
lu7213 77557ce4af 123 2026-08-13 02:47:05 -04:00
lu7213 f0b438eb6c 1 2026-08-13 02:26:24 -04:00
lu7213 cf9c801b93 123 2026-08-12 21:57:54 -04:00
lu7213 951912687a 11 2026-08-12 21:38:13 -04:00
lu7213 dcd51431f6 添加跟踪号 2026-08-12 21:36:41 -04:00
lu7213 e1f4ff5f86 123 2026-08-12 05:43:41 -04:00
lu7213 a28607a070 123 2026-08-12 05:38:45 -04:00
lu7213 f25ff6eb3b 添加接口 2026-08-12 05:20:52 -04:00
lu7213 9b78c4a8a5 123 2026-08-12 04:57:54 -04:00
lu7213 80ef537bbe 123 2026-08-12 03:39:26 -04:00
lu7213 85643b2cad 123 2026-07-28 04:19:11 -04:00
lu7213 4bf3e66a3a 123 2026-07-09 15:03:36 +08:00
lu7213 6ac13817a4 auth2 2026-07-08 12:01:01 +08:00
lu7213 d35402cc6a 123 2026-07-08 11:39:43 +08:00
lu7213 90d74de0d8 123 2026-07-07 17:21:13 +08:00
lu7213 07f5922a7d 123 2026-06-18 20:18:20 -04:00
lu7213 d56e6e41c4 123 2026-06-15 01:56:53 -04:00
lu7213 b5ed55b2a0 12 2026-05-21 18:18:37 -04:00
lu7213 e5d6c3d655 234 2026-05-20 13:21:50 -04:00
lu7213 2175e97068 123 2026-05-20 14:42:45 +08:00
lu7213 eaeb9876ca Merge remote-tracking branch 'origin/dm' 2026-05-20 11:49:23 +08:00
lu7213 b348805137 添加驗證 2026-05-20 11:04:01 +08:00
lu7213 208376906d 123 2026-05-20 09:17:24 +08:00
lu7213 1f2533c354 1 2026-05-14 23:48:34 -04:00
lu7213 69706cfbcd 1 2026-05-14 23:46:01 -04:00
lu7213 89e9cccf1d 11 2026-05-14 22:42:45 -04:00
lu7213 e22f6b510b 123 2026-05-14 09:36:29 -04:00
lu7213 1365ef660b 1 2026-05-14 09:21:40 -04:00
lu7213 a14741aec7 123 2026-05-14 08:32:37 -04:00
lu7213 5a341e6bb1 123 2026-05-14 01:07:17 -04:00
lu7213 1af9609d27 11 2026-05-13 21:41:36 -04:00
lu7213 4477f41795 1 2026-05-13 09:20:12 -04:00
lu7213 f8f93d3286 1 2026-05-13 06:37:19 -04:00
lu7213 6ecf7f713a 1123 2026-05-13 03:31:36 -04:00
lu7213 66ab89fa93 123 2026-05-12 09:00:03 -04:00
lu7213 1f08e30d3a 1 2026-05-12 03:59:18 -04:00
lu7213 7e30e92e7b 1 2026-05-12 03:54:04 -04:00
lu7213 8f71a35ee6 权限控制 2026-05-12 02:40:14 -04:00
lu7213 db12a62698 添加权限控制 2026-05-12 02:28:10 -04:00
lu7213 f91140ea33 123 2026-05-11 00:43:00 -04:00
lu7213 7530acde5b 213 2026-05-10 11:05:52 -04:00
lu7213 2707f3e7bb 123 2026-05-10 07:02:32 -04:00
lu7213 a19f0e8e46 123 2026-05-10 06:53:27 -04:00
lu7213 b77f5b0701 123 2026-05-10 05:16:10 -04:00
lu7213 36e5ab3308 123 2026-05-10 04:52:50 -04:00
lu7213 d4b1bc60b1 操作控制 2026-05-09 23:56:16 -04:00
lu7213 b8cea4af69 123 2026-05-06 09:38:05 -04:00
lu7213 f084d04808 123 2026-05-05 06:23:54 -04:00
lu7213 1957b0a1ed 1 2026-05-05 05:24:12 -04:00
lu7213 8cfd57aaa4 1 2026-05-05 05:21:30 -04:00
lu7213 6fbe9e42ab 1 2026-05-05 05:17:20 -04:00
lu7213 82153966f8 123 2026-05-05 05:17:00 -04:00
lu7213 48eb39722e 2 2026-05-05 05:02:56 -04:00
lu7213 37d6b21115 123 2026-05-05 04:07:13 -04:00
lu7213 d294ec17e0 123 2026-04-29 11:11:30 -04:00
lu7213 da952a1103 Merge remote-tracking branch 'origin/main' 2026-04-28 23:58:49 -04:00
lu7213 c45553b2bd 1 2026-04-28 23:58:39 -04:00
lu7213 ad4493fc8c 1 2026-04-29 11:57:56 +08:00
lu7213 2c43c99fa6 示例添加 2026-03-10 11:14:10 +08:00
lu7213 b54ecf1b6e 1111 2026-03-09 22:33:05 +08:00
lu7213 89987ee139 1 2026-03-07 22:52:06 +08:00
lu7213 7883a39de8 1 2026-03-07 21:51:23 +08:00
lu7213 1639b1e5fd 截图逻辑 2026-03-07 16:17:48 +08:00
lu7213 30da249b6b 11 2026-03-07 13:34:04 +08:00
lu7213 6c73388fdd 111 2026-03-05 22:42:55 +08:00
lu7213 7cd697187c 111 2026-03-03 09:39:33 +08:00
lu7213 68a2b4f68c 111 2025-12-09 20:47:23 +08:00
lu7213 a8e2a507d9 添加资金流水等表逻辑 2025-12-05 11:51:24 +08:00
lu7213 8d3cb18a46 去掉分表逻辑 2025-12-03 11:31:14 +08:00
lu7213 2d0a09c734 111 2025-12-02 23:41:21 +08:00
lu7213 8bc4dcb363 11 2025-12-02 23:31:23 +08:00
lu7213 345f906c35 111 2025-12-02 23:07:47 +08:00
lu7213 81eca8933a 111 2025-12-02 23:05:53 +08:00
Administrator f9334dfc75 Initial commit 2025-12-02 15:03:20 +00:00
726 changed files with 528518 additions and 24 deletions

No files matched your search

+41 -23
View File
@@ -1,26 +1,44 @@
# ---> Java
# Compiled class file
*.class
######################################################################
# Build Tools
# Log file
.gradle
/build/
!gradle/wrapper/gradle-wrapper.jar
target/
!.mvn/wrapper/maven-wrapper.jar
######################################################################
# IDE
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
nbproject/private/
build/*
nbbuild/
dist/
nbdist/
.nb-gradle/
######################################################################
# Others
*.log
*.xml.versionsBackup
*.swp
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.nar
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
replay_pid*
!*/build/*.java
!*/build/*.html
!*/build/*.xml
@@ -0,0 +1,8 @@
# 当前证据
扩展静态扫描完成:466 个运行依赖 JAR、125848 个条目,目标域名/IP 的明文、UTF-16、Base64 和百分号编码均未命中,扫描错误 0;阴性结果不能排除动态拼接、数据库配置或实际部署差异。
前轮已确认 AWS ELB 域名为 grpc.nile.trongrid.io 的 CNAME。
前轮扫描运行依赖未找到两个 Pinggy 域名明文。org.json:json:19970182 含授权校验逻辑,但尚未与 Pinggy 关联。
当前 RuoYiApplication 启动扫描 com.ruoyi、com.luqj 和 org.code.modules.plugins,插件目录来自 plugin.base.dir。独立执行器有另一个启动入口,也应支持同一诊断。
当前没有运行中的业务 Java 服务,仅有 IDEA Maven JVM,无法直接取得正在复现异常的 Java 调用栈。
对本地 D:/luqj-plugins 插件 JAR 和 D:/configs/license.dll 扫描明文、UTF-16 与 Base64 字符串,未命中目标域名。
主入口原本仅经本地 ruoyi-framework 间接依赖 ruoyi-system,Maven reactor 先编译 admin,新增诊断引用因此读取旧本地 system JAR。需要显式依赖 system 保证使用本轮编译的源码。
@@ -0,0 +1,7 @@
# 排查进度
最终相关回归:91 项,0 失败,0 错误,1 项跳过;其中诊断独立 JVM 测试 5 项全部通过,新增验证已有安全策略拒绝读取诊断配置时仍正常启动。
扩展扫描 466 个依赖 JAR 的 125848 条目,无目标字符串命中、无扫描错误。已完成中文启用与判读文档;仍需实际复现环境输出才能归因具体包。
已读取两个入口、POM、配置和当前工作区规则。保留已有修改,不执行 Git 历史查询。
计划使用 JDK 8 SecurityManager 的 checkConnect 观察 DNS/连接;默认关闭,已存在安全管理器时拒绝覆盖,仅记录指定域名及调用来源,不能作为沙箱。
4 个独立 JVM 测试全部通过:默认关闭、保留原安全管理器、本地真实 DNS 的动态 JAR 来源、域名边界和 200 事件输出上限。测试无可疑域名外联。
首次全模块编译因 admin 在 system 之前构建而找不到新类;以显式依赖修复构建顺序,不修改业务。
@@ -0,0 +1,11 @@
# Pinggy 异常外联定位
## Next Step
在实际复现服务启用诊断,采集首条完整调用栈以确认请求来源;本地实现与验证已完成。
### Phase 1: 当前调用链与证据检查
**Status:** complete
### Phase 2: 定位代码与隔离验证
**Status:** complete
### Phase 3: 扩展扫描、文档与结果交付
**Status:** complete
## Boundaries
不改业务逻辑,不主动请求可疑域名,不启动带真实数据库及链上调度的完整服务。
@@ -0,0 +1,107 @@
// Generate reviewable apply_patch input; this script never writes project files.
const fs = require('fs');
const path = require('path');
const root = path.resolve(__dirname, '../..');
const base = path.join(root, 'ruoyi-system/src/main/java/com/ruoyi/system');
const labels = {
RentAccount: 'UserId', RentApp: 'Name', RentNode: 'Name',
RentCredential: 'ApiKey', RentEvent: 'EventNo', RentLedger: 'BusinessKey',
RentNonce: 'Nonce', RentOrder: 'OrderNo', RentPackage: 'Name',
RentRefund: 'RefundNo', RentSettlement: 'SettlementNo',
RentSettlementItem: 'OrderId', RentTask: 'TaskNo',
RentTransaction: 'TxId', RentWallet: 'Address', RentWebhook: 'EventNo'
};
const read = p => fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n');
function blockEnd(text, open) {
let depth = 0;
let quote = null;
for (let i = open; i < text.length; i++) {
const c = text[i];
if (quote) {
if (c === '\\') i++;
else if (c === quote) quote = null;
} else if (c === '"' || c === "'") quote = c;
else if (c === '{') depth++;
else if (c === '}' && --depth === 0) return i + 1;
}
throw new Error('Unclosed generated block');
}
function removeBlocks(text, pattern, includeDoc = false) {
let match;
while ((match = pattern.exec(text))) {
let start = match.index;
// The regex ends at the method/if brace. Mapping paths can contain {id}.
const open = start + match[0].lastIndexOf('{');
const end = blockEnd(text, open);
if (includeDoc) {
const docStart = text.lastIndexOf('/**', start);
const docEnd = text.lastIndexOf('*/', start);
if (docStart >= 0 && docEnd > docStart && !text.slice(docEnd + 2, start).trim()) {
start = text.lastIndexOf('\n', docStart) + 1;
}
}
text = text.slice(0, start) + text.slice(end).replace(/^\n/, '');
pattern.lastIndex = 0;
}
return text;
}
const model = process.argv[2];
if (!(model in labels)) throw new Error('Explicit rental model required');
const plus = model + 'Plus';
const domain = read(path.join(base, 'domain', plus + '.java'));
const hasUser = /private Long userId;/.test(domain);
const label = labels[model];
if (!new RegExp('\\bget' + label + '\\(').test(domain)) throw new Error('Invalid display field');
let patch = '*** Begin Patch\n';
const changed = [];
for (const [folder, name] of [
['controller', model + 'Controller.java'],
['service', 'I' + model + 'Service.java'],
['service/impl', model + 'ServiceImpl.java']
]) {
const file = path.join(base, folder, name);
const before = read(file);
let after = before;
if (!hasUser) {
if (folder === 'controller') {
after = removeBlocks(after,
/^"\)\n[ \t]*public AjaxResult user\w+\([^\n]*\)\s*\{/m);
after = removeBlocks(after,
/^[ \t]*@PreAuthorize\("@ss\.hasPermi\('[^'\n]*:user-[^'\n]*'\)"\)[\s\S]*?public [^{]+\{/m,
true);
}
if (folder === 'service/impl') {
after = removeBlocks(after, /^[ \t]*if\s*\(\s*isUser\s*\)\s*\{/m);
after = removeBlocks(after, /^[ \t]*private void checkUser(?:Plus)?\([^)]*\)\s*\{/m);
after = after.replace('import com.ruoyi.common.utils.SecurityUtils;\n', '');
after = after.replaceAll(plus + '::getUserId,', '');
}
after = after.replace(/\s*,\s*boolean isUser/g, '');
after = after.replace(/,\s*(?:false|true)(?=[,)])/g, '');
if (/\b(?:isUser|checkUser|checkUserPlus|getUserId|setUserId|userGetInfo|userRemove)\b/.test(after)) {
throw new Error('Unexpected user-scope reference in ' + file);
}
}
if (label !== 'Name') {
after = after.replaceAll(plus + '::getName', plus + '::get' + label);
after = after.replace('selectItem.setName(item.getName());',
'selectItem.setName(String.valueOf(item.get' + label + '()));');
}
if (after === before) continue;
const oldLines = before.trimEnd().split('\n');
const newLines = after.trimEnd().split('\n');
let start = 0;
while (start < Math.min(oldLines.length, newLines.length) && oldLines[start] === newLines[start]) start++;
let oldEnd = oldLines.length, newEnd = newLines.length;
while (oldEnd > start && newEnd > start && oldLines[oldEnd - 1] === newLines[newEnd - 1]) { oldEnd--; newEnd--; }
const contextStart = Math.max(0, start - 3);
const contextEnd = Math.min(oldLines.length, oldEnd + 3);
patch += '*** Update File: ' + file.replaceAll('\\', '/') + '\n@@\n';
patch += oldLines.slice(contextStart, start).map(l => ' ' + l + '\n').join('');
patch += oldLines.slice(start, oldEnd).map(l => '-' + l + '\n').join('');
patch += newLines.slice(start, newEnd).map(l => '+' + l + '\n').join('');
patch += oldLines.slice(oldEnd, contextEnd).map(l => ' ' + l + '\n').join('');
changed.push(path.relative(root, file));
}
patch += '*** End Patch';
process.stdout.write(JSON.stringify({ model, hasUser, label, changed, patch: changed.length ? patch : null }));
+46
View File
@@ -0,0 +1,46 @@
# 审查发现
## 已确认范围
- 当前租赁文件为未跟踪的新设计:sql/rent_init.sql、docs/rental/schema-design.md、docs/rental/table-functional-flows.md。
- 未检索到租赁 Java 服务,当前修改应保持为设计文件,不宣称修复运行时行为。
- 15 表 V2.1 使用逻辑外键,MySQL 5.7 不执行 CHECK。
## 待修正缺口
1. 部分退款被 webhook(order_id,event_type) 唯一键阻止;退款缺少独立持久业务编号及审批/幂等对象。
2. 结算没有付款中状态,人工付款与数据库确认间可能被拒绝并释放来源。
3. 原文允许手续费返还供应商,但净应收/结算来源公式没有增加返还额,造成账单无法结算该金额。
4. 钱包预留释放和异步快照刷新缺少区块及版本屏障,可能用旧快照重新出租已委托本金。
5. 同地址对同资源多单仅描述应用串行,缺少可持久的互斥来源,原始关系增量和回收归属难以证明。
6. 服务起点使用核验完成时间,核验延迟会推迟租期并使经济事实不一致。
7. 无持久下单等待截止,回收任务未显式关联原委托交易;任务无 network 字段,跨表核验靠 JSON。
8. ITronService已有getCanDelegatedMaxSize只读查询;NILE/MAINNET通用delegateResourceV2写死lock=true、86400,与任意租期不兼容,租赁不可直接复用。
## V2.2决策
- 增加rent_refund至16表,部分退款使用独立幂等编号,回调按业务事件键和订单序号去重。
- 订单地址对占位持续至本金回收且资源恢复;任务按钱包及资源类型串行,未知不释放。
- 钱包确认区块下界、快照CAS及失效屏障共同防旧查询覆盖。
- 首版仅非锁定委托,避免不同业务租期被链上锁定合并;多单同地址对排队或另选钱包。
- 结算PAYING在人工付款前持久化,付款未知保留原授权编号与来源。
## 资源
## 后续生成代码审查
- 用户已新增16模块Controller/Domain/Mapper/Service/XML;之前未实现状态仅属于设计复核时点。
- 只有RentApp、RentNode、RentAccount实体直接有userId,其余13模块模板错误生成相同用户过滤/赋值/检查方法。
- 无userId模块的/user路由不能简单移除过滤后保留,应删除错误路由及无效isUser参数,保留后台PreAuthorize权限。
- 多个Controller和Service还引用不存在的getName;下拉显示使用真实业务编号或钱包地址。
- sql/rent_init.sql
- docs/rental/schema-design.md
- docs/rental/table-functional-flows.md
## 三端实现结论(2026-10-22)
- 当前工作区已实现后端、Vue及本地Node Agent,不再仅为设计文档。完整运行与接口说明见docs/rental/implementation.md。
- 普通TRON RPC不能提供任意确认区块的历史资源状态,自动交付核验依赖独立历史证明服务;缺失时必须人工隔离,不能以当前资源比率假装历史交付成功。
- 原交易未知时保留资金与SUN占位,恢复仅查询或重播原签名交易,不能创建替代交易。
- 本地验证结果与外部验收边界见docs/rental/validation-implementation.md;未对现有数据库或链上资产执行操作。
+61
View File
@@ -0,0 +1,61 @@
# 工作记录
## 三端功能实现(2026-10-22)
- 用户授权按 V2.2 实现前端、后端与本地 Agent Node,保持 JDK8 和清晰中文注释。
- 已新增事务仓储、四域HMAC/AES-GCM、订单冻结、供应商应收/手续费、退款/结算审批、钱包挑战、任务调度/回收/核验、WSS会话及回调队列实现。
- 当前工作区16个租赁API JS已经存在(用户新增),前端将按最新内容接业务接口。
- 三端主体已实现;16个管理页及3个用户页替换为统一业务组件,原页面备份在C:\Users\Administrator\AppData\Local\Temp\rental-vue-before-business-73daa005b1164f1283061eab6e6919b7。
- JDK8系统模块编译与管理端全依赖编译通过;第一轮后端10项、第二轮15项隔离测试通过;Agent10项测试通过;前端独立输出目录生产构建通过。
- 已修正MySQL JSON规范化后的任务HMAC原文、Socket旧会话fencing、未知构建禁止重建、本地落盘失败后重新fsync、失败扫描饥饿及BIGINT/USDT/UTC响应精度。
- 新增菜单SQL、外部配置profile、Agent环境模板和完整运行文档;不执行数据库初始化、主网或NILE广播。真实MySQL/浏览器TronLink/WSS公网/历史节点仍未联调。
- 首轮JDK8编译发现Trident地址类型与Base58方法差异,正在修正;尚未完成三端验证。
- 前端上轮删除13个无直接userId的用户CRUD页面,保留16个管理页面和3个用户页面;缺少租赁API JS。
- 复用当前计划,不查询 Git 历史,不操作真实链上交易或现有数据库。
## 设计审查
- 已读取项目规则、15 表 SQL 及业务说明;仅以当前工作区为依据,无 Git 历史查询。
- 已确认凭证、防重放、冻结、任务、链上独立核验的主框架可保留。
- 正在将退款、付款副作用、资源快照及地址对互斥缺口收敛为 V2.2 修改。
## SQL与文档修正
- SQL已升级16表V2.2;新增退款单、两个占位及唯一键、快照区块屏障、PAYING授权、显式回收来源。
- 主设计及逐表说明已同步,新建business-review-v2.2.md记录发现、事务协议、迁移要求及验收场景。
- MySQL方言解析:SQLGlot 26.33.0解析16条CREATE,无回退命令。
- 首轮12项离线检查有2项失败:验证记录链接尚未创建,以及用例对89字符示例错误要求超过96;已创建记录并删除无依据长度断言,保留160上限及跨账户去重检查。
- pip工具下载一次超时后自动重试成功;不加入项目依赖。
## 验证完成
- 最终SQLGlot严格MySQL方言解析16条CREATE TABLE,无不支持回退。
- 最终python docs/rental/check_schema.py运行12项全部通过。
- 明确补充原生委托费用预算非协议fee_limit硬上限、新任务RENT_TASK_V2、旧HMAC原文兼容。
- 已完成schema-design.md、table-functional-flows.md同步及business-review-v2.2.md、validation-v2.2.md、check_schema.py交付文件。
- 没有修改已有数据库、支付服务、Java/前端实现,没有执行链上操作。真实MySQL并发及NILE验收仍需实现阶段完成,验证记录明确此边界。
## 后续:用户新增16表基础代码后的清理
- 仅RentApp/RentNode/RentAccount直接有userId。其余13模块删除错误用户过滤、赋值、检查辅助方法及isUser参数,同步Service接口/实现/Controller调用。
- 无userId模块删除7个/user端点/模块(共91个),保留后台接口及PreAuthorize;未将无过滤接口继续暴露为用户接口。
- 12个无name模型的Controller改用真实字段;无name且无userId的11个Service下拉显示和检索改用编号、地址等字段。
- 共修改40个Java文件;Domain、Mapper、SQL、前端不作改动。
- 首轮机械删除误判注解中的{id}边界,已修正脚本并清理两类残片;静态检查确认每个无userId模块仅8个后台端点,有userId模块保留7个用户端点,所有端点均有权限注解。
- 16模块158处方法引用存在性检查通过;13个无userId模块不再有isUser、getUserId/setUserId、checkUser等模板引用。
- 默认JDK17触发现有Lombok模块访问错误,切换JAVA_HOME=C:\Java\jdk1.8.0_481后,mvn -o -pl ruoyi-system -am -DskipTests compile -q退出0。
## 三端业务实现完成(2026-10-22)
### 后续:角色首页及权限配置
- 供应商PROXY_SUPPLIER及租赁账户PROXY_ACCOUNT分别展示专属首页,双角色支持切换,其他用户保留支付首页。
- 拆分app/node/wallet创建及account开通权限,保留旧运营注册权限兼容;新增真实注解SpEL权限隔离测试2项通过,原租赁专项23项通过。
- 新增sql/rent_role_permissions.sql,包含幂等角色、首页菜单、按钮及角色菜单插入;未执行数据库写入,不分配用户,不授予运营财务权限。
- 新增docs/rental/role-permissions.md,记录全部业务角色接口映射、执行顺序和验证边界。
- 新增租赁后端业务服务、JWT/HMAC入口、WSS任务通道、资金事务及独立链上核验;旧通用CRUD入口禁用,防止绕过业务规则。
- Vue统一业务组件接入16个运营及3个用户菜单;本地Node24 Agent实现加密持久化、先落盘再广播、原交易恢复及默认禁广播。
- 最终修正调度主键轮转及恢复失败退避,避免故障记录阻塞后续扫描;Java四空格格式整理,拆分多变量声明。
- JDK8后端回归88项,0失败、4项原有测试跳过;最终格式整理后租赁专项23项再次通过。Agent10项、Schema12项通过,Vue ESLint及生产构建通过。
- 运行说明implementation.md及验证记录validation-implementation.md已完成。没有执行数据库脚本或真实广播;MySQL、公网WSS、浏览器TronLink和NILE联调仍属部署验收边界,历史证明服务为外部依赖。
+68
View File
@@ -0,0 +1,68 @@
# 能量与带宽租赁设计复核
## Goal
修正租赁 SQL 与业务文档中的资金、调度、交易恢复、回收及退款协同缺口,不操作现有数据库。
## Next Step
三端实现及本地验证完成;实际数据库迁移、公网WSS及NILE端到端验收按部署说明执行。
## Current Phase
Phase 7:验证和部署文档
### Phase 5: 业务后端与可靠任务
- **Status:** complete
- 实现应用/节点认证、钱包授权、资金事务、订单、调度、独立核验、回收、退款、结算与回调。
### Phase 6: 本地 Agent 与 Vue
- **Status:** complete
- 本地持久化原签名交易、默认禁广播、WSS 恢复;前端补齐 API、业务操作及权限。
### Phase 7: 验证和部署文档
- **Status:** complete
- JDK8 编译、资金/并发/恢复测试、前端构建及 Agent 测试;记录未获得外部环境的验证边界。
### Phase 1: 设计审查
- **Status:** complete
- 核对初始化 SQL、两份文档、现有调用与工具可用性。
### Phase 2: 修正 SQL 与文档
- **Status:** complete
- 采用明确可实现的约束,同步字段、状态、关系及异常流程。
### Phase 3: 验证与交付
- **Status:** complete
- 验证 DDL、唯一约束、典型并发/资金场景及文档一致性,说明验证边界。
## Decisions Made
### Phase 4: 生成代码清理
- **Status:** complete
- 无 userId 的13个模块删除直接用户过滤和/user路由,保留后台权限注解;有字段的3个模块保留。
- 按实际业务字段修正不存在的name引用;不扩展为关联归属授权实现。
| 决策 | 原因 |
| --- | --- |
| 只修改当前租赁设计及相关说明 | 用户请求为 SQL 和文档修正,当前无租赁 Java 服务 |
| 不执行现有数据库迁移 | 未掌握部署表及数据,初始化脚本不能直接升级旧表 |
## Errors Encountered
| 错误 | 处理 |
| --- | --- |
| 首次技能输出局部截断 | 补读被截断部分,完成技能阅读 |
| PowerShell下rg目录通配符不是实际目录 | 改为项目根搜索并按扩展名过滤 |
| Docker Linux引擎未启动,无本地MySQL命令 | 尝试独立临时工具进行DDL解析,不能宣称真实MySQL验收 |
| PowerShell foreach输出直接管道语法错误 | 将foreach包在数组表达式后输出 |
| 清理脚本误把路径{id}当作方法块开始 | 改为正则匹配末尾的真实方法大括号,删除残片并重新检查端点权限及编译 |
| 默认JDK17编译与现有Lombok处理器不兼容 | 使用项目要求的JDK1.8.0_481,离线Maven编译成功 |
+20
View File
@@ -0,0 +1,20 @@
The MIT License (MIT)
Copyright (c) 2018 RuoYi
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+122 -1
View File
@@ -1,2 +1,123 @@
# usdt
## 平台简介
临时排查未知域名外联可启用[网络调用来源诊断](docs/network-request-trace.md),记录 DNS 调用栈和实际加载的 JAR 来源;默认关闭,适用于 JDK 8。
TRON 密钥生成、地址校验和离线签名恢复通过现有 Trident 与 `TronKey` 适配实现,不再依赖 `tron-wallet-cli`;钱包派生路径、地址编码和投票交易行为保持兼容。后端请使用 JDK 8 编译。
归集、代付支持可选的[双平台资源租赁](docs/resource-rental.md):人工确认租赁后等待链上资源到账,再输入密码广播;独立执行器自动异步准备资源。默认关闭,启用前执行增量SQL并配置加密的平台凭据。
新增可选的独立[内网链上执行服务](docs/chain-executor.md):默认关闭,保留原配置密码方式;启用前执行 `sql/chain_executor.sql`,并按文档配置仅内网监听、来源白名单、TLS、服务凭据及执行器环境密码。
归集任务全部有效明细取消后,取消事务自动将主任务标记为 `status=4(已关闭)`,保留审核状态和历史记录。部分取消不会关闭任务;已关闭任务不能再次执行或审核,且不再占用待执行任务名额。执行开始及结束采用条件更新,防止旧执行快照覆盖关闭状态。无需修改数据库表结构。
归集明细支持管理端及用户端取消:`POST /system/usdtTaskItem/{id}/cancel`、`POST /system/usdtTaskItem/user/{id}/cancel`,分别复用明细 edit/user-edit 权限,用户端校验任务及明细归属。仅待执行明细可取消,取消保留审计记录且不可恢复。明细状态为 `0=待执行、1=成功、2=失败、3=已取消、4=执行中`;执行前以条件更新抢占明细,取消成功后不会广播。无需变更表结构。
用户套餐绑定与默认套餐下单:旧库先执行 [绑定表增量SQL](sql/rent_user_package.sql),三个NILE示例套餐见 [套餐初始化脚本](sql/rent_seed_three_packages.sql),管理及API说明见 [用户套餐绑定](docs/rental/user-package-bindings.md)。升级后未绑定用户不能创建新租赁订单。
能量与带宽租赁模块:三端配置、业务API、Agent安装及验收边界见[租赁实现说明](docs/rental/implementation.md);初始化结构见[租赁SQL](sql/rent_init.sql),菜单权限见[租赁菜单SQL](sql/rent_menu.sql)。本地Agent可选Node.js或[JDK17 + JavaFX20.0.2桌面版](../rent-agent-java/README.md)。默认不启动租赁调度与节点通道,本地Agent默认禁止广播。
susdt是一套全部开源的快速开发平台,毫无保留给个人及企业免费使用。
* 前端采用Vue、Element UI。
* 后端采用Spring Boot、Spring Security、Redis & Jwt。
* 权限认证使用Jwt,支持多终端认证系统。
* 支持加载动态权限菜单,多方式轻松权限控制。
* 高效率开发,使用代码生成器可以一键生成前后端代码。
* 提供了单应用版本[RuoYi-Vue-fast](https://github.com/yangzongzhuan/RuoYi-Vue-fast),Oracle版本[RuoYi-Vue-Oracle](https://github.com/yangzongzhuan/RuoYi-Vue-Oracle),保持同步更新。
* 不分离版本,请移步[RuoYi](https://gitee.com/y_project/RuoYi),微服务版本,请移步[RuoYi-Cloud](https://gitee.com/y_project/RuoYi-Cloud)
* 特别鸣谢:[element](https://github.com/ElemeFE/element),[vue-element-admin](https://github.com/PanJiaChen/vue-element-admin),[eladmin-web](https://github.com/elunez/eladmin-web)。
* 阿里云折扣场:[点我进入](http://aly.ruoyi.vip),腾讯云秒杀场:[点我进入](http://txy.ruoyi.vip)&nbsp;&nbsp;
* 阿里云优惠券:[点我领取](https://www.aliyun.com/minisite/goods?userCode=brki8iof&share_source=copy_link),腾讯云优惠券:[点我领取](https://cloud.tencent.com/redirect.php?redirect=1025&cps_key=198c8df2ed259157187173bc7f4f32fd&from=console)&nbsp;&nbsp;
## 内置功能
1. 用户管理:用户是系统操作者,该功能主要完成系统用户配置。
2. 部门管理:配置系统组织机构(公司、部门、小组),树结构展现支持数据权限。
3. 岗位管理:配置系统用户所属担任职务。
4. 菜单管理:配置系统菜单,操作权限,按钮权限标识等。
5. 角色管理:角色菜单权限分配、设置角色按机构进行数据范围权限划分。
6. 字典管理:对系统中经常使用的一些较为固定的数据进行维护。
7. 参数管理:对系统动态配置常用参数。
8. 通知公告:系统通知公告信息发布维护。
9. 操作日志:系统正常操作日志记录和查询;系统异常信息日志记录和查询。
10. 登录日志:系统登录日志记录查询包含登录异常。
11. 在线用户:当前系统中活跃用户状态监控。
12. 定时任务:在线(添加、修改、删除)任务调度包含执行结果日志。
13. 代码生成:前后端代码的生成(java、html、xml、sql)支持CRUD下载 。
14. 系统接口:根据业务代码自动生成相关的api接口文档。
15. 服务监控:监视当前系统CPU、内存、磁盘、堆栈等相关信息。
16. 缓存监控:对系统的缓存信息查询,命令统计等。
17. 在线构建器:拖动表单元素生成相应的HTML代码。
18. 连接池监视:监视当前系统数据库连接池状态,可进行分析SQL找出系统性能瓶颈。
## 在线体验
- admin/admin123
- 陆陆续续收到一些打赏,为了更好的体验已用于演示服务器升级。谢谢各位小伙伴。
演示地址:http://vue.ruoyi.vip
文档地址:http://doc.ruoyi.vip
## 演示图
<table>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/cd1f90be5f2684f4560c9519c0f2a232ee8.jpg"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/1cbcf0e6f257c7d3a063c0e3f2ff989e4b3.jpg"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/up-8074972883b5ba0622e13246738ebba237a.png"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-9f88719cdfca9af2e58b352a20e23d43b12.png"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/up-39bf2584ec3a529b0d5a3b70d15c9b37646.png"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-936ec82d1f4872e1bc980927654b6007307.png"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/up-b2d62ceb95d2dd9b3fbe157bb70d26001e9.png"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-d67451d308b7a79ad6819723396f7c3d77a.png"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/5e8c387724954459291aafd5eb52b456f53.jpg"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/644e78da53c2e92a95dfda4f76e6d117c4b.jpg"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/up-8370a0d02977eebf6dbf854c8450293c937.png"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-49003ed83f60f633e7153609a53a2b644f7.png"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/up-d4fe726319ece268d4746602c39cffc0621.png"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-c195234bbcd30be6927f037a6755e6ab69c.png"/></td>
</tr>
<tr>
<td><img src="https://oscimg.oschina.net/oscnet/b6115bc8c31de52951982e509930b20684a.jpg"/></td>
<td><img src="https://oscimg.oschina.net/oscnet/up-5e4daac0bb59612c5038448acbcef235e3a.png"/></td>
</tr>
</table>
## 租赁历史资源证明
租赁模块已提供与云端同进程运行的历史资源证明采集,复用4张证据表及1张待确认缓冲表。全局采样、确认归档与事件扫描独立运行,复用钱包一致性读与地址对基线;订单/任务提交后立即异步派单/推送。升级需重跑幂等脚本 `sql/rent_history_init.sql`,部署与配置见 [内置历史证明服务](docs/rental/history-service.md),业务运行说明见 [租赁模块](docs/rental/implementation.md)。
历史清理默认每日03:15 UTC运行,保留30天并额外保护未闭环订单及最近10000区块,先归档校验再分批删除,业务订单与资金记录不动。已有历史库部署前还需执行 `sql/rent_history_cleanup_upgrade.sql`,并配置持久归档目录 `RENT_HISTORY_ARCHIVE_DIRECTORY`;规则与配置见 [安全清理](docs/rental/history-service.md#7-历史表安全清理)。
## Authenticator 动态码登录
租赁订单交付间隔见`ruoyi-admin/src/main/resources/application-rental.yml`的`rental.delivery`:
`dispatch-interval-ms`默认3000,`push-interval-ms`默认2000;环境变量分别为
`RENT_DELIVERY_DISPATCH_INTERVAL_MS`、`RENT_DELIVERY_PUSH_INTERVAL_MS`,范围500~60000毫秒。
修改后重启服务端。正常在线、无积压且RPC及时返回时目标约10秒内接单,链上调用、快照过期和积压会额外耗时。
日志`orderAgeMs`表示下单到分配,`taskAgeMs`表示任务创建到推送;Agent另记录签发至接收及预检查耗时。
订单列表新增“未履约原因”及完整说明弹窗,管理员、商户和供应商均仅能查看自身有权限的订单。
委托链上确认但未满足履约条件时,服务端记录`租赁履约未通过`日志,并同事务写入`rent_event`的
`DELIVERY_REVIEW`事件,包含历史证明缺失、已核验数量不足、核验时租期已结束等原因;多个原因同时保留。
使用现有事件表,无需数据库升级。旧订单优先依据已归档交易证据回溯,缺失数据时明确显示无法确认;
不会用当前时间推断历史核验超时,也不会向页面返回完整交易证据或凭证。
保留密码和 Google 账号登录,新增六位动态码登录及个人中心绑定/解绑。部署前执行 `sql/totp_auth.sql` 并配置 `TOTP_ENCRYPTION_KEY`,详见 [部署与使用说明](docs/totp-login.md)。
## susdt前后端分离交流群
QQ群: [![加入QQ群](https://img.shields.io/badge/已满-937441-blue.svg)](https://jq.qq.com/?_wv=1027&k=5bVB1og) [![加入QQ群](https://img.shields.io/badge/已满-887144332-blue.svg)](https://jq.qq.com/?_wv=1027&k=5eiA4DH) [![加入QQ群](https://img.shields.io/badge/已满-180251782-blue.svg)](https://jq.qq.com/?_wv=1027&k=5AxMKlC) [![加入QQ群](https://img.shields.io/badge/已满-104180207-blue.svg)](https://jq.qq.com/?_wv=1027&k=51G72yr) [![加入QQ群](https://img.shields.io/badge/186866453-blue.svg)](https://jq.qq.com/?_wv=1027&k=VvjN2nvu) 点击按钮入群。
+12
View File
@@ -0,0 +1,12 @@
@echo off
echo.
echo [信息] 清理生成路径。
echo.
%~d0
cd %~dp0
cd ..
call mvn clean
pause
+12
View File
@@ -0,0 +1,12 @@
@echo off
echo.
echo [信息] 打包Web工程,生成war/jar包文件。
echo.
%~d0
cd %~dp0
cd ..
call mvn clean package -Dmaven.test.skip=true
pause
+14
View File
@@ -0,0 +1,14 @@
@echo off
echo.
echo [信息] 运行Web工程。
echo.
cd %~dp0
cd ../ruoyi-admin/target
set JAVA_OPTS=-Xms256m -Xmx1024m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=512m
java -jar %JAVA_OPTS% ruoyi-admin.jar
cd bin
pause
+3
View File
@@ -0,0 +1,3 @@
http://liaogou.media-help.cn:18080/my/RuoYi-Vue.git
https://gitee.com/y_project/RuoYi-Vue.git
+5118
View File
File diff suppressed because it is too large. Load diff
Binary file not shown.
+133
View File
@@ -0,0 +1,133 @@
# 内网链上执行服务
## 功能与兼容边界
`usdt-chain-executor` 是独立 JDK 8 进程,复用当前钱包信封解密、HD 派生、TRON 网络选择和资源估算。
支持主钱包/子钱包 TRX 与 USDT 转账、Stake 2.0 质押/取消质押、代理/取消代理、取消全部待解冻、归集、代付。
创建钱包、扩充子账号、轮换配置密码仍走原有人工密码流程,不向执行器开放这些管理能力。
支付后端 `CHAIN_EXECUTOR_ENABLED` 默认 `false`,此时直接执行原密码代码,既不访问内网服务,也不依赖新增表。
启用后,支付后端启动时先调用 `GET /internal/v1/connectivity` 验证传输链路、来源白名单和服务令牌,
再调用 `GET /internal/v1/readiness` 验证数据库钱包网络和配置密码。两项通过时输出服务可用日志;暂时不可用时
支付系统继续启动并输出受控诊断,但所有无密码远程链上操作仍会被拒绝。URL、协议或令牌长度配置非法时仍拒绝启动。
启用后,用户输入密码时本地执行,未输入密码时仅允许交给已就绪的内网服务。两种方式共用执行记录和受控交易构造,
执行前实时校验余额、资源和链上费率。`RESOURCE_ONLY` 缺口拒绝;`DIRECT` 检查燃烧预算及全局 `trx_num` 保留量。
页面仍要求明确确认广播;服务上线不会触发历史业务自动广播。
## 部署顺序
1. 备份并执行 `sql/chain_executor.sql`,只新增执行记录表,不重建原表。
2. 使用 JDK 8 构建:`mvn -pl usdt-chain-executor -am package -DskipTests`。
3. 给独立执行器配置下表环境变量,再启动 `java -jar usdt-chain-executor/target/usdt-chain-executor-3.4.0.jar`。
4. 验证监听地址、来源白名单和服务认证;HTTPS 部署还需验证 Nginx 与证书,再配置支付后端。
5. 首次在 NILE 验证。没有执行过真实交易的构建/隔离测试不能替代实际部署验收。
禁止把真实配置密码写在脚本、命令行参数、Git 文件或支付后端配置中。通过进程管理器的受控环境注入。
### 执行器环境变量
| 变量 | 含义 |
| --- | --- |
| `CHAIN_EXECUTOR_BIND_ADDRESS` | 必填,本机明确 IPv4;只接受 `10/8`、`172.16/12`、`192.168/16` 或 `127/8` |
| `CHAIN_EXECUTOR_PORT` | 必填,HTTP 监听端口;Nginx 模式建议使用回环端口 `9089` |
| `CHAIN_EXECUTOR_ALLOWED_IPS` | 必填,支付后端实际 TCP 来源 IPv4,逗号分隔,逐个精确匹配;不支持通配/CIDR |
| `CHAIN_EXECUTOR_TOKEN` | 必填,至少 32 位的独立随机服务凭据;与后端配置相同,不是钱包密码 |
| `CHAIN_EXECUTOR_CONFIGURATION_PASSWORD` | 必填,当前全局钱包配置密码,仅在执行器进程内存中使用 |
| `CHAIN_EXECUTOR_ALLOWED_NETWORK` | 必填,`NILE` 或 `MAINNET`;与数据库全局配置不同则未就绪 |
| `CHAIN_EXECUTOR_BROADCAST_ENABLED` | 必填,只有明确为 `true` 才启动 |
| `CHAIN_EXECUTOR_DB_URL` | 与支付后端相同数据库;使用 `connectionTimeZone=LOCAL&forceConnectionTimeZoneToSession=true` |
| `CHAIN_EXECUTOR_DB_USER` / `CHAIN_EXECUTOR_DB_PASSWORD` | 独立最小权限数据库账号及密码 |
| `TRON_GRID_API_KEY` / `TRON_SCAN_API_KEY` | 按实际节点配置,沿用共享 TRON 客户端 |
独立执行器数据库权限:`usdt_config`、`wallet_address`、`usdt_payout_order`、
`usdt_aggregation_task`、`usdt_aggregation_task_item` 只需 SELECT;`usdt_chain_execution` 需 SELECT/UPDATE。
执行器不需要创建表、删除表、写业务状态或修改商户余额的权限。
### 支付后端环境变量
| 变量 | 含义 |
| --- | --- |
| `CHAIN_EXECUTOR_ENABLED` | 启用双通道时设 `true` |
| `CHAIN_EXECUTOR_BASE_URL` | 无尾斜杠/路径的 HTTP 或 HTTPS 根地址,例如 `http://192.168.10.20:9088` 或 `https://192.168.10.20:9088` |
| `CHAIN_EXECUTOR_TOKEN` | 独立服务凭据,与执行器一致 |
| `CHAIN_EXECUTOR_TLS_CERTIFICATE` | HTTPS时可配置 `file:/.../rent-cert.pem` 或 `classpath:` 证书/CA;HTTP忽略 |
| `CHAIN_EXECUTOR_HEALTH_CHECK_INTERVAL_MS` | 后端健康检查周期,默认 `10000` 毫秒 |
| `CHAIN_EXECUTOR_HEALTH_FAILURE_THRESHOLD` | 连续失败自动停用阈值,默认 `3` 次 |
执行器自身只提供 HTTP。支付后端可使用 HTTP 直连,或使用 HTTPS 调用同机 Nginx,由 Nginx 转发到回环 HTTP。
生产跨机器调用推荐 HTTPS;证书 SAN 必须包含配置的内网 IP,支付后端 JVM 需信任签发 CA,禁止关闭证书校验。
HTTPS使用自签或内部CA时,建议设置 `CHAIN_EXECUTOR_TLS_CERTIFICATE=file:/etc/nginx/certs/rent-cert.pem`。
支付系统通过独立Java TLS上下文追加该证书,并保留JVM默认证书和主机名校验,不需要配置全局 trustStore。
只支持 IPv4 字面地址,不接受域名,避免 DNS 重绑定和意外公网解析。Nginx 示例见
`usdt-chain-executor/nginx/usdt-chain-executor.conf`。
后端定期检查执行器联通和业务就绪状态。管理员运行开关保存在 `sys_config` 的
`chain.executor.runtime.enabled`:连续失败达到阈值后自动写为 `false`,新链上操作只能使用配置密码。
服务恢复后只更新可达状态,不会自动打开运行开关;管理员需在全局配置页确认并重新启用。
### HTTPS + Nginx 推荐配置
执行器配置为 `CHAIN_EXECUTOR_BIND_ADDRESS=127.0.0.1`、`CHAIN_EXECUTOR_PORT=9089`、
`CHAIN_EXECUTOR_ALLOWED_IPS=127.0.0.1`。Nginx 使用内网 IP 的 `9088` 端口终止 TLS并转发到
`http://127.0.0.1:9089`。支付后端配置 `CHAIN_EXECUTOR_BASE_URL=https://内网IP:9088`。
执行器不读取证书或私钥;`CHAIN_EXECUTOR_TLS_KEYSTORE` 和 `CHAIN_EXECUTOR_TLS_PASSWORD` 已废弃。
## 仅内网访问
- 服务拒绝 `0.0.0.0`、公网、域名、IPv6 和未配置白名单的启动方式。
- 所有 HTTP 路径统一检查真实 TCP 对端 IP 和独立 Bearer 凭据;健康检查也不例外。
- 不信任 `X-Forwarded-For` 或其他代理头。经 Nginx 转发时执行器白名单应配置为 `127.0.0.1`,
Nginx 自身再用 `allow/deny` 限制支付后端真实来源 IP。
- 防火墙/安全组仅允许支付后端指定内网 IP 访问执行端口,其他来源全部拒绝。
- 禁止配置公网 NAT、端口转发、公网反向代理和公网 Ingress;容器部署只发布到宿主机指定内网地址。
- 前端只访问现有支付后端;执行器地址、凭据、密码、信封和签名交易不返回浏览器。
应用只能校验本机监听与实际来源,无法代替基础设施防火墙,也无法检测外部设备上的 NAT/公网转发规则。
## 协议与执行流程
- `GET /internal/v1/connectivity`:鉴权后验证传输链路,成功返回纯文本 `CONNECTED`。
- `GET /internal/v1/readiness`:鉴权后验证当前配置密码和网络,成功返回纯文本 `READY`,未就绪返回 503。
- `POST /internal/v1/executions`:鉴权后接收空正文通知,返回 202;只唤醒数据库扫描,不接收任意交易参数。
- `GET /system/chainExecutor/status`:现有后端登录鉴权入口,返回可用性和当前操作人最近 5 条公开执行记录。
业务指令先写数据库,通知只是加速信号;通知丢失时每 2 秒补扫。队列指令 10 分钟内未开始则拒绝执行。
就绪校验会解密信封但不签名;实际执行再次核对信封版本、网络、钱包启用状态、地址与索引、代付/归集业务状态及金额。
私钥仍由 `WalletSigningService` 在内存中派生,派生地址不匹配时拒绝。
| 状态 | 语义与恢复 |
| --- | --- |
| `QUEUED` | 持久化待执行;REMOTE 可以补扫;PASSWORD 不会在无人输入密码时自动解锁 |
| `RUNNING` | 已原子领取,正在校验/签名;不凭超时自动释放,防止多进程同时签名 |
| `SIGNED` | 签名交易与哈希已落库,广播前的持久化屏障;只查询或重播原字节,不重新构造 |
| `BROADCASTED` | 节点确认接收或按哈希查到原交易;不等同于链上执行成功 |
| `FAILED` | 明确在签名前失败,可以重新输入密码或重试远程执行;旧记录归档保留 |
| `CHAIN_FAILED` | 原代付链上确认任务已确认原哈希执行失败,允许下一次人工尝试;保留旧交易审计 |
广播包含首次最多尝试 4 次,使用同一笔签名交易。`SIGNED` 后响应丢失或数据库断连不改为可重新广播的失败。
恢复任务查原哈希或重播同一交易,不能因交易过期/未查到就自动创建新交易。
代付保留状态 6 直到结果明确;后端每 5 秒同步为已广播,再由原链上确认和账务结算完成。
归集明细保留状态 4,逐明细同步交易哈希与幂等支出流水;全部明细结束后同步主任务。
执行器只写执行记录,不能代替支付系统做审核或结算。
## 维护与异常恢复
- 密码轮换后,旧环境密码无法解密,服务就绪状态立即失败。更新执行器环境变量并重启;不要通过 HTTP 发送新密码。
- 切换全局网络时,必须同步调整执行器允许网络。旧网络 `SIGNED` 记录未处理完前不要切换。
- 存在 QUEUED/RUNNING/SIGNED 未决记录时,不要关闭后端功能开关后改走不受新表约束的旧通道。
- `SIGNED` 长期未确认:核对网络、交易哈希、交易过期时间与链上结果。禁止清空签名记录或直接重新转账。
- `RUNNING` 在进程异常退出后可能保留:先停止所有本地和远程执行进程,确认该记录没有 `signed_transaction`、没有交易哈希,
且签名前持久化屏障确实未通过,再由维护人员将其标记为 FAILED。禁止运行中按时间强制抢占。
- 后端分发归集期间异常退出时,主任务可能保留“正在分发链上执行任务”。先核对已创建指令与未提交明细,
不要直接重跑主任务。明确已提交结果后再恢复业务状态;该保守占位用于避免重复归集。
需要停机维护时先停止新提交,等待已签名交易和业务同步完成,再停执行器、关闭功能开关。
`signed_transaction` 不包含私钥,但具有广播能力,必须限制数据库读取和备份访问,不得公开或写日志。
## 验证
隔离测试覆盖:同业务并发提交/领取只成功一次、签名后不可标记为可重试失败、密码不入库、
广播响应丢失时同一字节重播与恢复不重新签名、真实回环 HTTP 的 IP 白名单/凭据校验、伪造转发头拒绝、密码轮换未就绪。
部署仍须验证公网无法连接、非白名单内网来源拒绝、错误服务凭据拒绝、TLS 验证和实际 NILE 链上确认。
+703
View File
@@ -0,0 +1,703 @@
# 支付系统、资源租赁平台与链上执行器配置手册
本文按当前工作区代码说明三个独立运行单元的配置、依赖关系和部署方式:
1. **支付系统**:`myEpusdt/ruoyi-admin`,负责订单、钱包、归集、代付、资源预检和任务编排。
2. **资源租赁平台服务端**:支付系统中启用 `rental` profile 后提供的租赁业务服务,负责租赁账户、套餐、订单、节点交付、结算、充值和回调。
3. **链上执行器**:`myEpusdt/usdt-chain-executor`,部署在受控内网,持有钱包配置口令并执行远程链上任务。
支付系统还可对接两种资源供应商:
- `INTERNAL`:当前项目自己的资源租赁平台。
- `DUIYA`:第三方 DUIYA 资源订单接口。
> 本文所有密钥均使用 `<...>` 占位符。当前仓库部分配置文件存在看似真实的密码、Token、API Key 和云存储密钥默认值。生产部署前应将其移出版本库,通过环境变量或外部配置注入,并立即轮换所有曾进入版本库的凭据。
## 1. 总体架构与配置归属
```text
管理员浏览器 / 商户
|
v
支付系统(RuoYi) ----------------------> MySQL / Redis
| ^
| 资源报价、下单、查询 |
+----> DUIYA | 共享 usdt_chain_execution
| |
+----> INTERNAL 资源租赁平台 |
| |
| Bearer + IP 白名单 |
+----> Nginx HTTPS(可选) ----> 链上执行器 HTTP
|
v
TRON 网络
```
| 配置类别 | 配置位置 | 读取者 | 生效方式 |
| --- | --- | --- | --- |
| 支付系统、TRON、执行器客户端开关 | `application.yml` 对应环境变量 | 支付系统 | 重启支付系统 |
| 资源供应商连接信息 | `usdt_resource_rental_config` | 支付系统 | 后台新增配置后立即供新订单使用 |
| INTERNAL 租赁平台 | `application-rental.yml` 对应环境变量 | 启用 `rental` profile 的服务 | 重启服务 |
| 链上执行器数据库和链查询 | `executor.properties` 对应环境变量 | 链上执行器 | 重启执行器 |
| 链上执行器网络入口和钱包口令 | 进程环境变量 | 链上执行器 | 重启执行器 |
| Nginx TLS、来源限制 | Nginx 配置 | Nginx | `nginx -t` 后 reload |
不要将三个概念混为一谈:
- `RENT_MASTER_KEY` 是租赁平台数据库敏感凭据的根加密密钥。
- `CHAIN_EXECUTOR_CONFIGURATION_PASSWORD` 是执行器解锁钱包配置的口令。
- `CHAIN_EXECUTOR_TOKEN` 是支付系统调用执行器时使用的 Bearer 服务令牌。
## 2. 部署前准备
### 2.1 基础依赖
- JDK 8。
- MySQL,字符集使用 `utf8mb4`,时区与应用保持一致。
- Redis,供支付订单金额槽位、会话和相关任务使用。
- 可访问所选 TRON 网络的 RPC、TronGrid 和 TronScan 接口。
- 需要 HTTPS 时准备 Nginx 及证书。
- 支付系统和链上执行器必须能访问同一个业务数据库。
### 2.2 SQL 初始化顺序
先备份数据库,再按实际启用功能执行增量脚本。不要用 drop/recreate 升级生产库。
```text
基础支付表 sql/payment_init.sql
资源租赁客户端 sql/resource_rental.sql
链上执行任务 sql/chain_executor.sql
租赁平台主体 sql/rent_init.sql
租赁充值 sql/payment_topup_upgrade.sql
sql/rent_topup_init.sql
租赁历史采集 sql/rent_history_init.sql
历史清理升级(已有库) sql/rent_history_cleanup_upgrade.sql
```
关键新增表用途:
| 表 | 用途 |
| --- | --- |
| `usdt_resource_rental_config` | 资源供应商连接配置的版本表;API Key/Secret 以 AES-GCM 密文保存,新配置不覆盖旧订单引用的版本。 |
| `usdt_resource_preparation` | 一次归集或代付的资源准备状态、预计资源、现有资源、授权和到账期限。 |
| `usdt_resource_rental_order` | 能量/带宽租赁订单;`preparation_id + resource_type` 唯一,防止重复下单。 |
| `usdt_resource_address_guard` | 同网络同地址的跨实例互斥,防止并发资源准备和执行。 |
| `usdt_chain_execution` | 支付系统与执行器共享的链上任务状态、脱敏命令、交易哈希和受控签名交易。 |
| `rent_topup_order` | 租赁平台用户通过支付系统充值的订单及支付通道快照。 |
| `rent_topup_notify` | 已验签充值通知的幂等收件箱。 |
| `rent_webhook` | 租赁订单业务事件的商户回调持久队列。 |
## 3. 支付系统基础配置
配置文件为 `ruoyi-admin/src/main/resources/application.yml`。生产环境建议使用外部 `application-prod.yml` 和环境变量,禁止把生产秘密写回仓库。
### 3.1 Spring profile、MySQL 与 Redis
`spring.profiles.active` 选择基础环境,例如 `prod`。若同一进程还承载租赁平台,应额外包含 `rental`:
```yaml
spring:
profiles:
active: prod
include: rental
```
数据库连接通常在对应 profile 的 Druid 配置中设置。至少配置 URL、用户名和密码:
```yaml
spring:
datasource:
druid:
master:
url: jdbc:mysql://<mysql-host>:3306/<database>?useUnicode=true&characterEncoding=utf8&connectionTimeZone=LOCAL&forceConnectionTimeZoneToSession=true
username: <database-user>
password: <database-password>
redis:
host: <redis-host>
port: 6379
database: 0
password: <redis-password>
```
支付数据库连接必须使用本地会话时区。历史 URL 中若有 `serverTimezone=UTC`,应改为项目约定的 `connectionTimeZone=LOCAL&forceConnectionTimeZoneToSession=true`。
### 3.2 支付业务参数
| 环境变量 | 是否必配 | 用途与要求 |
| --- | --- | --- |
| `APP_PRIVATE_KEY_ENCRYPTION_KEY` | 使用商户 RSA 私钥时必配 | 商户私钥的加密主密钥,至少 32 位;所有支付实例保持一致,不可直接轮换。 |
| `USDT_EXCHANGE_RATE` | 建议显式配置 | `1 USDT` 对应的业务货币金额;实际 USDT = 业务金额 / 汇率。使用十进制值,不使用浮点近似。 |
| `PAYMENT_CHECKOUT_URL` | 对外创建订单时必配 | 公共收银台完整 URL,例如 `https://pay.example.com/public/usdtPay`。 |
| `TRON_OPERATION_RESOURCE_REDUNDANCY_PERCENT` | 建议配置 | 链上资源估算冗余百分比,默认 20;过低易因链上变化导致资源不足。 |
同时应修改 RuoYi 自带的 `token.secret`,关闭生产 Swagger、演示功能和不需要的 Actuator 暴露端点。JWT 密钥必须使用高强度随机值。
### 3.3 TRON 链数据配置
| 环境变量 | 用途 |
| --- | --- |
| `TRON_GRID_API_KEY` | TronGrid API Key。 |
| `TRONSCAN_API_KEY` | TronScan 独立 API Key,不能用 TronGrid Key 代替。 |
| `TRON_MAINNET_TRANSACTION_ENDPOINTS` | 主网交易查询端点,多个地址用英文逗号分隔。 |
| `TRON_MAINNET_ACCOUNT_ENDPOINTS` | 主网账户查询端点。 |
| `TRON_NILE_TRANSACTION_ENDPOINTS` | Nile 交易查询端点。 |
| `TRON_NILE_ACCOUNT_ENDPOINTS` | Nile 账户查询端点。 |
| `TRON_SHASTA_TRANSACTION_ENDPOINTS` | Shasta 交易查询端点。 |
| `TRON_SHASTA_ACCOUNT_ENDPOINTS` | Shasta 账户查询端点。 |
生产建议配置至少两个可用查询端点并监控限流。网络由全局 USDT 配置决定,支付系统、租赁平台、执行器和钱包配置必须一致,禁止仅通过替换合约地址混用网络。
### 3.4 安全与通知可选项
| 环境变量 | 用途 |
| --- | --- |
| `TOTP_ENCRYPTION_KEY` | Base64 编码的 32 字节随机 AES 密钥;用于加密 Authenticator 凭据。所有实例一致,缺失时不能新建绑定。 |
| `TOTP_ISSUER` | Authenticator 中显示的发行方名称。 |
| `GOOGLE_OAUTH_ENABLED` | 是否启用 Google OIDC。 |
| `GOOGLE_OAUTH_CLIENT_ID` / `GOOGLE_OAUTH_CLIENT_SECRET` | Google OAuth 客户端凭据。 |
| `GOOGLE_OAUTH_REDIRECT_URI` | 后端 OAuth 回调地址。 |
| `GOOGLE_OAUTH_FRONTEND_RESULT_URL` | 登录完成后的前端结果地址。 |
| `TELEGRAM_ENABLED` | 是否启用 Telegram 审核/通知。 |
| `TELEGRAM_BOT_TOKEN` | Bot Token,禁止记录日志。 |
| `TELEGRAM_AUDIT_CHAT_ID` | 审核群或会话 ID。 |
| `TELEGRAM_WEBHOOK_URL` / `TELEGRAM_WEBHOOK_SECRET` | Telegram Webhook 公网地址和校验 Secret。 |
| `TELEGRAM_ALLOWED_USER_IDS` | 允许操作的 Telegram 用户 ID 列表。 |
| `TELEGRAM_PUSH_SCAN_INTERVAL_MS` | 待推送扫描周期,默认 10000 ms。 |
## 4. 支付系统的资源租赁客户端
### 4.1 功能开关
| 环境变量 | 示例 | 说明 |
| --- | --- | --- |
| `USDT_RESOURCE_RENTAL_ENABLED` | `true` | 总开关。启用前必须完成 SQL 和平台配置。 |
| `USDT_RESOURCE_RENTAL_PROVIDER` | `INTERNAL` | 当前使用的供应商,只能为 `INTERNAL` 或 `DUIYA`。 |
| `USDT_RESOURCE_ARRIVAL_TIMEOUT_SECONDS` | `300` | 下单后等待链上资源到账的最长时间。 |
切换供应商只修改 `USDT_RESOURCE_RENTAL_PROVIDER` 并重启支付系统;数据库中必须已有对应网络、已启用的供应商配置。
### 4.2 后台配置
进入 `USDTmanage/usdtConfig` 的“资源租赁平台”区域。保存配置会向 `usdt_resource_rental_config` 插入新版本,不会覆盖旧行;API Key 和 Secret 只写入、不回显。
| 字段 | 说明 |
| --- | --- |
| 平台 | `INTERNAL` 或 `DUIYA`。 |
| 网络 | `NILE` 或 `MAINNET`;DUIYA 当前只允许 `MAINNET`。 |
| 基础地址 | 平台 API 根地址。INTERNAL 可填写服务根地址,代码会使用 `/api/rental/v1`;DUIYA 填资源 API v2 根地址。 |
| API Key / Secret | 平台颁发的 HMAC 凭据。编辑时留空表示沿用旧密文。 |
| 能量周期 / 带宽周期 | 供应商支持的产品周期,例如 `1h`、`1day`。必须与平台套餐一致。 |
| 租期秒数 | INTERNAL 订单租期,必须匹配可用套餐。 |
| 能量步长 | 数量向上取整步长,常见为 30000。 |
| 带宽步长 | 数量向上取整步长,常见为 100。 |
| 单订单费用上限 | 任一资源订单允许的最大报价。 |
| 单次执行费用上限 | 一次业务全部资源允许的总费用,必须大于等于单订单上限。 |
| 币种 | 由后端确定:INTERNAL 为 USDT,DUIYA 为 TRX。 |
费用上限是资金安全边界,不应设置为无限大。生产值应依据正常报价加合理波动空间,并通过告警处理异常报价。
### 4.3 DUIYA 配置
DUIYA 当前仅支持主网。资源订单流程使用:
```text
POST /query_price 查询价格
POST /buy_energy 购买能量
POST /buy_net 购买带宽
POST /query_result 查询订单结果
```
基础地址应以 DUIYA 实际颁发文档为准,例如 API v2 根地址。数量必须符合平台最小值和步长。DUIYA 费用以 TRX 计价,因此费用上限也按 TRX 填写。
### 4.4 INTERNAL 配置
INTERNAL 指向本项目租赁平台,支付系统调用:
```text
POST /api/rental/v1/quote
POST /api/rental/v1/create
POST /api/rental/v1/query
```
请求使用 `X-Rent-*` HMAC 请求头认证。配置的 API Key/Secret 必须来自租赁平台中启用的应用凭据,网络、租期、资源步长必须与租赁账号已分配套餐一致。费用以 USDT 计价。
### 4.5 资源准备与防重复逻辑
人工密码执行时:
1. 页面预检每个业务地址的能量和带宽缺口及费用。
2. 管理员选择是否租赁并确认最大费用。
3. 后端为业务创建唯一 `usdt_resource_preparation`。
4. 每个准备单、每种资源最多创建一张租赁单;唯一键阻止重复购买。
5. 平台调用成功后不立即执行转账。支付系统主动查询平台订单,并反复查询目标地址链上资源。
6. 只有能量和带宽实际到账且满足当前重新估算值后,才允许输入钱包配置密码执行链上操作。
执行器自动执行时,同样先完成资源准备和链上到账确认,再创建/唤醒远程执行任务。平台响应“成功”不等于资源已到账。
资源租赁目前不依赖供应商向支付系统回调,因此无需为 DUIYA 或 INTERNAL 配置资源订单回调地址。订单状态与资源到账均由支付系统主动确认。
## 5. INTERNAL 资源租赁平台服务端
租赁平台配置位于 `application-rental.yml`。只有 Spring profile 包含 `rental` 时才加载。以下都是进程启动配置,修改后需要重启。
### 5.1 核心配置
| 环境变量 | 必需 | 说明 |
| --- | --- | --- |
| `RENT_ENABLED` | 是 | 租赁平台总开关。 |
| `RENT_DOMAIN` | 是 | 对外域名,用于平台生成和校验相关地址;填写域名,不要混入路径。 |
| `RENT_MASTER_KEY` | 是 | Base64 编码的**恰好 32 字节**随机密钥,用 AES-256-GCM 加密租赁凭据。所有实例必须一致。 |
| `RENT_MASTER_KEY_VERSION` | 是 | 密钥版本标识,例如 `v1`;轮换时用于识别密钥版本。 |
| `RENT_CONFIRMATIONS` | 是 | 链上交易所需确认数,主网建议按业务风控确定。 |
生成主密钥示例:
```bash
openssl rand -base64 32
```
`RENT_MASTER_KEY` 不是租赁 API Secret、支付 API Secret 或钱包密码。丢失它会导致已有加密凭据无法解密;直接替换会使历史凭据不可用。轮换必须先实现旧版本解密、新版本加密和数据迁移,不能只改环境变量。
### 5.2 商户 Webhook
| 环境变量 | 说明 |
| --- | --- |
| `RENT_WEBHOOK_ALLOW_PRIVATE_NETWORK` | 是否允许向 RFC1918/IPv6 ULA 内网地址发送回调。生产公网平台通常设为 `false`;内网联调才开启。 |
| `RENT_WEBHOOK_DEBUG_CREDENTIAL_SOURCE` | 调试回调凭据来源:`APP` 使用应用当前有效凭据;`CONFIGURED` 使用下面独立凭据。 |
| `RENT_WEBHOOK_DEBUG_API_KEY` / `RENT_WEBHOOK_DEBUG_API_SECRET` | 仅 `CONFIGURED` 调试模式使用。 |
| `RENT_WEBHOOK_DEBUG_SIGNATURE_PATH` | 反向代理改写路径时,指定参与签名的外部路径。 |
租赁订单状态变化时,同一事务写入 `rent_webhook`。后台工作线程按 HMAC 规则向商户的回调 URL 推送;只有响应 HTTP 200 且正文严格等于小写 `ok` 才确认成功。超时、非 200、正文不匹配都会进入重试/失败处理。
不要把支付充值通知 `/api/rental/payment/notify/{channel}` 当成租赁订单商户 Webhook:前者是支付系统通知租赁平台,后者是租赁平台通知自己的商户。
### 5.3 派单与交付
| 环境变量 | 默认概念 | 说明 |
| --- | --- | --- |
| `RENT_DELIVERY_WORKERS` | `4` | 异步交付工作线程数。 |
| `RENT_DELIVERY_QUEUE_CAPACITY` | `200` | 内存快速队列容量;持久化扫描仍负责补偿。 |
| `RENT_DELIVERY_DISPATCH_INTERVAL_MS` | `3000` | 待派单持久化补偿扫描间隔。 |
| `RENT_DELIVERY_PUSH_INTERVAL_MS` | `2000` | 节点推送/任务补偿间隔。 |
| `RENT_DELIVERY_VERIFICATION_GRACE_SECONDS` | `180` | 租期结束后允许链上核验延迟的宽限,不延长用户实际租期。 |
线程数应结合节点数、数据库连接池和 RPC 限流调整,不宜只为降低延迟盲目增大。
### 5.4 RPC 与历史采集
| 环境变量 | 说明 |
| --- | --- |
| `RENT_NILE_RPC` / `RENT_MAINNET_RPC` | 各网络 TRON RPC 根地址。 |
| `RENT_RPC_KEY` | RPC/TronGrid API Key。 |
| `RENT_HISTORY_EMBEDDED_ENABLED` | 是否启用同进程 Java 历史采集器。 |
| `RENT_HISTORY_NETWORKS` | 采集网络,建议先从 `NILE` 开始。 |
| `RENT_HISTORY_POLL_MS` | 区块轮询间隔。 |
| `RENT_HISTORY_BATCH_SIZE` | 单批处理区块/记录规模。 |
| `RENT_HISTORY_PARAMETER_GRACE_SECONDS` | 链参数归档暂时落后时的等待时间。 |
| `RENT_HISTORY_MAX_SAMPLE_AGE_SECONDS` | 参数样本最大允许年龄;过期时暂停新资源派单。 |
| `RENT_HISTORY_PROBE_ADDRESS` | 用于链能力/资源数据探测的有效 TRON 地址。 |
| `RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY` | 外部历史服务地址;启用内置采集时无需填写。 |
历史清理配置:
| 环境变量 | 说明 |
| --- | --- |
| `RENT_HISTORY_CLEANUP_ENABLED` | 是否启用归档清理。 |
| `RENT_HISTORY_CLEANUP_CRON` | UTC 时区 Quartz cron。 |
| `RENT_HISTORY_RETENTION_DAYS` | 在线历史保留天数。 |
| `RENT_HISTORY_CLEANUP_BATCH_SIZE` | 每批清理数量。 |
| `RENT_HISTORY_CLEANUP_MAX_BATCHES` | 单次任务最大批次数。 |
| `RENT_HISTORY_ARCHIVE_DIRECTORY` | 持久、可写且支持原子移动的归档目录;归档文件不会自动删除。 |
### 5.5 入金、提现和地址上链
| 环境变量 | 说明 |
| --- | --- |
| `RENT_NILE_DEPOSIT` / `RENT_MAINNET_DEPOSIT` | 租赁用户 USDT 入金地址,与供应节点钱包无关。 |
| `RENT_WITHDRAW_ENABLED` | 是否开放提现申请。 |
| `RENT_WITHDRAW_MIN_USDT` / `RENT_WITHDRAW_MAX_USDT` | 单笔提现上下限。 |
| `RENT_WITHDRAW_SCAN_ENABLED` | 是否扫描管理员已广播的提现交易。系统自身不自动广播提现。 |
| `RENT_WITHDRAW_POLL_MS` | 提现链上扫描周期。 |
| `RENT_WITHDRAW_SCAN_BATCH_BLOCKS` | 单批扫描区块数。 |
| `RENT_WITHDRAW_TELEGRAM_REVIEWERS` | `Telegram用户ID:后台用户ID`,多项逗号分隔。 |
| `RENT_WITHDRAW_NILE_PAYOUT_ADDRESSES` / `RENT_WITHDRAW_MAINNET_PAYOUT_ADDRESSES` | 各网络允许的出款地址白名单。 |
地址上链功能固定转出 1 TRX,并从用户 USDT 账户冻结本金折价与服务费:
| 环境变量 | 说明 |
| --- | --- |
| `RENT_ADDRESS_ONCHAIN_ENABLED` | 总开关,默认应关闭。 |
| `RENT_ADDRESS_ONCHAIN_<NETWORK>_TRX_PRICE_USDT` | 对应网络的 TRX/USDT 固定计价。 |
| `RENT_ADDRESS_ONCHAIN_<NETWORK>_FEE_USDT` | 固定服务费。 |
| `RENT_ADDRESS_ONCHAIN_<NETWORK>_PLATFORM_FEE_PERCENT` | 平台从服务费中的分成比例,0~100。 |
| `RENT_ADDRESS_ONCHAIN_<NETWORK>_FEE_LIMIT_SUN` | 链上交易 fee limit,单位 SUN。 |
`<NETWORK>` 为 `NILE` 或 `MAINNET`。价格必须逐网络显式设置,不跨网络兜底。
## 6. 租赁平台通过支付系统充值
这一组 `RENT_PAYMENT_*` 是“租赁平台用户向余额充值”的支付通道,不是支付系统购买能量/带宽的资源供应商配置。
### 6.1 全局参数
| 环境变量 | 说明 |
| --- | --- |
| `RENT_PAYMENT_ENABLED` | 充值支付总开关。 |
| `RENT_PAYMENT_CONNECT_TIMEOUT_MS` | 连接支付系统超时。 |
| `RENT_PAYMENT_READ_TIMEOUT_MS` | 支付接口读取超时。 |
| `RENT_PAYMENT_RECONCILE_MS` | 主动查询充值订单的补偿周期。 |
### 6.2 每网络通道
Nile 使用 `RENT_PAYMENT_NILE_*`,主网使用 `RENT_PAYMENT_MAINNET_*`:
| 后缀 | 说明 |
| --- | --- |
| `ENABLED` | 是否启用该网络充值。 |
| `BASE_URL` | 支付系统开放 API 根地址。 |
| `API_KEY` / `API_SECRET` | 支付应用凭据,用于创建/查询订单及签名。 |
| `PUBLIC_KEY` | 支付应用的 RSA 公钥文件位置,用于验证支付通知签名。 |
| `TLS_CERTIFICATE` | HTTPS 服务器证书或 CA 证书位置,仅用于 Java TLS 信任。 |
| `NOTIFY_URL` | 支付系统回调地址,必须为 `https://<rent-domain>/api/rental/payment/notify/<channel>`。 |
| `MIN_AMOUNT` / `MAX_AMOUNT` | 单笔充值金额范围。 |
RSA 公钥与 TLS 证书用途不同:RSA 公钥验证业务通知签名;TLS 证书建立 HTTPS 信任。即使两者来自同一域名也不能互相替代。
支付通知请求必须携带 `X-Payment-Api-Key` 和 `X-Payment-Rsa-Signature`。租赁平台验签、幂等入库后返回纯文本 `ok`;无效通知返回 400。
## 7. 链上执行器
### 7.1 作用与安全边界
执行器不接收任意交易参数、私钥或 HTTP 口令。支付系统先把脱敏命令写入 `usdt_chain_execution`,再通过 HTTP 发送空正文唤醒请求。执行器从共享数据库读取任务,使用仅存在于执行器进程中的配置口令解锁钱包并执行。
HTTP 接口:
| 方法与路径 | 用途 | 成功响应 |
| --- | --- | --- |
| `GET /internal/v1/connectivity` | 验证网络、IP 白名单和 Bearer Token。 | `CONNECTED` |
| `GET /internal/v1/readiness` | 额外验证数据库网络配置和钱包配置口令。 | `READY` |
| `POST /internal/v1/executions` | 空正文唤醒任务扫描。 | HTTP 202 `ACCEPTED` |
所有路径都要求真实 TCP 来源 IP 在白名单中并携带 `Authorization: Bearer <token>`。执行器不信任 `X-Forwarded-For`。
### 7.2 执行器进程配置
| 环境变量 | 必需 | 说明 |
| --- | --- | --- |
| `CHAIN_EXECUTOR_BIND_ADDRESS` | 是 | 执行器 HTTP 监听地址,必须属于本机。直连可填内网 IP;Nginx 同机代理建议 `127.0.0.1`。 |
| `CHAIN_EXECUTOR_PORT` | 是 | HTTP 端口,例如 `9089`。 |
| `CHAIN_EXECUTOR_ALLOWED_IPS` | 是 | 允许的实际 TCP 来源 IP,逗号分隔。经过同机 Nginx 时通常包含 `127.0.0.1`。 |
| `CHAIN_EXECUTOR_TOKEN` | 是 | 至少 32 位随机 Bearer Token,必须与支付系统一致。 |
| `CHAIN_EXECUTOR_CONFIGURATION_PASSWORD` | 是 | 主钱包配置文件口令,只允许存在执行器环境中,禁止写入支付系统和日志。 |
| `CHAIN_EXECUTOR_ALLOWED_NETWORK` | 是 | `NILE` 或 `MAINNET`,必须与数据库全局配置一致。 |
| `CHAIN_EXECUTOR_BROADCAST_ENABLED` | 是 | 必须明确为小写 `true`,否则拒绝启动。 |
| `CHAIN_EXECUTOR_DB_URL` | 是 | 与支付系统共享的 MySQL JDBC URL。 |
| `CHAIN_EXECUTOR_DB_USER` / `CHAIN_EXECUTOR_DB_PASSWORD` | 是 | 建议使用最小权限专用数据库账号。 |
| `TRON_GRID_API_KEY` | 是 | 执行器链查询/交易所需 TronGrid Key。 |
| `TRON_SCAN_API_KEY` | 按实现需要 | 执行器使用的 TronScan Key;注意此处变量名为 `TRON_SCAN_API_KEY`。 |
支付系统使用 `TRONSCAN_API_KEY`,执行器使用 `TRON_SCAN_API_KEY`,两个变量名当前并不相同。
### 7.3 支付系统的执行器客户端配置
| 环境变量 | 说明 |
| --- | --- |
| `CHAIN_EXECUTOR_ENABLED` | 是否启用远程执行通道。建议首次部署先设为 `false`,服务验证后由管理员启用。 |
| `CHAIN_EXECUTOR_BASE_URL` | 执行器根地址,例如直连 `http://10.0.0.20:9089` 或 Nginx `https://executor.internal:9088`。不要带 `/internal/v1`。 |
| `CHAIN_EXECUTOR_TOKEN` | 与执行器完全一致的 Bearer Token。 |
| `CHAIN_EXECUTOR_TLS_CERTIFICATE` | HTTPS 私有/自签证书或 CA 的位置,仅支持 `file:/...` 或 `classpath:...`。HTTP 模式留空。 |
| `CHAIN_EXECUTOR_HEALTH_CHECK_INTERVAL_MS` | 周期性健康检查间隔。 |
| `CHAIN_EXECUTOR_HEALTH_FAILURE_THRESHOLD` | 连续失败达到此阈值后自动停用执行器。 |
代码还支持属性 `chain.executor.health-check-initial-delay-ms`,用于设置启动后首次周期检查延迟;当前 YAML 未提供同名环境变量占位,可在外部 YAML 中显式配置。
支付系统启动时会进行执行器验证。连续健康检查失败后,远程执行自动停用,只能回退到页面密码执行;执行器恢复上线后不会自动重新启用,需要管理员在 `USDTmanage/usdtConfig` 中立即检查并重新启用,避免故障抖动自动恢复广播能力。
### 7.4 任务状态与重启恢复
| 状态/模式 | 处理规则 |
| --- | --- |
| `QUEUED + REMOTE` | 执行器扫描并领取。 |
| 未签名的 `RUNNING + REMOTE` | 执行器启动时将确认可安全重试的记录恢复为 `QUEUED`,并重新校验有效期、余额和资源。 |
| 仍有签名或结果歧义的 `RUNNING` | 不自动重领,启动日志列出,需结合交易哈希和链上结果人工核验。 |
| `SIGNED` | 只重播数据库中同一笔签名交易,禁止重新构造。 |
| `PASSWORD` | 依赖管理员页面口令流程,不由远程执行器自动恢复。 |
## 8. HTTP 与 Nginx HTTPS
执行器自身只提供 HTTP,不加载 PKCS12/JKS。直接 HTTP 适用于严格隔离的受控内网;需要链路加密时由 Nginx 终止 TLS。
### 8.1 HTTP 直连
执行器:
```bash
CHAIN_EXECUTOR_BIND_ADDRESS=10.0.0.20
CHAIN_EXECUTOR_PORT=9089
CHAIN_EXECUTOR_ALLOWED_IPS=10.0.0.10
```
支付系统:
```bash
CHAIN_EXECUTOR_BASE_URL=http://10.0.0.20:9089
CHAIN_EXECUTOR_TLS_CERTIFICATE=
```
端口只允许支付系统 IP 访问,不能暴露公网。
### 8.2 Nginx HTTPS
执行器监听回环地址:
```bash
CHAIN_EXECUTOR_BIND_ADDRESS=127.0.0.1
CHAIN_EXECUTOR_PORT=9089
CHAIN_EXECUTOR_ALLOWED_IPS=127.0.0.1
```
Nginx 示例:
```nginx
server {
listen 10.0.0.20:9088 ssl;
server_name executor.internal;
ssl_certificate /etc/nginx/certs/executor-cert.pem;
ssl_certificate_key /etc/nginx/certs/executor-private.key;
ssl_protocols TLSv1.2 TLSv1.3;
allow 10.0.0.10; # 支付系统 IP
deny all;
location /internal/v1/ {
proxy_pass http://127.0.0.1:9089;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Authorization $http_authorization;
proxy_set_header Host $host;
proxy_connect_timeout 2s;
proxy_read_timeout 5s;
proxy_send_timeout 5s;
proxy_buffering off;
}
location / { return 404; }
}
```
支付系统:
```bash
CHAIN_EXECUTOR_BASE_URL=https://executor.internal:9088
CHAIN_EXECUTOR_TLS_CERTIFICATE=file:/etc/ruoyi/certs/executor-cert.pem
```
证书必须在有效期内,并包含与 URL 主机匹配的 SAN。只有 CN、没有 SAN 的自签证书在现代 TLS 主机名校验中可能失败。使用 IP URL 时证书需包含 IP SAN;推荐使用内网 DNS 名和对应 DNS SAN。
## 9. 推荐环境变量模板
模板仅展示核心关系,不应提交填好秘密的文件到版本库。
### 9.1 支付系统
```bash
APP_PRIVATE_KEY_ENCRYPTION_KEY=<at-least-32-char-random-secret>
USDT_EXCHANGE_RATE=1
PAYMENT_CHECKOUT_URL=https://pay.example.com/public/usdtPay
TRON_OPERATION_RESOURCE_REDUNDANCY_PERCENT=20
TRON_GRID_API_KEY=<trongrid-api-key>
TRONSCAN_API_KEY=<tronscan-api-key>
USDT_RESOURCE_RENTAL_ENABLED=true
USDT_RESOURCE_RENTAL_PROVIDER=INTERNAL
USDT_RESOURCE_ARRIVAL_TIMEOUT_SECONDS=300
CHAIN_EXECUTOR_ENABLED=true
CHAIN_EXECUTOR_BASE_URL=https://executor.internal:9088
CHAIN_EXECUTOR_TOKEN=<same-random-token-as-executor>
CHAIN_EXECUTOR_TLS_CERTIFICATE=file:/etc/ruoyi/certs/executor-ca-or-cert.pem
CHAIN_EXECUTOR_HEALTH_CHECK_INTERVAL_MS=10000
CHAIN_EXECUTOR_HEALTH_FAILURE_THRESHOLD=3
```
### 9.2 INTERNAL 租赁平台
```bash
RENT_ENABLED=true
RENT_DOMAIN=rent.example.com
RENT_MASTER_KEY=<base64-of-exactly-32-random-bytes>
RENT_MASTER_KEY_VERSION=v1
RENT_CONFIRMATIONS=19
RENT_RPC_KEY=<trongrid-api-key>
RENT_HISTORY_EMBEDDED_ENABLED=true
RENT_HISTORY_NETWORKS=MAINNET
RENT_NILE_DEPOSIT=<nile-tron-address>
RENT_MAINNET_DEPOSIT=<mainnet-tron-address>
```
### 9.3 链上执行器
```bash
CHAIN_EXECUTOR_BIND_ADDRESS=127.0.0.1
CHAIN_EXECUTOR_PORT=9089
CHAIN_EXECUTOR_ALLOWED_IPS=127.0.0.1
CHAIN_EXECUTOR_TOKEN=<same-random-token-as-payment>
CHAIN_EXECUTOR_CONFIGURATION_PASSWORD=<wallet-configuration-password>
CHAIN_EXECUTOR_ALLOWED_NETWORK=MAINNET
CHAIN_EXECUTOR_BROADCAST_ENABLED=true
CHAIN_EXECUTOR_DB_URL=jdbc:mysql://<db-host>:3306/<db>?useUnicode=true&characterEncoding=utf8&connectionTimeZone=LOCAL&forceConnectionTimeZoneToSession=true
CHAIN_EXECUTOR_DB_USER=<executor-db-user>
CHAIN_EXECUTOR_DB_PASSWORD=<executor-db-password>
TRON_GRID_API_KEY=<trongrid-api-key>
TRON_SCAN_API_KEY=<tronscan-api-key>
```
## 10. 启动顺序
1. 备份并初始化/升级数据库表。
2. 配置 MySQL、Redis、TRON 网络和支付系统基础秘密。
3. 若使用 INTERNAL,启动带 `rental` profile 的租赁平台,确认 RPC、历史采集、套餐、节点和应用凭据正常。
4. 在 `USDTmanage/usdtConfig` 保存对应网络的 INTERNAL 或 DUIYA 配置。
5. 首次将 `USDT_RESOURCE_RENTAL_ENABLED=false`、`CHAIN_EXECUTOR_ENABLED=false` 启动支付系统,完成基础页面和数据库检查。
6. 启动链上执行器,确认日志显示配置校验、数据库/钱包就绪和 HTTP 监听成功。
7. 若使用 Nginx,执行 `nginx -t`,reload 后验证 HTTPS。
8. 配置并启用支付系统执行器客户端,在全局配置页面执行“立即检查”,确认检查时间和状态更新。
9. 启用资源租赁,先在 Nile 或小额主网业务完成报价、下单、链上到账、签名、广播全流程验证。
## 11. 验证命令
### 11.1 执行器直连 HTTP
```bash
curl -v \
-H 'Authorization: Bearer <executor-token>' \
http://127.0.0.1:9089/internal/v1/connectivity
curl -v \
-H 'Authorization: Bearer <executor-token>' \
http://127.0.0.1:9089/internal/v1/readiness
```
### 11.2 Nginx HTTPS
```bash
curl -v \
--cacert /etc/ruoyi/certs/executor-cert.pem \
-H 'Authorization: Bearer <executor-token>' \
https://executor.internal:9088/internal/v1/readiness
```
只在诊断 TLS 握手时临时使用 `curl -k`,不要把跳过证书校验作为生产配置。
### 11.3 证书检查
```bash
openssl x509 -in /etc/nginx/certs/executor-cert.pem \
-noout -subject -issuer -dates -fingerprint -sha256 -ext subjectAltName
openssl s_client -connect executor.internal:9088 \
-servername executor.internal </dev/null
```
### 11.4 数据库状态
```sql
SELECT provider_code, network, base_url, currency, enabled, created_at
FROM usdt_resource_rental_config
ORDER BY id DESC;
SELECT id, business_key, stage, required_energy, required_bandwidth,
available_energy, available_bandwidth, deadline_at, error_message
FROM usdt_resource_preparation
ORDER BY created_at DESC
LIMIT 20;
SELECT execution_id, business_key, execution_mode, status,
transaction_id, error_message, updated_at
FROM usdt_chain_execution
ORDER BY created_at DESC
LIMIT 20;
```
不要查询或导出 `api_key_cipher`、`api_secret_cipher`、`signed_transaction`、钱包私钥等敏感列用于普通排查。
## 12. 常见故障
### 12.1 `GET /api/system/chain-resources/config` 提示方法不支持
后端实际控制器路径是 `GET /system/chain-resources/config`。前端通常通过 `/api` 或 `/dev-api` 代理前缀转发,需检查代理是否将前缀正确移除。若请求命中旧实例,也会出现 GET 不支持,应确认部署包和实例版本一致。
### 12.2 执行器启动联通测试失败
按顺序检查:
1. 支付系统 `CHAIN_EXECUTOR_BASE_URL` 协议是否与入口一致。
2. HTTP 是否误写成 HTTPS,或 HTTPS 是否绕过了 Nginx 直接访问执行器 HTTP 端口。
3. 支付系统真实来源 IP 是否在 Nginx和执行器对应白名单中。
4. 两端 `CHAIN_EXECUTOR_TOKEN` 是否完全一致且无换行。
5. `readiness` 还要求数据库网络配置匹配和钱包配置口令正确。
6. HTTPS 私有证书是否通过 `CHAIN_EXECUTOR_TLS_CERTIFICATE` 加载,SAN 是否匹配 URL。
### 12.3 浏览器显示 `ERR_EMPTY_RESPONSE`
常见原因是对纯 HTTP 执行器端口发起 HTTPS 握手。执行器不支持 TLS:使用 `http://...:9089`,或访问 Nginx 的 `https://...:9088`。浏览器无法方便地附带 Bearer Token,也不是合适的验收工具,应使用 `curl`。
### 12.4 `TLS证书加载失败`
- 路径必须为支付系统 JVM 可读的 `file:/absolute/path.pem` 或有效 `classpath:` 资源。
- 文件应为 PEM X.509 证书/CA,而不是只有私钥、PKCS12 中的错误条目或 Nginx 配置文本。
- 检查文件权限、有效期和完整证书链。
- 证书 SAN 必须匹配 `CHAIN_EXECUTOR_BASE_URL` 的主机名或 IP。
### 12.5 资源订单成功但迟迟不执行
平台订单成功并不代表资源已到账。检查:
- `usdt_resource_rental_order` 的供应商状态和错误信息。
- `usdt_resource_preparation` 的 `required_*` 与 `available_*`。
- 目标地址是否正确、网络是否一致。
- `USDT_RESOURCE_ARRIVAL_TIMEOUT_SECONDS` 是否足够。
- RPC 是否返回最新账户资源,是否被限流或缓存。
不要手工重复下单。唯一键和未知状态保护用于避免同一资源重复购买;应先查询供应商和链上结果,再决定人工处理。
### 12.6 执行任务停在 `RUNNING`
先查 `transaction_id` 和是否存在签名交易:
- 无签名、无交易哈希且为远程任务:重启执行器会尝试安全恢复。
- 已签名:只能重播同一签名交易,不能重新构造。
- 有交易哈希:先查链上结果,再做业务对账。
- 日志显示 `VALIDATE_BUSINESS`:业务状态、金额、地址或任务有效期已变化,应检查业务表,不是简单网络故障。
### 12.7 Protobuf 与 TRON Trident 不兼容
出现 `NoSuchMethodError: com.google.protobuf.Any.pack(...)` 表示运行时装载了不兼容的 `protobuf-javalite` 或旧版 `protobuf-java`。应在最终构建依赖中只保留与当前 TRON Trident 兼容的 protobuf 版本,检查 fat jar/lib 目录是否残留旧 jar,清理后重新完整构建和部署。
## 13. 安全、备份与轮换
- 数据库、Redis、API Secret、Bearer Token、钱包密码、RSA 私钥、TOTP 密钥和 `RENT_MASTER_KEY` 不得写日志、HTTP 响应或前端状态。
- 配置文件中已经出现过的秘密应视为泄露并轮换,包括数据库/Redis 密码、TRON API Key、执行器 Token 和云服务密钥。
- `RENT_MASTER_KEY`、`APP_PRIVATE_KEY_ENCRYPTION_KEY`、`TOTP_ENCRYPTION_KEY` 轮换前必须先设计版本化解密和数据迁移,不能直接替换。
- `CHAIN_EXECUTOR_TOKEN` 可在维护窗口双端同步替换并重启;替换期间先停用远程执行。
- `CHAIN_EXECUTOR_CONFIGURATION_PASSWORD` 轮换后执行器 readiness 会立即失败,必须同步更新钱包配置并验证。
- 对数据库和租赁历史归档目录做加密备份,并定期验证恢复。
- Nginx 和防火墙只开放必需来源;执行器端口绝不能暴露公网。
- 上线主网前在 Nile 完成端到端演练,并使用小额主网交易验证资源估算、到账确认、广播和业务对账。
## 14. 上线检查清单
- [ ] 已轮换所有曾进入版本库的真实凭据。
- [ ] 基础支付表和所启用功能的增量 SQL 已执行并备份。
- [ ] 支付系统、租赁平台、执行器使用相同网络。
- [ ] `RENT_MASTER_KEY` 是 Base64 编码的 32 字节随机值并已离线备份。
- [ ] 资源平台配置已在后台保存,网络、周期、步长和费用上限正确。
- [ ] 执行器 Token 两端一致,钱包配置口令只存在执行器。
- [ ] HTTP 端口受防火墙限制,或 Nginx TLS 证书 SAN 与 URL 匹配。
- [ ] connectivity、readiness、立即检查均通过且页面显示正确检查时间。
- [ ] 已验证资源下单后由系统独立确认链上到账,不依赖平台成功响应。
- [ ] 已验证重复点击、超时和服务重启不会重复租赁。
- [ ] 已验证 SIGNED 任务只重播同一签名交易。
- [ ] 已配置日志保留、数据库备份和告警,但日志不包含任何秘密。
+66
View File
@@ -0,0 +1,66 @@
# Google OpenID Connect 部署说明
## 登录与绑定策略
- Google 身份只使用 OpenID Connect 的 `sub` 作为唯一标识,不以邮箱匹配本地用户。
- 未绑定的 Google 账号不能登录,也不会自动注册本地账号。
- 用户必须先通过账号密码登录,在“个人中心 -> 账号安全”中主动绑定 Google。
- 一个本地账号只能绑定一个 Google 身份,一个 Google 身份也只能绑定一个本地账号。
## 数据库升级
部署应用前执行:
```sql
SOURCE /path/to/myEpusdt/sql/google_oauth.sql;
```
脚本只新增 `sys_user_google_oauth` 表,不修改 `sys_user` 和现有登录数据。执行前仍应按生产规范备份数据库。
## Google Cloud 配置
1. 在 Google Auth Platform 创建 Web application 类型的 OAuth Client。
2. OAuth 同意屏幕只申请 `openid`、`email`、`profile`。
3. 将后端固定回调地址登记为 Authorized redirect URI,例如:
```text
https://api.example.com/auth/google/callback
```
登记值必须与 `GOOGLE_OAUTH_REDIRECT_URI` 完全一致。生产环境必须使用 HTTPS;仅本地开发允许 `http://localhost` 或 `http://127.0.0.1`。
## 环境变量
Linux 可在应用启动前设置:
```bash
export GOOGLE_OAUTH_ENABLED=true
export GOOGLE_OAUTH_CLIENT_ID='your-client-id.apps.googleusercontent.com'
export GOOGLE_OAUTH_CLIENT_SECRET='your-client-secret'
export GOOGLE_OAUTH_REDIRECT_URI='https://api.example.com/auth/google/callback'
export GOOGLE_OAUTH_FRONTEND_RESULT_URL='https://app.example.com/auth/google/result'
```
`GOOGLE_OAUTH_CLIENT_SECRET` 只能保存于服务器环境变量或密钥管理系统,不得写入前端、日志或版本库。修改环境变量后重启后端服务。
## 发布验证
本项目使用 `ruoyi-admin.jar + lib/` 的外置依赖方式发布。执行 Maven `package` 后,必须同时部署:
```text
ruoyi-admin/target/ruoyi-admin.jar
ruoyi-admin/target/lib/
```
不能只替换 `ruoyi-admin.jar`。Google OIDC 至少依赖 `google-api-client-1.34.1.jar`、`google-http-client-1.41.8.jar`、`google-http-client-gson-1.41.8.jar` 和 `google-oauth-client-1.33.2.jar`;缺少 `google-http-client` 会在启动时出现 `NoClassDefFoundError: com/google/api/client/json/JsonFactory`。
1. 使用本地账号密码登录,进入个人中心绑定 Google。
2. 退出系统,再从登录页使用已绑定的 Google 账号登录。
3. 使用未绑定的 Google 账号登录,确认页面提示先登录本地账号绑定。
4. 禁用一个已绑定的本地用户,确认 Google 登录被拒绝。
5. 确认重复回调、重复交换登录票据均被拒绝。
6. 确认原有账号密码登录、角色、菜单权限和退出登录不受影响。
## 回滚
设置 `GOOGLE_OAUTH_ENABLED=false` 并重启后端即可关闭登录入口。原有密码登录保持可用;关联表建议保留,避免重新发布后丢失既有绑定关系。
@@ -0,0 +1,125 @@
# MAINNET 非广播功能测试报告
测试日期:2026-11-07
测试范围:支付系统、资源租赁逻辑、链上执行器、TRON MAINNET 只读链路。
明确排除:真实资源购买、租赁订单创建、钱包解锁、交易签名、交易广播及生产数据库写入。
## 1. 结论
当前代码的支付、租赁和执行器核心逻辑测试总体通过,TRON MAINNET 的 TronGrid 与 TronScan 只读接口实测可用。执行器 HTTPS 入口可达且拒绝非白名单来源,但由于测试工作站不在执行器允许来源中,无法从本机完成已部署执行器的 readiness 验证。
尚不能据此宣布主网全链路正式通过。剩余主网验证包括:真实 INTERNAL/DUIYA 报价、真实资源下单与到账、执行器从支付服务器来源的 readiness、主网签名和小额广播。这些步骤需要在生产同等网络和凭据环境中执行,其中下单和广播需要单独授权。
## 2. 安全边界
本轮未调用以下接口或能力:
- DUIYA `/buy_energy`、`/buy_net`。
- INTERNAL `/api/rental/v1/create`。
- 任何钱包解锁和真实签名。
- TRON `broadcasttransaction` 或等价广播接口。
- 已部署支付/租赁系统的生产数据库写操作。
测试日志中出现的“创建”“签名”“广播”均来自 H2、mock HTTP 或 fake chain,不连接真实链和真实供应商。
## 3. 自动化测试结果
### 3.1 `ruoyi-system`
命令使用 JDK 8 执行 Maven 测试。
| 项目 | 结果 |
| --- | --- |
| 唯一测试数 | 257 |
| 按设计跳过 | 4 |
| 业务失败 | 0 |
| 首轮环境性异常 | 1 个 TLS 本地夹具超时 |
| TLS 单独复跑 | 2/2 通过 |
已覆盖:
- 链上任务路由、状态持久化、未签名任务恢复、SIGNED 重播规则。
- 资源预检、按地址互斥、租赁授权、费用上限、幂等防重复下单。
- INTERNAL 与 DUIYA 请求格式、鉴权、报价和查询响应解析(本地 mock)。
- 支付订单、代付订单、回调、充值、提现、结算和时区处理。
- 租赁 HMAC、nonce 防重放、节点派单、资源核验、历史采集和清理。
- MAINNET/NILE 网络隔离及主网定价分支。
- 自签 TLS 证书加载、保留主机名校验、禁止远程证书 URL。
- TronGrid/TronScan 端点切换、限流和异常降级(本地 mock)。
TLS 用例首次在本地 `HttpsServer` 请求中超时,单独复跑 2/2 通过,暂定为本机测试夹具偶发问题。该结果应保留观察;若 CI 重复出现,应为本地 HTTPS server 配置独立线程池并增加稳定性测试。
### 3.2 `ruoyi-admin`
| 项目 | 结果 |
| --- | --- |
| 测试数 | 40 |
| 失败/异常/跳过 | 0/0/0 |
首次运行发现 `AggregationItemCancellationTest` 仍按旧的双参数方法签名做反射。生产方法已经增加 `Boolean resourceOnly` 参数,导致测试在进入业务逻辑前报 `NoSuchMethodException`。已仅更新测试签名和调用参数,未修改生产代码,复跑 40/40 通过。
覆盖内容包括归集取消与执行互斥、任务删除约束、支付任务、数据库时区、TOTP、订单权限和 Webhook 调试验签。
### 3.3 `usdt-chain-executor`
| 项目 | 结果 |
| --- | --- |
| 测试数 | 6 |
| 失败/异常/跳过 | 0/0/0 |
覆盖内容包括:
- 必填启动参数和广播开关保护。
- HTTP 监听、Bearer Token、TCP 来源 IP 白名单。
- connectivity、readiness 和空正文唤醒接口。
- 钱包配置口令或网络不匹配时拒绝 readiness。
- Protobuf 完整运行时检查,确认装载 `protobuf-java 3.25.5`,未装载冲突的 javalite 实现。
## 4. TRON MAINNET 真实只读测试
API Key 从现有配置在进程内读取,测试命令和报告均未输出凭据。
| 服务 | 检查 | HTTP | 结果 | 本次响应摘要 |
| --- | --- | --- | --- | --- |
| TronGrid | `wallet/getnowblock` | 200 | 通过 | 返回有效最新区块高度 |
| TronGrid | `wallet/getchainparameters` | 200 | 通过 | 返回 81 项链参数 |
| TronGrid | `wallet/getaccount` | 200 | 通过 | 返回与请求一致的主网地址 |
| TronGrid | `wallet/getaccountresource` | 200 | 通过 | 返回有效全网能量参数 |
| TronScan | `api/accountv2` | 200 | 通过 | 返回有效地址字段 |
这证明当前两套 API Key、DNS、TLS、主网 API 访问和基础响应格式可用。它不能替代长时间限流、故障切换和主网写操作测试。
## 5. 已部署执行器检查
从当前测试工作站访问配置中的 HTTPS 执行器:
| 路径 | 结果 | 解释 |
| --- | --- | --- |
| `/internal/v1/connectivity` | HTTP 403 | HTTPS 入口可达,访问被来源 IP 或 Bearer 防线拒绝。 |
| `/internal/v1/readiness` | HTTP 403 | 同上,尚未进入钱包口令/数据库就绪检查。 |
该结果符合执行器的安全设计,但不代表支付服务器到执行器的真实链路通过。应登录支付系统所在服务器,使用相同 Base URL 和受控 Token 执行 readiness,或在全局配置页点击“立即检查”。不要为了测试把执行器开放给所有来源。
## 6. 未覆盖与上线前必测
| 项目 | 当前状态 | 原因/下一步 |
| --- | --- | --- |
| INTERNAL MAINNET 真实报价 | 未实测 | 当前工作站没有租赁应用数据库凭据/API Secret;可在支付服务器执行只读 `/quote`。 |
| DUIYA MAINNET 真实报价 | 未实测 | 当前工作站没有解密后的平台凭据;只调用 `/query_price`,禁止调用购买接口。 |
| 平台真实订单查询 | 未实测 | 需要一张已有主网测试订单号,避免创建新订单。 |
| 资源到账确认 | 未实测 | 需要已有租赁订单和目标地址,比较下单前后链上资源。 |
| 支付服务器到执行器 readiness | 被白名单阻止 | 必须从白名单内的支付服务器执行。 |
| 主网资源购买 | 明确排除 | 会产生外部订单和费用,需要单独授权。 |
| 主网签名与广播 | 明确排除 | 用户本轮明确不测试实际广播。 |
## 7. 风险与建议
1. 当前 API Key 已通过对话和版本化配置出现,应尽快轮换,并改为部署环境变量或密钥管理服务注入。
2. `ruoyi-system` 的本地 TLS 测试出现一次偶发超时,虽然复跑通过,仍建议在 CI 连续执行多次观察稳定性。
3. 当前 Maven 版本较旧,测试依赖仍报告若干缺少 POM 元数据的本地制品警告;构建能完成,但应维护内部 Maven 仓库中的完整 POM。
4. 主网启用前至少完成一次“真实报价但不下单”,确认网络、套餐、数量步长、费用币种和费用上限。
5. 首次主网购买和广播应使用独立小额地址、最低数量、严格费用上限,并全程核对 `usdt_resource_preparation`、`usdt_resource_rental_order` 和 `usdt_chain_execution`。
## 8. 本轮代码变化
仅修改测试文件 `ruoyi-admin/src/test/java/com/ruoyi/web/controller/system/AggregationItemCancellationTest.java`,使反射调用匹配生产方法当前的三个参数。未修改任何生产业务逻辑或配置。
+124
View File
@@ -0,0 +1,124 @@
# Pinggy 外联调用来源定位
## 当前结论与证据边界
`grpc.nile.trongrid.io` 的 AWS ELB CNAME 属于已有 Nile 查询链路。
两个 `*.run.pinggy-free.link` 域名的 DNS 记录不能直接确定 Java 调用者,
也不能凭 NXDOMAIN 断言已经成功连接或外传信息。
已检查的本地动态插件 JAR 和 `D:/configs/license.dll` 中未命中目标域名的明文、
UTF-16 或 Base64 内容。此前识别到 `org.json:json:19970182` 含授权代码,
但没有把它与这两个 Pinggy 域名关联的调用栈;暂不能认定是该包引入。
实际部署目录、数据库、运行环境可能与本机不同,需要在复现进程中采样。
## 开启方式
该功能针对本项目 JDK 8,默认关闭。管理后端和独立执行器均已在 `main` 的
Spring 启动之前调用 `NetworkRequestTrace.installIfEnabled()`,不需要修改业务配置。
IDEA 的 Run/Debug Configuration → VM options 加入:
```text
-Dnetwork.trace.enabled=true
```
部署环境也可以设置 `NETWORK_TRACE_ENABLED=true`。JVM 参数优先于环境变量。
必须重启实际出现异常的 Java 进程,修改当前终端变量不会影响已经启动的进程。
无需把开关放进 `application.yml`;这里是在 Spring 读取 YAML 之前安装。
现有 `java -jar` 启动命令把开关放在 `-jar` 之前,例如:
```bash
java -Dnetwork.trace.enabled=true -jar ruoyi-admin.jar
```
默认匹配 `pinggy-free.link` 和它的子域名。如果只需这两个域名,可以设置:
```text
-Dnetwork.trace.hosts=wzndf-185-244-148-229.run.pinggy-free.link,lmdpj-185-244-148-229.run.pinggy-free.link
```
环境变量等效项为 `NETWORK_TRACE_HOSTS`。需要顺便对照 Nile 调用时,可以把
`grpc.nile.trongrid.io` 加入逗号分隔的列表。不要使用 URL、密码或查询串作为过滤值。
更新主程序时,必须同时更新本轮构建的 `ruoyi-system` JAR;外置 `lib` 部署不能只更新
`ruoyi-admin.jar`,也不能把旧 `ruoyi-system` 留在同一 classpath 中。
主模块已显式声明系统模块依赖,完整 Maven 构建会先编译当前系统模块。
## 查看结果
启动控制台首先应显示:
```text
[NETWORK-TRACE] ENABLED java=1.8... hosts=pinggy-free.link maxEvents=200 output=stderr observation-only
```
日志直接写入标准错误输出,覆盖日志框架尚未初始化的时段。
IDEA 控制台、systemd journal 或容器日志一般会收集 stderr;只看业务 `info.log`
可能看不到。自行启动时可以在原命令后追加 `2>network-trace.log` 收集诊断。
目标域名被解析时,输出形式如下(以下为格式示意,并非已经捕获的可疑调用):
```text
[NETWORK-TRACE] BEGIN event=1 timeMillis=... threadId=... operation=DNS host=lmdpj-185-244-148-229.run.pinggy-free.link port=-1
origin com.example.CallbackWorker source=file:/srv/app/lib/example.jar
at java.net.InetAddress.getAllByName(...)
at com.example.CallbackWorker.send(CallbackWorker.java:123)
[NETWORK-TRACE] END event=1
```
`origin` 显示实际执行类的 CodeSource,而非根据类名推测 JAR;`at` 显示方法和行号。
结合类名与相应栈帧,判断请求来自业务回调、依赖授权逻辑或动态插件。
若栈帧是异步 DNS 工作线程,它只能说明当前解析任务的执行者,仍需沿上游任务入口追查。
重点判读:
| 栈上的业务类 | 后续核查 |
| --- | --- |
| `PaymentCallbackWorker` | `orders.notify_url`、订单 ID、回调次数 |
| `PayoutCallbackService` | `usdt_payout_order.notify_url` |
| `RentalWorkers` | `rent_order.notify_url`、`rent_webhook` 对应明细;域名校验本身也可能触发 DNS |
| `com.license.*` | 日志中实际加载的 JAR、部署环境的授权地址配置及本地 DLL |
| 其他库或插件类 | 以 `origin source=` 指向的实际 JAR 为准,核对该部署文件的哈希及来源 |
## 同步检查数据库中的旧回调地址
当前本机无法连接配置中的数据库,所以没有假定数据库里不存在目标域名。
可以在复现服务实际连接的数据库中执行以下只读查询,只返回记录 ID 和状态,
不返回完整 URL、请求参数、API Key 或私钥。没有租赁表的库跳过相应查询。
```sql
SELECT id, status, callback_num, callback_confirm
FROM orders WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status, callback_num, callback_confirm
FROM usdt_payout_order WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status
FROM rent_order WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
SELECT id, status
FROM rent_app WHERE LOWER(notify_url) LIKE '%pinggy-free.link%' LIMIT 100;
```
命中仅代表存在配置,不代表该行正被定时任务执行;需要结合调用栈和任务状态确认。
不要直接删除订单、修改回调状态或清空队列作为定位手段。
## 诊断边界与关闭
- 该钩子基于 JDK 8 `SecurityManager.checkConnect`。`port=-1` 表示解析前检查,
不是 HTTP 已成功发出。诊断本身不访问目标域名,也不改变 DNS 缓存、代理或连接结果。
- 只记录域名、时间、线程 ID、栈帧和类来源,不采集完整 URL、请求头、正文或钱包数据。
- 已存在安全管理器时输出 `NOT_INSTALLED existing-security-manager`,不会覆盖已有策略。
这是观察工具,不是安全沙箱。部分较新 JDK 已禁用此机制,应使用项目 JDK 8。
- 最多输出 200 条事件;出现 `LIMIT_REACHED` 后仍正常执行网络操作,但停止打印。
- JNI、自建 DNS 解析器、原生库、子进程和其他服务的请求不一定经过本钩子。
一直没有日志时,应先核对 `ENABLED`、进程、部署 JAR、事件上限,再用操作系统工具关联 PID。
- 定位后删除 VM 参数/环境变量并重启,或显式设置 `-Dnetwork.trace.enabled=false`。
现有业务任务、回调及链上逻辑均不因该开关而被禁用。
## 验证
`NetworkRequestTraceTest` 在独立 JVM 中验证默认关闭、保留原安全管理器、
通过本地 `localhost` 真实解析记录动态 JAR 来源、域名边界、敏感 URL 拒绝输出和事件上限。
测试不解析 Pinggy 域名,也不启动真实数据库或链上调度。
+27
View File
@@ -0,0 +1,27 @@
# 本人租赁资金对账单
租赁账户与供应商首页顶部新增“资金对账单”。展开后选择网络与记账日期,点击“下载 Excel”。默认沿用首页网络及近7/14/30天;导出日期独立于看板统计。执行 `sql/rent_statement_export_menu.sql`,为 PROXY_ACCOUNT、PROXY_SUPPLIER 授予 `rent:statement:export`,重新登录后生效。父菜单需要已有 `rent:portal:view` 页面。
本功能复用现有rent_account及rent_ledger,无需新增表或迁移历史资金数据。权限SQL需部署方执行,不会由页面自动修改角色。
## 文件内容和口径
- 账户收支汇总:账户编号、网络、时区、起止日期、生成时间、期初/期末总资产、资产增加/减少及校验;同时列出可用、冻结、待结算三个分户的期初、增、减、期末。
- 业务分类汇总:按 event_type 汇总笔数、资产增减和三个分户净变化。
- 资金流水明细:流水ID、记账时间、事件类型、资产与分户变动、记账后余额、订单/结算/退款/提现/冲正关联ID及记账说明。只导出明确白名单字段,不含私钥、API Secret、账户凭证或内部付款证据。
总资产=可用余额+冻结余额+待结算收益。逐笔三个分户变动之和大于0为资产增加,小于0为资产减少,0为内部划转/无净变化。因此冻结、解冻、收益结算转入可用不会重复增加收入或支出。供应商毛收入和平台扣费保留为独立事件,扣费体现在供应商待结算减少,不将平台自身收入算作本人资产。该口径是资金账本资产变化,不能等同链上钱包收付款或利润表。
同一用户双角色共用同网络资金账户,导出完整账本,不按角色遗漏其中一侧流水。NILE与MAINNET独立,禁止跨网汇总。日期按服务器/JVM本地时区,包括起止当天,数据库使用左闭右开区间;当天数据截至生成本次一致性快照。冻结中的资金仍属于资产。无流水区间仍输出期初、期末余额。
期末余额由同一事务的当前账户余额减去结束日期之后的流水变化还原;期初=期末-区间净变化。不修改历史数据,不触发链上查询,不创建账户。明细按不可变流水ID升序,金额及编号为Excel文本,保持6位小数及大整数精度。备注以文本输出,不执行公式。
## 接口与限制
`POST /rental/statements/export?network=NILE&from=2026-11-01&to=2026-11-03`,需登录与 `rent:statement:export` 权限。仅支持NILE/MAINNET、单次最多366天/50000条,结束日期不能晚于服务器当天。越限明确拒绝并提示分段导出,禁止静默截断。未开通账户返回业务错误。客户端不传userId/accountId,即使额外提交也不参与查询。
成功返回xlsx二进制,失败返回原有JSON错误;前端识别错误Blob而不下载损坏文件。响应不缓存,不在浏览器本地存储账本。SXSSF临时文件在完成/失败后均清理。按服务端导出开始、快照生成、导出完成/失败日志中的userId/network/date/rows排查,不记录金额、流水正文和凭证。
## 验证记录
JDK8隔离租赁回归186项通过。新增用例覆盖跨用户/网络过滤、冻结与结算内部划转、真实消费与提现扣款、历史期后变动还原、左闭右开日期边界、空区间和大金额文本精度,并通过POI重新读取生成的三个工作表、验证备注不是公式。前端模板/脚本检查及实际Vue组件桌面/手机交互验证通过;演示下载使用隔离测试生成的xlsx,未连接真实资金账户。impeccable独立收尾评审结论ship。
+185
View File
@@ -0,0 +1,185 @@
# 地址上链订单:固定转入 1 TRX
## 业务与费用
同一网络、同一接收地址只能存在一笔待处理的地址上链订单,限制跨应用、跨用户生效。WAITING、EXECUTING、VERIFYING、MANUAL_REVIEW 均占用名额;只有 SUCCESS、FAILED、CANCELLED 释放。相同商户订单号及参数重试仍返回原单,不重复冻结。失败或取消后可重试,但仍须通过链上未激活校验。数据库唯一索引防止并发绕过检查。
已有数据库需先执行 `sql/rent_onchain_pending_migration.sql`;若有历史重复待处理订单,脚本拒绝升级,需人工核实交易和资金状态后处理,禁止直接删除或批量取消。
用户在“我的套餐”或“我的订单”中的“地址上链”卡片输入网络、接收地址及应用凭证,获取报价后确认。即使没有资源套餐,也能创建地址上链订单。供应商通过原有 rent_node 及已证明所有权的 rent_wallet 执行,不需要供应商创建 rent_app。
地址上链使用独立路径 `/api/rental/v1/address-onchain/quote`、`/create`、`/query`,订单类型由路径固定为 `ADDRESS_ONCHAIN`,请求可省略order_type;若提交只能为ADDRESS_ONCHAIN。原 `/api/rental/v1/quote`、`/create`、`/query` 仅处理 `RESOURCE_RENTAL`,拒绝混用订单类型。两者复用签名、应用归属、商户单号幂等、账务及回调机制。原地址上链接入方需同时更新请求URL和HMAC签名中的完整路径,不能用旧路径签名请求新接口;已有订单可通过新的query路径按原商户单号查询。
每笔固定转出 **1 TRX = 1000000 SUN**。USDT 本金折价 = `ceil6(1 × trx-price-usdt)`;固定服务费 = `ceil6(service-fee-usdt)`;总金额为两者之和。示例汇率0.15、固定服务费0.05,总冻结0.200000 USDT。所有运算使用 BigDecimal,不使用浮点数。NILE 和 MAINNET 汇率、服务费分别配置,未配置不允许下单,不自动取另一网络价格。
这里固定服务费使用 USDT 配置,不是实际链上燃烧的 TRX。本金全额补偿供应商,只有服务费参与百分比分成。实际网络交易/激活费用由供应商承担,不能在执行后追加扣用户资金。运营定价时应覆盖激活成本;`fee-limit-sun` 是链上操作本地预算,不计入用户报价第二次收费,也不是原生TRX交易的协议硬上限。
### 供应商与平台分账
`platform-fee-percent` 表示平台占服务费的百分比,20表示20%,允许0至100、最多4位小数,两种网络必须分别显式配置。未配置时拒绝新单,不影响原订单幂等恢复。用户支付总额不因分成比例改变。
```text
平台收入 = round6(服务费 × platform-fee-percent / 100),四舍五入
供应商服务收入 = 服务费 - 平台收入
供应商净应收 = 1TRX折价本金 + 供应商服务收入
用户支付总额 = 供应商净应收 + 平台收入
```
例如本金0.150000、服务费0.050000 USDT、平台比例20:用户扣0.200000,供应商净得0.190000(本金0.150000+服务收入0.040000),平台得0.010000。比例0表示服务费全归供应商,100表示服务费全归平台,本金始终归供应商。只对平台份额舍入一次,供应商取差额,保证金额守恒。
下单保存 `supplier_amount=用户总额`、`supplier_fee_percent=平台百分比`、`supplier_fee_amount=平台收入`、`supplier_net_amount=供应商净应收`,完整报价保存到package_snapshot。历史订单不重算,同一商户单号重试使用原快照;客户端不可覆盖分成参数。资源租赁订单继续按原有套餐规则计算。
链上独立确认成功才在同一事务写CHARGE、SUPPLIER_EARN和SUPPLIER_FEE流水:先登记供应商毛收入,再扣平台份额并写入 `rent_ledger.delta_platform_fee`;供应商待结算余额只增加净额。平台收入不是用户可用余额,平台统计沿用平台流水汇总。重复确认不重复入账,失败/未知不会确认收入。结算使用净应收,不二次扣费;退款/冲正仍走现有审核流程,平台退费累计上限为订单快照supplier_fee_amount,不随当前配置变化。
地址上链仅允许当前网络尚未激活的地址。创建新单前,云端调用所选网络最新节点的 `/wallet/getaccount`,已存在账户(即使余额为0)拒绝创建;RPC异常或响应异常时中止,不生成订单、不冻结USDT。报价只计算费用,不保证下单时仍未激活。原商户单号幂等重试仍返回原单,不会因原单执行后地址已激活而失败。合约地址由本地Agent拒绝;网络由请求明确指定,不通过地址推断。此检查不构成对外部链上交易的锁定,检查之后地址仍可能被第三方激活。
## 流程与失败处理
1. `/api/rental/v1/address-onchain/quote` 校验当前网络配置及地址,计算USDT报价,不冻结资金。
2. `/api/rental/v1/address-onchain/create` 锁定应用,按 `app_id + merchant_order_no` 幂等,保存价格快照、冻结用户USDT可用余额。重试命中原单不重读价格、不再次冻结;`expected_amount` 不匹配拒绝。网络、接收者、订单类型变化拒绝复用原商户单号。
3. 云端只选择当前在线、审核通过、钱包所有权已证明、明确声明 `transfer_enabled` 的供应节点。检查候选TRX余额,持有钱包TRX执行槽,签发 `TRANSFER_TRX` 原生任务。旧Agent未声明能力,不会收到转账任务。
4. Agent确认 `RENT_TRANSFER_ENABLED=true`、总广播授权、同网络、本地钱包owner、固定1000000 SUN、接收者、余额、权限、当前带宽费率、未激活地址创建费及留存。构建单个TransferContract,独立检查原始protobuf与授权一致后本地签名,先加密落盘再广播。
5. 云端在订单网络独立查交易与确认回执,核对交易类型、唯一合约、owner、to、1000000 SUN、授权时间及确认深度。节点自报SUCCESS/RESULT不能触发扣款。
6. 独立确认成功后:冻结USDT扣除、生成供应商待结算收入、订单SUCCESS、回调SUCCESS。`reclaim_status=NOT_REQUIRED`,不产生租期或回收任务;供应商结算沿用现有结算功能。
7. 明确未执行的拒绝或链上已证明失败:同一订单最多4次任务尝试且不超过派单截止;终结释放冻结。未派单超时取消。断线、超时、查不到交易及UNKNOWN都不能证明未执行:保留任务槽、冻结资金和原签名交易,不自动退款或改派。
Agent暂停后未签名任务会明确拒绝;已经签名的任务始终只查原txID或重播同一原交易。禁止删除任务日志、用新单号重复提交来处理未知结果。管理员可通过现有原交易补证操作核对原始转账,不能用人工改余额代替核验。
## 表设计与协同
| 表 | 本功能数据与职责 |
| --- | --- |
| rent_order | 新增order_type、transfer_sun、trx_price_usdt、principal_usdt、service_fee_usdt;package_id允许NULL,package_snapshot复用保存费用预算及完整报价;resource_type=TRX,资源数量/租期=0 |
| rent_node | 新增transfer_enabled,由认证SYNC_STATE同步能力及本地授权;默认0,旧Agent关闭 |
| rent_wallet | 复用节点关联、网络、所有权证明、状态;无需创建私钥字段,实时余额由RPC及Agent校验 |
| rent_task | task_type=TRANSFER_TRX,resource_type=TRX,delegate_sun复用保存固定转账本金1000000,换算额度/权重为0;钱包TRX执行槽隔离资源任务 |
| rent_transaction | 一任务一原交易,transaction_type=TRANSFER_TRX,amount_sun=1000000,保存独立确认区块、时间和证据;网络+txID唯一防重复认领 |
| rent_account / rent_ledger | USDT冻结、扣款、释放以及供应商收入均同事务入账,沿用不可变business_key去重 |
| rent_settlement / rent_settlement_item | 复用订单净应收来源及人工付款授权,包含本金折价和服务收入 |
| rent_app / rent_credential | 用户应用及APP签名凭证;供应商使用NODE凭证,与应用凭证隔离 |
| rent_webhook / rent_event | 复用回调重试、签名验签、操作与节点审计 |
本功能不新增独立订单/账户表,避免两套余额与幂等。历史资源订单默认RESOURCE_RENTAL,委托及回收行为保持现有规则。
## 升级与配置
已有库执行 `sql/rent_address_onchain_migration.sql`,全新库用更新后的 `sql/rent_init.sql`。增量脚本支持重复执行;它不会删表、改历史金额或真实广播。升级期间停止租赁worker及Agent,先迁移,再部署云端和两个Agent,最后开启功能。
在application-rental.yml中已添加 `rental.address-onchain`:
```yaml
rental:
address-onchain:
enabled: ${RENT_ADDRESS_ONCHAIN_ENABLED:false}
nile:
trx-price-usdt: ${RENT_ADDRESS_ONCHAIN_NILE_TRX_PRICE_USDT:}
service-fee-usdt: ${RENT_ADDRESS_ONCHAIN_NILE_FEE_USDT:}
platform-fee-percent: ${RENT_ADDRESS_ONCHAIN_NILE_PLATFORM_FEE_PERCENT:}
fee-limit-sun: ${RENT_ADDRESS_ONCHAIN_NILE_FEE_LIMIT_SUN:3000000}
mainnet:
trx-price-usdt: ${RENT_ADDRESS_ONCHAIN_MAINNET_TRX_PRICE_USDT:}
service-fee-usdt: ${RENT_ADDRESS_ONCHAIN_MAINNET_FEE_USDT:}
platform-fee-percent: ${RENT_ADDRESS_ONCHAIN_MAINNET_PLATFORM_FEE_PERCENT:}
fee-limit-sun: ${RENT_ADDRESS_ONCHAIN_MAINNET_FEE_LIMIT_SUN:3000000}
```
仅在计划使用的网络配置正汇率、非负服务费。供应商Agent新增 `RENT_TRANSFER_ENABLED=false`,明确同意转账后改为true并重新连接。`RENT_MAX_SUN`至少1000000;`RENT_MAX_FEE_SUN`不小于订单fee-limit-sun;余额覆盖转出本金、保守链上费用与`RENT_TRX_RETAIN_SUN`。这两个限额单位均为SUN。JavaFX每次启动仍默认关闭总广播,必须手动开启。
使用原有应用凭证调用新的地址上链独立API,无需额外菜单权限。网页公开API文档访问 `/rental-api`,所有独立接口及示例统一列在接口列表中。
## API 示例
`POST /api/rental/v1/address-onchain/quote`,请求头及HMAC签名与资源租赁一致:
```json
{"network":"NILE","receiver_address":"TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"}
```
`POST /api/rental/v1/address-onchain/create`:
```json
{"network":"NILE","receiver_address":"TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf","merchant_order_no":"ADDR-DEMO-001","expected_amount":"0.200000"}
```
查询:`POST /api/rental/v1/address-onchain/query`,请求 `{"merchant_order_no":"ADDR-DEMO-001"}`。
不得传入package_id、resource_type、resource_quantity、duration_seconds、transfer_sun。金额示例不是实际配置价格。query按merchant_order_no查询;响应及回调增加order_type、transfer_sun、principal_usdt、service_fee_usdt、transaction_id,金额单位USDT。transaction_id仅在云端独立确认转账后提供,确认前为空。回调接收方照旧验签、按event_no去重、仅在业务落库成功后返回正文ok。
## 日志排查
使用orderId、taskId、nodeId、network、txID串联云端及本地日志。云端打印冻结金额拆分、无合格候选、候选余额不足(INFO,包含本金及费用上限SUN)、同地址跳过、状态变化/执行槽占用、派单、节点事件、独立证明、扣款及明确失败。Node打印PREFLIGHT、预算、BUILT_PERSISTED、BROADCASTED/UNKNOWN;Java打印任务阶段、原交易恢复及RPC路径耗时。密钥、签名交易、API Secret、原始凭证帧和带认证信息的响应禁止打印。
### 节点在线但未收到地址上链订单
快照更新时间长期不变时,先检查启动日志“租赁快照定时扫描已启用”。扫描每轮结束后延迟15秒再次运行,每批最多20个ACTIVE且快照缺失/过期的钱包;游标走到末尾后下一轮从头开始,因此不是每个钱包严格每15秒更新。刷新成功输出INFO(walletId、网络、旧快照时间、耗时),失败输出WARN及安全异常因果链;批次汇总输出成功/失败数量。无候选和区块夹读明细为DEBUG。失败不会推进snapshot_at或有效期。
链上采集失败日志stage含义:BEFORE_BLOCK/AFTER_BLOCK为区块RPC,ACCOUNT_RESOURCE为资源RPC,ENERGY_DELEGATABLE/BANDWIDTH_DELEGATABLE为对应可委托本金RPC,BLOCK_CONSISTENCY为前后区块一致性检查,GLOBAL_PARAMETERS为全网参数检查。BLOCK_CHANGED_OR_INVALID显示前后高度;STALE_OR_CONCURRENT显示钱包版本、新旧高度及快照屏障。RPC另记录路径和非成功HTTP状态码,不记录认证头或响应原文。请按walletId、网络、地址和相邻时间关联日志。
区块夹读不一致时,在本轮立即整套重采集,最多3次(含首次);每次重新查询前后区块、资源和两类可委托本金,绝不复用失败尝试的数据。日志包含attempt/maxAttempts、每次耗时,重试成功或耗尽时输出总耗时。3次均失败则不更新旧快照及时间,等待后续扫描。RPC错误、本金响应无效、全网参数缺失不作为跨区块错误盲目重试;数据库版本及快照屏障校验保持不变。持续跨区块应检查RPC延迟及节点一致性,重试不能保证慢RPC一定取得快照。
地址上链不依赖能量/带宽出租开关、可委托质押本金、历史资源证明或资源快照有效期。供应钱包必须在订单对应网络、状态为ACTIVE且已完成控制权验证;节点必须ACTIVE、ONLINE、心跳未过期,并由Agent在连接恢复同步时上报转账授权。仅打开能量/带宽出租并不会授予转账权限。
Agent配置 `RENT_TRANSFER_ENABLED=true` 后需重启或重连;数据库中的 `rent_node.transfer_enabled` 应由Agent同步上报,不应手工改成1绕过本地授权。Java Agent还需要打开总广播授权。云端实时查询余额至少覆盖固定1TRX与订单快照中的fee-limit-sun,Agent执行前还会检查实际创建费、带宽费用及本地留存。
修复后的转账任务 `conversion_block_height=0` 表示不适用质押换算,不代表链上确认高度。委托/回收任务仍使用可信资源高度。无需为此修改数据库结构或生成虚假资源快照。
可使用以下只读SQL核对部署状态:
```sql
SELECT o.id, o.order_no, o.network, o.status, o.dispatch_deadline,
t.task_no, t.task_type, t.status AS task_status
FROM rent_order o LEFT JOIN rent_task t ON t.order_id=o.id
WHERE o.order_type='ADDRESS_ONCHAIN' ORDER BY o.id DESC LIMIT 20;
SELECT w.id AS wallet_id, w.network, w.status AS wallet_status,
w.ownership_verified_at, n.id AS node_id, n.status AS node_status,
n.connection_status, n.heartbeat_expires_at, n.transfer_enabled
FROM rent_wallet w JOIN rent_node n ON n.id=w.node_id
ORDER BY w.id;
```
WAITING且没有任务表示尚未派单;已有PENDING任务则继续检查Socket推送和Agent接收日志。EXECUTING/UNKNOWN已有在途任务时,不允许手动重置订单或另建交易。更新服务端后,仍在派单期限内的WAITING订单由扫描自动重试;已超时取消的订单不会自动恢复。
## 回调未到达排查(2026-11-02)
持续405的实际HTTP探测证据、关联日志和Nginx精确代理配置见[回调405定位](rental-webhook-405.md)。
### 调试接收端验签
`WebhookDebugController`的`POST /api/webhook/debug`仅接收application/json。使用原始UTF-8正文和X-Rent-Key/Timestamp/Nonce/Signature请求头,复用租赁WEBHOOK域HMAC-SHA256协议,允许时间偏差小于60秒;正文上限512KiB。GET返回405,CONFIGURED模式缺凭证或存储故障503,认证失败401,事件JSON无效400,nonce重放409;仅验签及持久化nonce成功返回纯文本ok。不更新业务订单,不用于正式记账,合法事件重投携带新nonce时可再次观察。
```yaml
rental:
webhook-debug:
credential-source: ${RENT_WEBHOOK_DEBUG_CREDENTIAL_SOURCE:APP}
api-key: ${RENT_WEBHOOK_DEBUG_API_KEY:}
api-secret: ${RENT_WEBHOOK_DEBUG_API_SECRET:}
signature-path: ${RENT_WEBHOOK_DEBUG_SIGNATURE_PATH:}
```
默认APP模式按请求X-Rent-Key查询本系统ACTIVE且未过期的APP凭证并解密Secret验签,不需要填写固定api-key/api-secret;未知、NODE、停用或过期凭证拒绝。适用于同系统调试,能够验证各应用轮换后的真实签名,不能作为外部商户生产回调的身份授权模型。CONFIGURED模式使用上面的固定凭证,必须与发送器当前选择的APP有效凭证一致;轮换后同步更新接收端。路径必须与外部notify_url路径逐字一致:例如回调地址为`http://192.168.3.103/api/api/webhook/debug`,Nginx移除一层/api后,设置`RENT_WEBHOOK_DEBUG_SIGNATURE_PATH=/api/api/webhook/debug`。留空使用后端实际请求URI,不能从不可信转发头推断路径。不将Secret、签名、完整正文或异常原文写日志;成功记录事件号、订单号、事件类型及状态摘要。修改配置后重启服务。此接口映射不能修复Nginx静态服务产生的405,仍需确保POST转发到后端2020端口。
认证诊断不再合并为“通知认证参数无效”:分别记录KEY_MISSING、KEY_MISMATCH、ACTIVE_APP_CREDENTIAL_NOT_FOUND、NONCE_INVALID、TIMESTAMP_NOT_UNIX_MILLIS、TIMESTAMP_OUT_OF_WINDOW及SIGNATURE_MISMATCH_CHECK_SECRET_PATH_AND_BODY。日志提供Key不可逆摘要、时间差毫秒数、nonce长度,不记录认证原文。HTTP时间戳是Unix毫秒,与DATETIME存储时区无关,不允许手工加8小时或取消时间窗验证。独立demo接收端仍使用其固定配置,并返回具体参数校验说明。
在服务端日志中按 `webhookId` 或 `orderId` 查询“租赁回调”。日志依次包含领取次数/正文字节数、目标主机/路径、有效凭证记录ID、POST请求开始、HTTP响应状态/长度和最终状态;异常包含失败阶段及安全的异常类型/代码位置,不输出Secret、签名、请求正文或响应正文。`rent_webhook.last_error`同步保存固定阶段和原因码。
- `TARGET_NOT_PUBLIC`:目标被地址策略拒绝。开启内网配置后允许192.168/10/172.16~31及IPv6 ULA;回环、链路本地、未指定及组播仍拒绝。关闭内网配置时192.168.x.x等也会被拒绝。
- `TLS_CERTIFICATE_OR_HANDSHAKE_FAILED`:HTTPS握手或证书验证失败。
- `DNS_RESOLUTION_FAILED`、`CONNECTION_FAILED`、`TIMEOUT_OR_INTERRUPTED`:分别核对DNS、端口和网络超时。
- `NO_VALID_CREDENTIAL_OR_LOOKUP_FAILED`:检查订单所属应用是否有ACTIVE且未过期凭证及数据库状态。
- `HTTP_STATUS_301/302/404/401/...`:请求已收到HTTP响应,检查代理路由/登录拦截;不会自动跟随重定向。`/api/api/webhook/debug`是否正确取决于Nginx前缀转发,不自动删减路径。
- `ACK_BODY_NOT_EXACT_OK`:要求HTTP200且响应正文严格为小写`ok`,JSON包装、HTML或多余换行均不确认。
扫描每5秒执行,仅领取已到`next_attempt_at`且租约可用的PENDING/SENDING记录。失败退避重试,累计10次进入DEAD;管理员通过已有回调重投功能重新投递DEAD事件,不直接修改订单或删除回调记录。没有回调URL时沿用既有跳过发送并确认的行为,日志标记`EMPTY_NOTIFY_URL`。
内网回调配置为`rental.webhook.allow-private-network: ${RENT_WEBHOOK_ALLOW_PRIVATE_NETWORK:true}`,按当前需求默认开启,修改后重启服务生效;设为false恢复仅公网策略。支持`http://192.168.3.103/api/api/webhook/debug`,也支持`http://192.168.3.103:2020/api/webhook/debug`等内网HTTP自定义端口;路径由Nginx或后端实际路由决定。HTTP按发送时DNS解析结果逐个校验,仅可连接私网,禁止代理及重定向;公网HTTP仍拒绝。HTTPS仍限定443且校验证书链及IP SAN。
诊断定向测试3项通过,覆盖内网开关、私网及IPv6 ULA放行、特殊地址继续拒绝和网络/凭证错误分类;未连接实际回调目标或操作生产数据。
## 验证记录(2026-10-29)
地址上链派单修复回归:JDK8离线执行 `RentalBusinessTest,RentalOnchainTest`,67项通过、0失败、0错误。新增覆盖无资源快照派单并完成独立核验扣款、过期快照不阻止转账但阻止资源委托,以及无快照下身份/网络/在线心跳/授权/余额保护。本次未进行真实链上广播或生产部署。
追加服务费分账后,JDK8云端租赁测试95项通过,包含H2真实事务、唯一键、无套餐下单、重复冻结防护、分成边界及舍入守恒、历史快照不重算、平台单次入账、净额结算、UNKNOWN隔离和独立链上参数证明。公开API文档ESLint通过。此前Node Agent14项、Java17 Agent41项测试通过,Java Agent完成package构建,Vue模板编译及staging生产构建通过(现有3项无关API导出警告及2项包大小警告);此次分账未修改Agent。
本次未运行生产MySQL增量脚本、未部署、未连接真实钱包、未执行真实支付或链上广播;实际两网联调应在配置完成后进行。
+49
View File
@@ -0,0 +1,49 @@
# 管理员租赁接口调试台
## 安装与入口
先执行已有租赁菜单脚本,再执行 `sql/rent_api_debugger_menu.sql`。新菜单为“资源租赁 / 租赁API调试”,组件 `rental/apiDebugger`,权限 `rent:api:debug`,默认只授予admin角色;其他管理员需显式分配菜单。当前目录路径为rental时访问 `/rental/api-debugger`,已安装目录使用proxyRent时为 `/proxyRent/api-debugger`。刷新登录权限后显示菜单,不需要后端新增配置或存储凭证。
## 使用流程
1. 输入API基地址、租赁应用的API Key与API Secret。基地址默认取当前后台代理前缀,例如 `/prod-api`,最终调用 `/prod-api/api/rental/v1/packages`;直连API域名时填写 `https://租赁域名`,也支持包含实际代理前缀。
2. 在接口下拉框中选择7个商户接入接口之一,按“资源租赁 / 地址上链”分组。页面自动显示对应参数表单、必填标记、单位和填写说明;不适用的参数不显示。每个接口分别保留当前页面内的草稿。
3. 查询套餐后点击“使用此套餐报价”,填写真实资源接收地址,发送报价。
4. 报价成功后点击“使用此报价准备下单”,自动沿用参数、报价原始金额字符串并生成商户单号。确认接收地址、网络、费用和回调地址,再发送下单请求。
5. 下单成功后点击“查询此商户订单”跟踪状态。创建成功不代表履约成功;超时/停止等待不会取消服务端业务,请用原商户单号查询,不要贸然生成新单号重试。
## 调试信息
### 格式化请求的签名兼容
全局 `RepeatedlyRequestWrapper` 必须按原始字节缓存请求体。原实现通过 `HttpHelper.getBodyString` 逐行拼接,删除JSON中的LF/CRLF,造成页面签名与服务端验签请求体不同,表现为凭证正确但“租赁签名无效”。已改为原始字节缓存,并显式使用UTF-8读取字符,保留空格、换行和中文。此修复需要更新后端;不能通过要求用户删除换行或放宽验签来绕过。
默认使用表单填写网络、套餐ID、接收地址、商户单号、时长、资源数量、预计金额和回调地址。查询仅需原商户订单号,套餐查询仅需网络。选填参数清空时从请求中移除,不发送空字符串;金额和资源整数按精确字符串提交。需要扩展参数或排查原始字节时,切换“高级JSON / 请求预览”,两种模式共享同一份请求数据。无效JSON需先修正才能继续表单编辑。
页面展示HTTP状态、业务原始响应、耗时、可见响应头、完整请求URL、JSON原文、请求体SHA256和脱敏签名原文。API Key与签名脱敏,Secret不展示、不写日志、不持久化。签名与发送共用同一原始UTF-8请求体,时间戳和nonce每次更新;反向代理前缀不参与签名。
页面使用独立浏览器请求,不携带后台Token或Cookie,不使用后端代发代理。签名依赖Web Crypto,需要HTTPS或localhost。跨域API必须允许当前后台来源、POST、Content-Type和X-Rent-*认证头;响应头受浏览器CORS可见范围限制。证书不可信、网络错误、跨域或重定向均需按实际部署修复,页面不会关闭证书校验。
初版仅调试当前服务已提供的7个用户接入接口,不提供不存在的余额、取消或退款API。回调地址通过下单JSON的notify_url填写;Webhook接收和验签示例参见 `/rental-api` 文档页面。
## 服务端验签日志排查
`RentalIdentity`在INFO级别打印“租赁认证开始 / 凭证已定位 / 认证成功”,失败在WARN打印“租赁认证失败”。同一次认证使用相同`diagnosticId`,同时沿用项目日志traceId。不会输出Secret、请求正文、完整Key或完整签名。
| stage | 排查方向 |
| --- | --- |
| AUTH_FIELDS | 检查keyValid、nonceValid、timestamp、serverTime、clockSkewMs;客户端时间必须在±60秒内 |
| CREDENTIAL_LOAD | Key不存在、凭证已吊销或过期,或数据库异常;使用Key的SHA256前16位keyFingerprint关联同一凭证 |
| OWNER_TYPE | 例如在商户API中使用NODE节点凭证;此处需要APP凭证 |
| SIGNATURE_FORMAT | 签名缺失、长度不为64或不是十六进制;观察signatureLength/Whitespace等字段 |
| SECRET_DECRYPT | 检查部署主密钥及版本,不能通过重填客户端Secret修复服务端解密问题 |
| SIGNATURE_COMPARE | 将method、path、bodySha256与调试台逐项对照;路径不含代理剥离前缀,JSON签名后不能修改;协议输出小写签名。若路径和摘要一致,再检查原始Secret是否匹配、是否复制了空格 |
| NONCE_SAVE | 检查是否重复提交同一nonce或数据库结构问题,每次请求必须产生新nonce |
bodyBytes为UTF-8字节数,bodyLfCount/bodyCrCount为服务端实际收到的换行数。比如页面请求有格式化换行而日志显示0,应继续排查部署版本、全局过滤器和代理是否改写正文。storedMasterVersion/configuredMasterVersion仅显示版本号,不输出密钥内容。
## 本地验证
已校验Vue模板与脚本解析;使用Node Web Crypto及独立HMAC计算交叉核对签名、JSON原文字节、代理前缀、地址上链子路径和随机nonce。未用真实凭证创建订单或冻结资金。
前端staging打包通过,保留项目已有3个API导出缺失告警及资源体积告警。本次无后端业务或数据库结构变更;菜单SQL尚未执行。
+43
View File
@@ -0,0 +1,43 @@
# 供应商收益结算与提现付款
## 资金流程
履约成功且收入已确认 → 供应商或管理员勾选订单申请收益结算 → 独立管理员审核 → 待结算收益转入可用余额 → 供应商申请提现 → 冻结金额 → 管理员或Telegram审核 → 执行付款 → 人工登记并核验或自动扫描匹配 → 扣除冻结金额。
## 页面与权限
管理员:原“供应商结算”页面,先选网络及供应商账户,再勾选订单创建收益结算单;保留新单审核及旧单付款核对操作。
供应商:`system/rentSettlement/user/index`,菜单“我的收益结算”,默认路径为父目录下的 `supplier-settlement`。执行 `sql/rent_supplier_settlement_menu.sql` 后重新登录刷新权限。该脚本兼容rental/proxyRent目录,只授予PROXY_SUPPLIER本人查看和申请权限,不授予管理或审批权限。
两个页面共享订单选择器,过滤SUCCESS、CHARGED、净收益大于0且无有效结算占用的订单。申请中和已入账来源均不出现;拒绝释放后重新出现。金额以六位最小单位字符串精确求和,最终金额仍由服务端加锁计算。切换网络、账户、搜索或分页会清空勾选,避免提交不可见选择。支持订单号/接收地址搜索、分页、来源详情、错误重试与空状态引导。
- `GET /rental/settlements`:本人结算分页,参数network/status/page;权限 `rent:settlement:view`。
- `GET /rental/settlements/candidates`:本人可申请订单,参数network/keyword/page;权限 `rent:settlement:apply`。
- `POST /rental/settlements`:本人勾选申请,正文order_ids;权限 `rent:settlement:apply`。不接受user_id指定归属。
- `GET /rental/settlements/{id}`:本人结算详情及来源,权限 `rent:settlement:view`。
- 管理员分页/详情分别为 `/rental/manage/settlements` 和 `/rental/manage/settlements/{id}`,权限 `rent:manage:list`。
- 管理员候选账户 `/rental/manage/settlements/accounts` 参数network/keyword;候选订单 `/rental/manage/settlements/candidates` 参数network/account/keyword/page,权限 `rent:settlement:create`。创建沿用 `/rental/settlement`。
结算仅做内部划转,提现才对应链上出款。沿用现有提现配置、权限和到账机制,供应商需具备 `rent:withdraw:create` 权限。
## 表与接口
- `rent_settlement.settlement_mode`:新单固定 `INTERNAL_TRANSFER`,历史单为 `LEGACY_PAYOUT`,不接受前端指定模式。
- `rent_settlement_item`:同一供应商账户、同网络订单净收益快照;每单只允许一次有效结算,拒绝后释放来源。
- `POST /rental/settlement`:提交1至100个不重复的 `order_ids`,均须 `SUCCESS` 且 `CHARGED`。
- `POST /rental/settlement/{id}/approve`:提交 `reason`,审批者不能是创建者;同事务验证明细和账户ACTIVE状态,以唯一流水 `INCOME_SETTLE:{id}` 增加可用、等额减少待结算。结果为 `SETTLED` 并记录 `settled_at`。重复审批不重复划转。
- `POST /rental/settlement/{id}/reject`:其他管理员拒绝待审单,不修改资金,释放明细占位。
- 新单禁止 `pay/unknown/confirm`,完成结算后不允许拒绝撤销。提现使用原 `/rental/withdraw/create` 等接口。
SETTLED后仍保留来源占位。沿用退款保护:被结算占用的来源不得直接冲正供应商收入或向其返还手续费;待审单可先拒绝后处理退款。已结算收益的后续冲正需独立资金追偿业务,不能从其他订单待结算收益中冒扣,此版本不开放该操作。
## 升级与旧单
停服备份后执行 `sql/rent_income_settlement_migration.sql`,再部署新后端和前端。脚本可重复执行,仅增加模式与入账时间字段,不更改余额和历史状态。不要在旧、新版本混跑时创建结算单。
所有历史单保持 `LEGACY_PAYOUT`,继续原审批、付款授权和交易核验,完成只扣待结算,不增加可用,防止重复提现。历史PENDING/APPROVED且明确未付款的单可先按原规则拒绝,再创建新收益结算单;PAYING/UNKNOWN不能自动拒绝或转换。不得直接改模式或删除明细绕过来源占位。
## 排查
按 `settlementId` 查创建、审批幂等、入账或拒绝日志。核对明细合计、来源订单净应收、账户状态及 `rent_ledger` 的 `INCOME_SETTLE` 记录。划转前后可用与待结算之和不变,冻结与平台手续费不变;提现另外记账。
+55
View File
@@ -0,0 +1,55 @@
# 租赁回调405定位与HTTP入口配置
## 已复现证据
2026-11-02从开发环境发送POST到`http://192.168.3.103/api/api/webhook/debug`,实际返回HTTP405、Server nginx/1.24.0 (Ubuntu)、Content-Type text/html以及Nginx默认405页面。直连`192.168.3.103:2020`超时。证据指向HTTP入口代理/静态路由,尚未取得运行服务器的Nginx配置,不能仅凭Server头断定具体location;代理也可能替换上游错误页。开发环境无法直连2020不等于服务器本地也无法连接。
## 新日志如何定位
发送端“租赁回调请求开始”包含随机`callbackId`、实际POST、协议、主机、端口和签名路径;“响应来源”记录Server、Allow、X-Rent-Debug-Backend、响应关联ID与上游traceId,不记录凭据、正文或Cookie。
接收端`WebhookDebugTraceFilter`在MVC路由匹配前记录“租赁调试回调入口”,出口记录HTTP状态和匹配Controller。即使认证尚未配置或MVC返回405也能记录。响应头`X-Rent-Debug-Backend: ruoyi-webhook-debug-v1`表示经过当前版本调试回调过滤器,不能替代验签,也不证明已进入Controller。缺标记时还需考虑代理剥离响应头或错误页替换,用接收端callbackId日志进一步判断。
- 无入口日志:检查Nginx实际HTTP server/location、是否落入前端静态页、是否指向旧实例。
- 入口方法不是POST:检查proxy_method、rewrite/error_page内部跳转及其他代理。
- 入口POST且405:查看出口handler、后端运行版本、路由与过滤器。
- 返回401或503:已经进入验签接收端,应继续配置凭证/签名路径,不再是HTTP方法问题。
## 服务器本地验证及修正
先在运行后端的服务器执行,使用无签名测试正文不会更新订单:
```bash
curl -i --connect-timeout 3 --max-time 10 \
-X POST http://127.0.0.1:2020/api/webhook/debug \
-H 'Content-Type: application/json' -d '{}'
sudo nginx -T
```
新版后端默认APP模式,无认证请求头应返回401;CONFIGURED模式缺凭证时返回503,有凭证但无签名返回401,并带后端标记;不应返回405。不要为测试返回ok而关闭验签。
如果Nginx和后端同机、后端端口为2020,在实际监听80、匹配192.168.3.103的server块添加以下精确location(不是放在只监听443的server块):
```nginx
location = /api/api/webhook/debug {
proxy_pass http://127.0.0.1:2020/api/webhook/debug;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Rent-Callback-Id $http_x_rent_callback_id;
proxy_intercept_errors off;
proxy_connect_timeout 5s;
proxy_read_timeout 10s;
}
```
不同机器部署须替换为Nginx能访问的真实后端地址。保持POST方法和正文默认透传,不使用proxy_method GET或关闭proxy_pass_request_body;不要用error_page 405返回200掩盖故障。若server级存在统一return/rewrite,应确保回调请求不会在location处理前被改写到其他地址。
```bash
sudo nginx -t && sudo systemctl reload nginx
curl -i --connect-timeout 3 --max-time 10 \
-X POST http://192.168.3.103/api/api/webhook/debug \
-H 'Content-Type: application/json' -d '{}'
```
外部notify_url不变,验签配置仍使用`RENT_WEBHOOK_DEBUG_SIGNATURE_PATH=/api/api/webhook/debug`,而后端实际接收路径为`/api/webhook/debug`。确认无签名测试返回401/503后再通过正式回调验签验证ok;DEAD事件使用管理员已有重投入口,不能重新扣款或重置业务订单。
+87
View File
@@ -0,0 +1,87 @@
# 租赁资金账户提现
## 业务边界
提现只使用当前用户对应网络 `rent_account.available_amount`,不提取冻结余额或供应商待结算金额。NILE与MAINNET分别记账,但数据库用 `active_user_id` 唯一槽保证同一用户全网络只能有一笔未完成提现。提交即在同一事务写 `WITHDRAW_HOLD` 流水:可用余额减少、冻结余额增加。拒绝写 `WITHDRAW_RELEASE`;链上到账写 `WITHDRAW_COMPLETE`,只减少冻结,不再次减少可用。
状态为 `PENDING_REVIEW → EXECUTING → VERIFYING/MANUAL_REVIEW → COMPLETED`,拒绝为 `REJECTED`。进入执行后不能直接退款,因为管理员可能已经付款;RPC失败、未确认或证据冲突均保持冻结。
后台和Telegram审核调用相同服务。Telegram数字ID除原白名单外,还必须在 `telegram-reviewers` 映射到具有 `rent:withdraw:review` 权限且有效的系统用户,不能用昵称授权或虚构系统操作者。审核通过保存当时的付款地址JSON快照,后续修改配置不改变已审核订单。
## 手动与自动到账
管理员手动:完成外部钱包付款后填写交易Hash、可选日志索引和执行备注。系统独立查询TRON交易及收据,核验成功才能到账,不能强制改变余额。
自动监听:按网络持久化扫描已固化区块,RPC确认深度由 `rental.confirmations` 再次限制。逐块读取完整交易收据,发现审核快照付款地址发出的真实USDT `Transfer`,保存 `rent_withdraw_transaction` 后匹配提现。匹配同时要求网络、USDT合约、付款地址、收款地址、6位金额完全相同,并且链上区块时间严格晚于 `approved_at`。不拼接多笔、不接受多付少付;多单歧义转人工核对。
两种入口最终调用同一个 `complete` 事务。提现单行锁、链上事件唯一键、`withdraw_id`唯一认领及账本business_key共同防止并发重复扣款。到账记录 `arrival_mode=MANUAL/AUTO`、Hash、日志索引、区块与时间。自动扫描游标仅在整块事件保存完成后推进,多实例使用短租约;故障重启会重扫,幂等约束防重复。
## 部署
1. 执行 `sql/rent_withdraw_migration.sql`,再执行 `sql/rent_withdraw_menu.sql`;不删除或重算历史余额。
2. 配置每个启用网络的付款地址、额度、Telegram映射;先保持 `enabled=false` 和 `scan-enabled=false`。
3. 部署前后端,赋予运营角色 `rent:withdraw:list/review/execute`;申请角色由脚本获得 `rent:withdraw:create`。
4. 打开提现但暂不开扫描,使用小额单验证后台审核及人工Hash核验。
5. 验证RPC支持 `/wallet/gettransactioninfobyblocknum` 后开启扫描,观察后台页面游标和服务日志,再扩大额度。
```yaml
rental:
withdraw:
enabled: ${RENT_WITHDRAW_ENABLED:false}
min-amount-usdt: ${RENT_WITHDRAW_MIN_USDT:1}
max-amount-usdt: ${RENT_WITHDRAW_MAX_USDT:10000}
scan-enabled: ${RENT_WITHDRAW_SCAN_ENABLED:false}
poll-interval-ms: ${RENT_WITHDRAW_POLL_MS:10000}
scan-batch-blocks: ${RENT_WITHDRAW_SCAN_BATCH_BLOCKS:5}
telegram-reviewers: ${RENT_WITHDRAW_TELEGRAM_REVIEWERS:}
nile:
payout-addresses: ${RENT_WITHDRAW_NILE_PAYOUT_ADDRESSES:}
mainnet:
payout-addresses: ${RENT_WITHDRAW_MAINNET_PAYOUT_ADDRESSES:}
```
服务不保存付款私钥、不自动广播。配置多个地址用英文逗号分隔;地址与Telegram映射属于敏感运营配置,不提交代码仓库。日志打印提现ID、网络、金额、Hash、日志索引、模式和脱敏异常定位,不打印凭证、私钥、签名原文或完整RPC响应。
## 页面及接口
本人资金账户页提供申请、记录和时间线:`POST /rental/withdraw/create`、`GET /rental/withdraw/list`、`GET /rental/withdraw/{id}`。管理员菜单页面使用 `/rental/manage/withdraw` 下的列表、详情、审核及transaction接口;只读交易明细接口便于定位未匹配事件。用户ID始终来自登录上下文。
申请示例(使用已登录后台身份,不使用租赁应用API凭证):
```json
{"network":"NILE","receiver_address":"你的TRON地址","amount":"30.000000","client_request_no":"客户端唯一请求号","remark":"提现说明"}
```
`client_request_no`重试必须保持不变。相同用户与请求号、相同内容返回原申请;变更金额或地址需要新请求号,并且原在途申请必须先结束。金额以十进制字符串传递,最多6位小数;初版不收提现手续费,申请金额等于链上应付USDT金额。
管理员审核:`POST /rental/manage/withdraw/{id}/review`,请求 `{"approve":true,"reason":"审核意见"}`。手动到账:`POST /rental/manage/withdraw/{id}/transaction`,请求 `{"transaction_id":"64位Hash","log_index":0,"remark":"付款执行说明"}`;日志索引可省略,但同一交易存在多个符合条件的事件时必须明确指定。核验未通过时返回保留冻结的当前状态及`last_error`,前端不得仅根据HTTP成功提示到账。
交易排查:`GET /rental/manage/withdraw/transactions?network=NILE&page=1&hash=可选完整Hash`。本人列表固定每页20条,管理员列表支持network/status/page;本人详情禁止跨用户访问。相同区块发现多笔符合单张提现申请的付款时转人工核对,不自动选择第一笔。
## 数据表职责
| 表 | 关键字段与职责 |
| --- | --- |
| rent_withdraw_order | user_id/account_id/network确定资金归属;amount/frozen_amount记录申请与冻结金额;active_user_id唯一约束防全网络重复申请;client_request_no/request_hash保证重试幂等;approved_at与payout_sender_snapshot固定匹配边界;arrival_mode/arrival_transaction_id/completed_at记录到账结果 |
| rent_withdraw_transaction | network+transaction_id+log_index唯一标识真实链上事件;保存合约、付款方、收款方、6位USDT金额、最小单位、区块Hash/时间和证据;withdraw_id唯一约束防止一笔付款核销两次 |
| rent_withdraw_scan_cursor | 每网络一个持久扫描位置,last_block只在整块处理成功后推进;lock_owner/lock_until支持多实例租约;last_error记录可排查故障 |
| rent_ledger | 新增nullable withdraw_id关联提现;WITHDRAW_HOLD/RELEASE/COMPLETE与余额更新同事务,不更改既有充值和租赁流水 |
| rent_event | 保存申请、审核、手动核验、MANUAL/AUTO到账操作轨迹和操作者 |
| telegram_audit_record及推送队列 | 沿用项目现有Telegram审核模型,业务类型RENT_WITHDRAW;创建申请时与冻结一并持久化,机器人推送失败不丢审核单 |
## 排查及运行边界
管理员详情突出展示本单网络的允许付款钱包,并在通过审核前再次确认网络、付款地址、收款地址与金额。待审核使用当前配置,通过后展示审核时的地址快照;地址未配置或详情未加载完成时禁止点击通过。提示同时适用于后续手动Hash核验与自动到账。
按withdrawId/withdrawNo、network、Hash检索日志;扫描日志包含cursor、confirmedHead及backlog。余额不足、重复申请、本人审核、权限映射无效均拒绝;网络异常、未确认、付款方/金额不匹配均不解冻。管理员不能审核自己的提现。
首次扫描从最早有效审核时间前定位区块,之后按持久断点追赶。默认每10秒最多扫描5块,积压时可调大batch(上限100),并观察RPC限流。RPC必须支持整块回执接口,不支持或回执缺失时停止推进并保留冻结;不会降级成忽略交易。服务使用已有TRON网络配置和对应USDT合约,不能把测试网交易用于主网到账。
增量脚本需先于新服务执行,因为公共账本插入已包含withdraw_id。脚本仅新增结构和菜单,不会付款、不重算余额、不删除历史数据。真实MySQL、Telegram机器人及NILE钱包仍需部署后小额联调。
## 本地验证记录
- JDK8执行`Rental*Test`:108项通过,0失败、0错误,其中提现专项12项。
- 覆盖冻结/拒绝释放、跨网络并发申请、幂等重试、手动与自动并发核销、未知链上结果保留冻结、重复付款歧义、Telegram真实审核路由和重复回调、RPC失败后恢复,以及真实USDT日志解码和确认边界。
- 前端staging构建完成;存在项目原有的3个API导出缺失告警以及资源体积告警。提现相关Vue模板与脚本解析通过。
- 新建表在初始化、独立建表和增量脚本中的定义一致。数据库测试使用H2 MySQL兼容模式,未执行生产MySQL脚本,未发送Telegram消息或广播交易。
+51
View File
@@ -0,0 +1,51 @@
# 租赁账户的应用工作台
入口:PROXY_ACCOUNT → 租赁应用(system/rentApp/user/index)。
1. 无应用时显示创建引导;有应用时显示卡片列表及分页。
2. 创建时填写名称及可选 HTTPS 默认回调地址,创建成功自动进入详情。
3. 详情展示应用 ID、状态、默认回调、创建时间和凭证版本。
4. 点击创建/轮换凭证,确认影响后,服务端为当前 APP 签发凭证;无需手工填写主体编号。
5. API Secret 仅在成功响应的弹窗中展示一次,默认隐藏;确认安全保存后关闭,立即清除内存引用,不写缓存或日志。
签发会使旧 ACTIVE 凭证变为 VERIFY_ONLY,新请求须切换到新凭证。签发失败不自动重试,避免多次轮换。
## 接口与权限
| 接口 | 权限 | 说明 |
| --- | --- | --- |
| GET /rental/mine/app | rent:portal:view | 本人应用分页 |
| POST /rental/register/app | rent:app:create 或旧 rent:portal:register | 归属取当前登录用户 |
| GET /rental/app/{id} | rent:portal:view | 按当前用户校验应用归属,凭证显式选列,不返回 Secret |
| POST /rental/credential/issue | rent:credential:issue | owner_type 固定 APP,owner_id 为当前应用;后端再次校验归属 |
现有 sql/rent_role_permissions.sql 授予 PROXY_ACCOUNT 创建、查看、签发及删除权限,无新增表结构。已部署环境执行 sql/rent_app_remove_permission.sql 增量授权删除权限,执行后重新登录。
## 删除与时间显示(2026-10-25)
- 应用详情时间统一返回 UTC 毫秒时间戳,页面按浏览器本地时区显示。前端兼容 ISO 与旧 UTC 日期文本;无效值显示 `—`,不会再显示全零时间。
- 详情底部提供删除按钮和二次确认。DELETE /rental/app/{id} 需要 rent:app:remove(兼容旧 rent:portal:register)。
- 删除只允许本人应用;任何状态订单及任何状态 APP 凭证(包括已过期、已吊销及 VERIFY_ONLY)均阻止删除,不自动清理关联。
- 订单下的任务、退款、流水、回调等通过禁止删除有订单应用而受到保护。审计日志独立保留,并记录删除操作,不作为业务依赖阻止空应用删除。
- 删除、下单、凭证签发共享应用行锁,先检查后删除在同一事务完成。旧生成器单个及批量删除入口同步复用此规则,整批失败回滚。
本轮验证:JDK8 Rental*Test 56项通过;ESLint、Vue模板编译、`node tests/rental-app-time.mjs` 时间回归通过。未执行数据库授权SQL及真实浏览器联调。
## Secret 展示与凭证删除
- 一次性 Secret 保持只读密码框,使用独立“显示/隐藏”按钮;修复 Element UI readonly 导致内置显隐按钮被隐藏的问题。每次签发重置为隐藏,关闭清空。
- 凭证列表提供删除与二次确认,DELETE /rental/credential/{id} 复用 rent:credential:issue,无新增权限 SQL。
- 仅允许本人 APP 凭证删除;有关联任务、回调或未过期 nonce 时拒绝。由于订单不记录请求凭证版本,有任何应用订单(包括已取消历史订单)也拒绝删除,应保留历史凭证、按需吊销。
- 节点凭证禁止删除,继续使用吊销,避免丢失历史任务验签依据。旧生成器凭证删除入口同样复用业务校验。
- 删除不清理审计,也不恢复原先已转 VERIFY_ONLY 的其他版本;删除后若无 ACTIVE 凭证,需主动重新签发。
本轮验证:后端 Rental*Test 57项通过,前端 ESLint 与模板编译通过;未进行实际登录浏览器验收。
验收:空列表引导、创建失败保留输入、创建后打开详情、取消轮换不签发、重复点击防重、一次性密钥确认、跨用户详情拒绝、窄屏布局。构建及隔离测试不替代真实登录浏览器联调。
## 本次验证
- 页面及 API 文件 ESLint 通过,Vue 模板独立编译通过。
- staging 全量构建成功;其他页面存在 3 项导出缺失及资源体积警告。
- JDK8 后端 Rental*Test 共 55 项通过(0 失败),包含新增应用详情隔离测试。
- 尚未连接实际 MySQL 或登录 PROXY_ACCOUNT 浏览器验收。
+237
View File
@@ -0,0 +1,237 @@
# 能量与带宽出租业务复核与修正 V2.2
说明:本文保留设计复核阶段记录。后续新增的Java/Vue/Node.js实现、部署步骤及当前验证边界见[implementation.md](implementation.md),不把历史“未实现”陈述视为当前代码状态。
## 1. 结论与适用范围
原 V2.1 的独立余额、供应商本地签名、链上独立核验、未知隔离、履约和回收分离方向可保留,但退款、人工付款、资源快照和多单回收存在实质缺口。V2.2 已在 [初始化 SQL](../../sql/rent_init.sql)、[主设计](schema-design.md) 和[逐表说明](table-functional-flows.md)中同步修正,表数由 15 增至 16。
这是设计及初始化脚本修正,不是运行时修复报告。当前未实现租赁服务、未对现有数据库执行迁移、未进行 NILE 真实委托。下述应用约束必须由后续服务及 Agent 实现,MySQL 5.7 不会替应用执行 CHECK 或逻辑外键。
| 问题与触发场景 | 原设计后果 | 本次修正 |
| --- | --- | --- |
| 同订单第二次部分退款 | 回调 `(order_id,event_type)` 唯一键冲突;没有退款请求幂等主体 | 新增 rent_refund;回调改为 event_key 及订单事件序号唯一 |
| 审批后已人工付款,但尚未登记结果 | 仍处于 APPROVED,可能被拒绝并释放订单,或再次付款 | 新增 PAYING、唯一 payout_no、payment_started_at,先持久化授权再付款 |
| 平台手续费退给供应商 | 账户待结算增加,但订单结算来源公式不包含这部分 | 增加 supplier_fee_returned_amount,并纳入净可结算公式 |
| 委托已确认、资源预留已扣减,但异步旧查询回写 | 旧可委托本金再次可见,可能超卖 | 钱包最低快照区块、快照高度、version CAS、旧快照失效和任务执行占位配合 |
| 同钱包同接收者同类型存在多笔委托 | 链上聚合关系难归单,锁定及撤销可能互相影响 | 订单 relation_slot 持久互斥,直到本金回收且资源恢复;同地址下一单排队或改选钱包 |
| 可重试失败时先解冻,再生成新任务 | 可能无冻结资金继续履约 | 明确重试与终结:重试保留 HELD;最终失败才 RELEASE |
| 只扫描交易表恢复 UNKNOWN | Agent 已接单但未回 txId 的任务永远遗漏 | 同时扫描任务和交易,未知占位不释放 |
| 核验晚于实际交付很久 | 用核验时间作为租期起点,额外延长占用或对已过期业务扣款 | 保存 block_time,以确认交易区块时间算租期;已到期转人工 |
| 任意业务租期直接调用现有通用委托方法 | 当前实现写死 lock=true、86400 且直接广播,无法遵守本地持久化恢复协议 | 套餐 delegate_lock=0,首版只非锁定委托,Agent 独立执行;只复用查询 |
| 回收任务未显式绑定原交易 | 可能按当前资源换算或引用错误本金 | task.source_transaction_id 固定原确认委托,撤销原 SUN、同网络同类型 |
| 已上链但资源量不足 | 若按普通失败释放,将低估实际已委托本金 | 链上 CONFIRMED 与订单 SUCCESS 分离;先记事实及屏障,再人工处置和回收 |
## 2. 修正后的业务主流程
```mermaid
flowchart TD
A["应用认证、订单幂等、套餐校验"] --> B["下单事务:冻结USDT、锁定价格规则和执行截止"]
B --> C{"钱包、关系占位、快照和资源满足?"}
C -->|无| D["WAITING等待;截止前重试"]
D --> C
D -->|从未派单且超时| Z["取消、解冻、回调"]
C -->|有| E["预留SUN、关系占位、创建唯一在途任务"]
E --> F["Agent持久化、复核、原交易签名广播"]
F --> G{"云端独立核验"}
G -->|未知| H["保留占用、查询原任务和交易"]
H --> G
G -->|明确失败可重试| I["释放旧资源占位,保留冻结资金"]
I --> C
G -->|最终失败| J["解冻资金、释放安全占位、失败回调"]
G -->|上链但交付不足或核验已过期| M["确认链上事实、快照屏障、人工核对及回收"]
G -->|达标且未过期| K["扣款、供应商净应收、快照屏障、成功回调"]
K --> R["租期届满,按原交易SUN创建回收任务"]
M --> R
R --> S["撤销核验、快照屏障、资源恢复检查"]
S -->|未恢复| S
S -->|恢复| T["回收DONE,释放关系占位"]
K --> P["结算占用、独立审批、PAYING授权、人工付款核验"]
K --> Q["独立退款单审批、余额与流水原子调整"]
```
首版保持固定套餐、一单一种资源、一个钱包、整笔交付、整笔回收、每订单来源全额结算一次。能量与带宽分别下单、换算和预留。非锁定不表示自动回收,供应商必须承诺租期内不擅自撤销;平台监测委托关系,提前撤销转人工并按规则退款。平台不掌握私钥,不能用数据库约束阻止供应商自行链上操作。
## 3. 钱包快照、预留和互斥协议
### 3.1 两种占位分别负责什么
- `rent_order.relation_slot=1`:限制同钱包、同接收者、同类型只保留一笔在租或待回收订单。成功履约后仍保留;只有明确未执行释放,或原本金回收且本单资源恢复后才置 NULL。
- `rent_task.wallet_execution_slot=1`:同钱包同类型只允许一个在途链上操作,包括委托、回收和 UNKNOWN。核验终结并写入屏障后可置 NULL,让其他接收者的任务继续执行。
- `rent_task.active_slot=1`:同订单同任务类型的有效或已成功尝试占位。成功后继续保留用于追溯,只有明确失败且安全时才能置 NULL 后产生新 attempt。
三个占位业务上只允许 1 或 NULL。唯一键不阻止写入 2,所以服务端必须校验,不能接受客户端提交。节点不能把 UNKNOWN 当失败;租约、会话失效不释放占位。
### 3.2 取得和应用快照
1. 先读取钱包 version、snapshot_min_block_height 及地址、网络、策略,不持有长事务进行 RPC。
2. 通过受信任节点获取两类资源状态、对应全网参数、`getCanDelegatedMaxSize`、确认区块高度及必要证据。高度必须代表这些数据的实际观测状态,不得给旧数据贴上新高度。
3. 若 RPC 不支持按区块一致查询,应通过前后区块检查和节点一致性验证形成可验证观测;不能证明数据覆盖下界就拒绝调度,不伪造“确认区块参数”。历史交付核验需要可信历史快照或支持历史状态的节点,不能拿当前 L/W 冒充确认区块值。
4. 短事务 CAS 更新:version 仍等于查询前值,快照区块不回退且不低于 snapshot_min_block_height;成功后递增 version。任一条件失败丢弃并重查。
5. 快照刷新只改链上投影、参数、时间及高度,不覆盖 reserved_sun、占位和供应商策略。两类查询有一类失败时不推进共同快照,不用零覆盖旧值。
6. 调度还要检查对应 enabled、节点在线和审核状态、快照未过期、执行占位为空及可调度本金。普通 TRX 余额、免费带宽、收到代理量不参与本金池。
### 3.3 委托确认与快照屏障
假设旧快照可委托 1000 SUN,本次在途预留 600 SUN,链上已执行但旧查询仍返回 1000。若只减预留至 0,旧值会错误允许再委托 1000。
修正顺序:确认交易 → 同事务将该笔预留从 HELD 转 COMMITTED,reserved_sun 减 600 → snapshot_min_block_height 提升到确认区块 → snapshot_expires_at=NULL → version 递增 → 释放钱包执行占位。此时任何调度都因快照失效失败;旧查询因版本或区块不符失败。新查询覆盖已确认委托,取得真实剩余额度后才恢复出租。
撤销确认同样先写屏障、失效快照,再释放执行占位。回收任务固定 `reservation_status=NONE`,不能把回收本金当一笔新的待委托预留,也不能一确认撤销就机械增加可出租本金。接收者使用资源后撤销可能将资源使用债务转回供应者,实际可委托上限需重新查询。
未知时不释放预留或执行占位,即便快照已经包含交易变化,多扣一份也只会暂时保守,不得以“看起来余额够了”为由解除未知隔离。
### 3.4 地址对、链上锁定与外部修改
首版任务必须非锁定,接收者不是 owner,地址有效、已激活且满足目标网络当下委托条件。签名前检查同 owner/receiver 同类型已委托基线为零;存在外部委托或锁定关系则不使用该地址对。回收前确认关系与本单原本金对应,发现外部追加、提前撤销或部分变化则暂停相关调度并转人工。
参与租赁的钱包不得同时由其他平台或无协调脚本修改相同资源池。Agent 本地也要按钱包及类型串行,不只依赖云端。数据库无法防止拥有私钥者绕开 Agent;必须持续核对链上变化,不把事先审核当永久授权事实。
共享快照可能因另一资源类型的确认暂时整体失效,这是保守的首版取舍;不能跨类型转移本金。将来若拆独立快照,应为两类分别设置版本和区块屏障。
### 3.5 费用与任务授权
Stake 2.0 委托和撤销是原生操作,不应把智能合约调用的 fee_limit 字段当作它们的协议费用硬上限。此设计的 fee_limit_sun 是本地允许预算,Agent 根据当下带宽、网络费用、权限/签名附加费用和费用留存进行检查;预算为零或无法估算则拒绝。它不承诺协议费率变化时绝对不超额,供应商毛收入须覆盖双方约定的委托及回收成本。
新任务 intent 使用业务结构版本 `RENT_TASK_V2`,外层 HMAC 协议仍为 RENT_HMAC_SHA256_V1;签名覆盖新增 network、source_transaction_id、原委托 txId、精确 SUN、类型、两端地址、预算及期限等完整意图。Agent 对标量字段和签名原文一致性逐项校验,不能只验 JSON 一份却使用另一份未校验字段执行。回收来源必须可对应真实原交易;旧任务仍保留旧结构原文和验证路径,不原地重签。
## 4. 失败、重试、交付与回收
### 4.1 截止与重试
订单创建时固化 `dispatch_deadline`,DELEGATE 任务 deadline 不晚于它;RECLAIM 使用独立有效期,不受原下单截止限制。Agent 不能在任务过期后新签名/新广播,原交易查询和结果回报仍允许。
只有从未创建过执行任务的 WAITING 单可以用户取消或等待超时直接取消;已有投递线索时先恢复原任务。明确未执行拒绝可在截止前释放资源、保持 HELD 并重派;原订单 wallet_id、供应商及账号只在已证明无副作用且旧占位释放的安全重试中可重选,旧尝试归属保留在 task。最终 FAILED/CANCELLED 与资金 RELEASED 是终态,不能再自动恢复执行。
已构建原交易的重试,必须确认链上失败且无委托副作用,或原交易有效期已过并通过可信链上查询证明未执行。查询返回一次“未找到”、节点离线、worker 租约过期、Agent 本地丢记录都不足以证明。无 txId 的 UNKNOWN 同样由任务扫描处理,保留占用直至有足够证据。
### 4.2 链上成功与交付成功
`rent_transaction.CONFIRMED` 表示链上操作已执行,不表示套餐交付合格。将实际资源额度写入 verified_resource_quantity,即便小于目标也保存真实值。task VERIFIED 记录操作已核验,订单 MANUAL_REVIEW 保留资金,原本金进入回收计划。
服务起点为委托交易的可信 block_time;到期时间为起点加 duration_seconds。核验很晚、服务已经到期或无法取得可信历史参数时,不自动扣款或重设起点,转人工按实际交付和合同处理。已确认委托无论订单是否成功都要持久化回收计划。
异常 HELD 订单回收完毕后,按审核处置释放资金并终结 FAILED;没有确认供应商收入时不凭空创建应收。若要对异常实际服务收费,须新增明确补偿审批和流水业务,不能绕过本版成功条件直接修改余额。
### 4.3 回收不等于瞬间可再次出租
RECLAIM.source_transaction_id 只能引用本订单已确认的 DELEGATE 交易,网络、owner、receiver、资源类型和 SUN 全部一致。回收不能重新按资源量换算,不撤销其他来源,不自动部分回收。
撤销确认后状态可进入 RECOVERING;按可信可委托上限及资源恢复证据判定本单恢复,不要求数值回到旧快照(会受其他订单和全网参数影响)。无法归属或恢复债务持续异常时保留关系占位并人工核对。资源恢复判定标准须在 NILE 实测后固定,不能仅靠数据库状态宣称恢复。
## 5. 资金、退款和结算
### 5.1 统一锁顺序与原子性
所有流程统一锁序:账户按 ID 升序 → 已有结算单按 ID 升序 → 订单按 ID 升序 → 退款单按 ID 升序 → 钱包按 ID 升序 → 任务按 ID 升序 → 交易记录。只锁本操作涉及的层级,可跳过但不能逆序回锁。先读取候选 ID,再开启事务按顺序重查状态和归属;发现归属已变则回滚重试,禁止持有订单锁后补锁账户。
套餐版本商业字段不可变;下单在账户之后锁套餐再插入新订单。节点审核/连接改变用状态条件、版本和 Agent 再验证保护,不在钱包锁后反向锁账户。所有外部调用在短事务外执行。
结算创建和退款审批共同锁定供应商账户及来源订单,因此不能在检查完“无结算占用”后又被并发结算抢走。结算不扣审批阶段余额,但有效明细占住来源。退款提交时 PENDING 不预留金额,审批时必须再次校验累计,多个审批由订单行锁裁决。
余额、流水、订单累计、退款 APPLIED、回调队列和审计同事务;唯一键冲突必须回滚整个余额变更,不得捕获后继续提交。重试用固定业务键查既有结果。
### 5.2 退款计算和逐次回调
设本次商户退款 M、供应商原净额冲正 S、平台手续费退回 F:
- M > 0;M 加累计 refunded_amount 不超过售价。
- S >= 0;S 加 supplier_reversed_amount 不超过原 supplier_net_amount。
- F >= 0;F 加 supplier_fee_reversed_amount 不超过原 supplier_fee_amount。
- F=0 时 fee_return_to 必须 NONE;F>0 时只能 MERCHANT 或 SUPPLIER。
- MERCHANT 时 F<=M,F 已包含在 M 中,不能再增加 F 可用余额。
- SUPPLIER 时增加待结算 F,并增加订单 supplier_fee_returned_amount;它是 supplier_fee_reversed_amount 的子集,不能再冲正第二次。
- 涉及 S 或 F 的审批,若来源已结算或存在有效结算明细,拒绝应用;回到人工协调,不能修改已付记录。S=F=0 的平台承担退款可独立审批。
- 最终各账户余额不能为负。商户和供应商是同一账户时仍分别追加业务流水,按单次变化顺序计算 after 值。
退款流水建议使用 `REFUND:<refund_no>:MERCHANT`、`:SUPPLIER_REVERSE`、`:FEE_RETURN` 等独立 business_key,全部关联 refund_id。MERCHANT 退费可拆为基础退款 M-F 与手续费退款 F,后者 delta_platform_fee=-F;F=M 时不必写零额基础流水。SUPPLIER 方向的商户退款为 +M,供应商手续费返还为待结算 +F、平台手续费 -F,供应商原净额冲正另为 -S。
每次 APPLIED 产生 event_key=`REFUND:<refund_no>`,payload 保存本次金额及该时点累计。锁订单行后,以当前读查询该订单最高序号(例如按序号倒序 LIMIT 1 FOR UPDATE),分配 `order_event_sequence=max(已有序号)+1`;不能使用事务旧快照中的 MAX。普通成功等事件仍使用稳定 ORDER:id:type 键。没有回调地址时不创建发送任务。重试不修改内容和序号;消费者按 event_no 去重,不用到达顺序覆盖较新累计。
### 5.3 手续费返还与结算来源一致
```text
本单净可结算 = supplier_net_amount
- supplier_reversed_amount
+ supplier_fee_returned_amount
```
例:原供应商净应收 9.5 USDT、平台手续费 0.5 USDT;审核给商户退 1 USDT,同时将 0.2 USDT 手续费返供应商。商户 +1,供应商待结算 +0.2,平台手续费 -0.2;本单可结算变 9.7,而不是仍为 9.5。若另冲正原净应收 0.3,则变 9.4。此来源金额在结算创建时快照,结算占用期间禁止再改变供应商/手续费来源。
### 5.4 人工付款恢复
```text
PENDING → APPROVED → PAYING → PAID
↘ UNKNOWN → PAID
PENDING / APPROVED → REJECTED(尚未授权付款)
PAYING / UNKNOWN → REJECTED(独立证明未付款且授权已作废,特殊审核)
```
出款前必须持久化 payout_no 并提交 PAYING。付款页面和操作规程以 payout_no 为核对依据,结果未确认不得提供“重新付款”入口。进程崩溃后查询原付款证据;数据库授权只能防应用重复发起,人工操作和外部付款平台也必须遵守单一授权,不声称数据库能保证外部资金绝对只支付一次。
付款凭据按 network:txid:eventIndex 等规范化并独立核验金额、币种、网络、实际收款人与授权一致;payment_reference 唯一不能代替真实性核验。付款确认时原子减少待结算、追加 SETTLE、标记 PAID。PAID 明细占位保留。
### 5.5 充值与对账
TOPUP 的 business_key 以已核验的全局充值事件构造,不含账户 ID;其他流水键可以包含账户。键长度扩为 160 ASCII,为不同事件编号及账户组合留足空间,所有写入仍检查长度并拒绝截断。evidence_ref 仍是依据描述,不是唯一约束。
每日按网络核对:冻结余额 = HELD 订单售价合计;供应商待结算 = 已确认且未支付来源净额合计(包括退回供应商手续费);账户各余额 = 对应流水增量合计;平台手续费收入 = delta_platform_fee 合计;钱包预留 = HELD 委托任务本金合计。退款拒绝、结算拒绝和未知都保留历史,不手改差额。
## 6. SQL 与文档修正清单
| 表 | V2.2 变化 |
| --- | --- |
| rent_wallet | 快照高度、最低区块屏障 |
| rent_package | delegate_lock,首版只允许非锁定 |
| rent_order | 供应商账户、关系占位、执行截止、手续费返还累计、关系唯一键及扫描索引;修正服务起点 |
| rent_task | network、原委托交易引用、钱包执行占位及唯一键;回收预留 NONE |
| rent_transaction | block_time;实际资源不足不篡改链上事实 |
| rent_ledger | business_key 扩容及 ASCII、refund_id,修正手续费方向说明 |
| rent_settlement | PAYING、唯一 payout_no、付款授权时间 |
| rent_settlement_item | 净结算来源加入返还供应商手续费 |
| rent_refund | 新表,审批、幂等、退款与各方费用承担 |
| rent_webhook | event_key、订单事件序号及唯一键,删除按事件类型唯一限制 |
| rent_event | 编号长度与 ASCII、REFUND 审计类型 |
其余表保留原身份、凭证、防重放和资金账户职责。金额和状态检查仍须服务端执行,不能把 COMMENT 当数据库约束。
## 7. 已有数据库的迁移要求
本次只修订初始化 DDL,不提供盲目执行的 ALTER,因为目前没有实际已部署表结构和历史数据证据。重跑 IF NOT EXISTS 不会增加字段、修改索引或回填数据。
1. 暂停新单和新出款,备份结构及数据,核对实际版本;历史链上交易继续独立核对。
2. 先增可空字段并建退款表,再从可信来源回填;不要直接给历史在途单填一个“当前时间”或虚构的 block_time。
3. 同钱包同接收者同类型的历史重复在租订单,以及同钱包同类型多在途任务,先隔离核对,不能直接全部赋占位 1 后强建唯一键,也不能把 UNKNOWN 随意置 NULL。
4. 回填 supplier_account_id,检查用户/网络归属;历史手续费返还从不可变流水及审核依据重建,没有事实证明时不能猜测。
5. 回填 dispatch_deadline;历史已投递任务保持恢复路径,不因回填截止被自动取消或重派。
6. 原委托 block_time 从链上核验;RECLAIM.source_transaction_id 按真实原交易回填。旧任务 intent 和 HMAC 不原地修改,新字段仅用于新任务协议,旧在途沿旧版验证至完结。
7. 历史已锁定委托不改写为非锁定;保留原授权和真实锁期,专门回收。新套餐使用新版本和 delegate_lock=0。
8. 历史结算 APPROVED 需逐笔核对是否已付款或已开始人工付款,未知先隔离为 UNKNOWN;不能默认未付。历史付款凭据规范化去重后再建唯一索引。
9. 已有回调在保留原 payload、event_no 前提下按可信业务来源分配 event_key 和订单序号;历史缺失的部分退款需核对后补独立记录,不能重发造成再次退款。
10. 快照全部失效,初始化最低区块为已确认相关交易高度,可信重查后才恢复出租;验证新唯一键及逻辑约束,再上线服务。
## 8. 验收场景与边界
| 场景 | 必须满足的结果 |
| --- | --- |
| 同订单并发两次同退款请求 | 只一条退款单、一次余额变化和一次业务回调 |
| 同订单两次不同部分退款 | 两条退款来源和回调均可保存,累计不超过售价 |
| 两个退款审批累计超限 | 订单行锁裁决,第二个重新检查后拒绝,不改余额 |
| 同地址对同类型两单并发调度 | 关系唯一键只允许一个占位;失败事务不能遗留预留 |
| 同钱包同类型两个链上任务 | 执行唯一键拒绝第二个;不同类型独立占位 |
| 原任务 UNKNOWN | 预留及占位保留,不新签、不改派;无 txId 仍被恢复扫描 |
| 老快照请求在新确认事务之后返回 | 版本或高度不匹配,丢弃,不恢复出租额度 |
| 委托确认后扣掉预留但尚无新快照 | 快照失效,调度拒绝 |
| 已上链却未覆盖冗余目标 | 交易 CONFIRMED,订单人工核对,仍追踪本金回收,不重复委托 |
| 可重试失败 | 保留商户冻结资金,无终态失败回调 |
| 最终失败 | 一次解冻,不再自动新执行 |
| 核验晚于原租期 | 不延长起点或自动扣款,人工处理真实交付 |
| 回收任务 | 绑定原委托、原 SUN、同类型,reservation_status=NONE |
| 回收后资源尚未恢复 | RECOVERING,不按旧快照重租,不释放关系占位 |
| 手续费返供应商后结算 | 返还额同时存在账户、流水和来源订单,可结算金额一致 |
| 退款与结算并发 | 同账户/订单锁序决定唯一有效来源,不能既付款又冲掉来源 |
| PAYING 后崩溃或失联 | 查原 payout_no,不能普通拒绝或重新出款 |
| 重复充值凭据给不同账户 | TOPUP 全局业务键冲突,整个事务回滚 |
| 重复回调与乱序 | 余额不受影响,商户按 event_no 去重及事件序号识别旧事件 |
静态 DDL 与模型验证结果记录在 [validation-v2.2.md](validation-v2.2.md)。静态检查不能替代真实 MySQL 5.7/8.0 并发事务、Agent 故障恢复、HMAC 跨语言向量和 NILE 资源恢复实测。
+169
View File
@@ -0,0 +1,169 @@
"""离线验证租赁 DDL 的索引语义、文档覆盖及资金算例。
运行:python docs/rental/check_schema.py
仅使用标准库。SQLite 内存库只映射实际 DDL 的列名和唯一键,
用于验证冲突/NULL 占位语义,不替代 MySQL 方言、类型或并发事务测试。
"""
from decimal import Decimal
from pathlib import Path
import re
import sqlite3
import unittest
ROOT = Path(__file__).resolve().parents[2]
DDL = (ROOT / "sql/rent_init.sql").read_text(encoding="utf-8")
TABLES = {}
for match in re.finditer(
r"CREATE TABLE IF NOT EXISTS `([^`]+)` \((.*?)\n\) ENGINE=.*?;",
DDL,
re.S,
):
name, body = match.groups()
columns = re.findall(r"^ `([^`]+)` (.+?)(?:,)?$", body, re.M)
unique = [
(key, re.findall(r"`([^`]+)`", fields))
for key, fields in re.findall(
r"UNIQUE KEY `([^`]+)` \(([^)]+)\)", body
)
]
TABLES[name] = (columns, unique)
class RentalDesignChecks(unittest.TestCase):
def setUp(self):
self.db = sqlite3.connect(":memory:")
self.serial = 0
for table, (columns, unique) in TABLES.items():
definitions = [
'"id" INTEGER PRIMARY KEY' if field == "id" else f'"{field}" TEXT'
for field, _ in columns
]
definitions.extend(
"UNIQUE (" + ",".join(f'"{field}"' for field in fields) + ")"
for _, fields in unique
)
self.db.execute(f'CREATE TABLE "{table}" ({",".join(definitions)})')
self.addCleanup(self.db.close)
def insert(self, table, **values):
self.serial += 1
# 为与本用例无关的唯一列使用独立值,避免错误命中其他唯一键。
row = {
field: f"row-{self.serial}-{field}"
for field, _ in TABLES[table][0]
if field != "id"
}
row.update(values)
self.db.execute(
f'INSERT INTO "{table}" ({",".join(row)}) '
f'VALUES ({",".join("?" for _ in row)})',
tuple(row.values()),
)
def conflict(self, table, **values):
with self.assertRaises(sqlite3.IntegrityError):
self.insert(table, **values)
def test_table_and_document_coverage(self):
self.assertEqual(len(TABLES), 17)
self.assertEqual(len(re.findall(r"CREATE TABLE", DDL)), 17)
doc = (ROOT / "docs/rental/table-functional-flows.md").read_text("utf-8")
sections = set(re.findall(r"### 2\.\d+ (rent_\w+):", doc))
self.assertEqual(sections, set(TABLES))
for table, (columns, unique) in TABLES.items():
fields = {name for name, _ in columns}
self.assertEqual(len(fields), len(columns), table)
self.assertTrue({"id", "version", "created_at", "updated_at"} <= fields)
for name, definition in columns:
self.assertIn("COMMENT '", definition, f"{table}.{name}")
for key, parts in unique:
self.assertTrue(set(parts) <= fields, f"{table}.{key}")
executable = re.sub(r"--[^\n]*", "", DDL)
self.assertNotRegex(executable, r"(?i)\b(DROP|ALTER|DELETE|TRUNCATE)\b")
def test_document_local_links(self):
for path in (ROOT / "docs/rental").glob("*.md"):
for target in re.findall(r"\]\(([^)]+)\)", path.read_text("utf-8")):
if "://" not in target and not target.startswith("#"):
self.assertTrue((path.parent / target.split("#")[0]).exists(), target)
def test_order_relation_exclusion_and_null_release(self):
key = dict(wallet_id=7, receiver_address="receiver-A", resource_type="ENERGY")
self.insert("rent_order", **key, relation_slot=1)
self.conflict("rent_order", **key, relation_slot=1)
self.insert("rent_order", **key, relation_slot=None)
self.insert("rent_order", **key, relation_slot=None)
self.insert("rent_order", **{**key, "resource_type": "BANDWIDTH"}, relation_slot=1)
self.insert("rent_order", **{**key, "receiver_address": "receiver-B"}, relation_slot=1)
def test_wallet_execution_shared_by_delegate_and_reclaim(self):
key = dict(wallet_id=7, resource_type="ENERGY", wallet_execution_slot=1)
self.insert("rent_task", **key, task_type="DELEGATE")
self.conflict("rent_task", **key, task_type="RECLAIM")
self.insert("rent_task", **{**key, "resource_type": "BANDWIDTH"})
self.insert("rent_task", **{**key, "wallet_execution_slot": None})
self.insert("rent_task", **{**key, "wallet_execution_slot": None})
def test_task_attempt_active_slot(self):
key = dict(order_id=11, task_type="DELEGATE", active_slot=1)
self.insert("rent_task", **key, attempt_no=1)
self.conflict("rent_task", **key, attempt_no=2)
self.insert("rent_task", **{**key, "active_slot": None}, attempt_no=2)
self.conflict("rent_task", **{**key, "active_slot": None}, attempt_no=2)
def test_refund_request_deduplication(self):
self.insert("rent_refund", order_id=11, request_no="request-A")
self.conflict("rent_refund", order_id=11, request_no="request-A")
self.insert("rent_refund", order_id=11, request_no="request-B")
def test_multiple_partial_refund_webhooks(self):
self.insert("rent_webhook", order_id=11, event_type="REFUNDED",
event_key="REFUND:R1", order_event_sequence=2)
self.insert("rent_webhook", order_id=11, event_type="REFUNDED",
event_key="REFUND:R2", order_event_sequence=3)
self.conflict("rent_webhook", order_id=11, event_type="REFUNDED",
event_key="REFUND:R1", order_event_sequence=4)
self.conflict("rent_webhook", order_id=11, event_type="REFUNDED",
event_key="REFUND:R3", order_event_sequence=3)
def test_payout_and_payment_reference_uniqueness(self):
self.insert("rent_settlement", payout_no="P1", payment_reference="MAINNET:tx:0")
self.conflict("rent_settlement", payout_no="P1", payment_reference=None)
self.conflict("rent_settlement", payout_no="P2", payment_reference="MAINNET:tx:0")
self.insert("rent_settlement", payout_no=None, payment_reference=None)
self.insert("rent_settlement", payout_no=None, payment_reference=None)
def test_settlement_order_source_not_reusable_after_paid(self):
self.insert("rent_settlement_item", order_id=11, active_slot=1)
self.conflict("rent_settlement_item", order_id=11, active_slot=1)
self.insert("rent_settlement_item", order_id=11, active_slot=None)
def test_topup_global_business_key(self):
key = "TOPUP:MAINNET:" + "a" * 64 + ":2147483647"
self.assertLessEqual(len(key), 160)
self.insert("rent_ledger", account_id=1, business_key=key)
self.conflict("rent_ledger", account_id=2, business_key=key)
def test_one_transaction_per_task_and_hash(self):
self.insert("rent_transaction", task_id=11, network="NILE", tx_id="tx1")
self.conflict("rent_transaction", task_id=11, network="NILE", tx_id="tx2")
self.conflict("rent_transaction", task_id=12, network="NILE", tx_id="tx1")
def test_supplier_fee_return_example(self):
# 精确金额算例:账户待结算增量必须与来源订单可结算额一致。
gross, fee = Decimal("10"), Decimal("0.5")
returned, reversed_net = Decimal("0.2"), Decimal("0.3")
ledger_pending = gross - fee + returned - reversed_net
order_source = Decimal("9.5") - reversed_net + returned
self.assertEqual(ledger_pending, order_source)
self.assertEqual(order_source, Decimal("9.4"))
# 退商户的手续费已包含于M:基础退款+手续费退款=M,不能M+F。
merchant_refund, merchant_fee_part = Decimal("1"), Decimal("0.2")
self.assertEqual((merchant_refund - merchant_fee_part) + merchant_fee_part,
merchant_refund)
if __name__ == "__main__":
unittest.main(verbosity=2)
+297
View File
@@ -0,0 +1,297 @@
# 云端内置 TRON 历史资源证明服务
本功能随现有 Java 8 云端服务启动,复用 MySQL 和只读 TRON RPC,不需要另起一个 Java 服务,也不需要供应商运行 TRON 节点。默认关闭;不持有钱包私钥,不签名、不广播、不执行自动出金。
业务16表保持不变,复用4张历史证据表,额外增加1张待确认缓冲表 `rent_history_sample`。新环境执行 [rent_history_init.sql](../../sql/rent_history_init.sql);已有历史库还需执行幂等升级脚本 [rent_history_cleanup_upgrade.sql](../../sql/rent_history_cleanup_upgrade.sql),给游标增加两个独立清理租约字段。业务基础脚本仍为 [rent_init.sql](../../sql/rent_init.sql)。本次没有对现有数据库执行这些脚本。
## 1. 实现范围与可信前提
普通 HTTP RPC 不支持任意历史高度的完整账户/全网资源状态。内置实现采用“FullNode实时状态采样、等待确认 + 完整区块事件归档 + 地址对重放”,从启用时开始积累可用的历史证据,不是完整 TRON 归档节点,也不能凭空恢复上线前的历史资源参数。
采集必须使用**由运营信任、状态一致的固定 RPC 节点**。Nile公共服务没有`/walletsolidity/getaccountresource`,不能用该路径,也不能把最新参数标记为当前确认头参数。当前实现先用最新头夹读绑定采样高度,待该高度进入确认链并核对哈希后才归档。公共负载均衡服务即使前后两次头相同,也不能证明中间请求来自同一后端;生产应使用自己的固定节点或有一致性保证的服务。需要支持以下 POST 接口:
| 接口 | 用途 |
| --- | --- |
| `/walletsolidity/getnowblock` | 获取确认头高度、区块哈希 |
| `/wallet/getnowblock` | FullNode最新头,夹读以绑定实时采样高度 |
| `/wallet/getaccountresource` | 该最新高度的能量/带宽全网额度和权重 |
| `/wallet/getdelegatedresourcev2` | 当前委托关系检查 |
| `/walletsolidity/getdelegatedresourcev2` | 首次地址对已确认的 Stake 2.0 本金基线,需支持lock=false/true |
| `/walletsolidity/getblockbynum` | 按高度读取确认区块及按序交易、执行回执 |
示例RPC地址仅表示接口来源,不能据此认为公共服务已通过生产验收。不支持某接口、返回参数不完整或限流时,采集会失败,不用空值伪造成功。
全网参数是**交易所在区块执行完成后的确认状态**,不是交易在区块内执行前的瞬时参数,也不是保证整个租期内用户可用资源恒定不变。资源被用户消耗、全网参数后续变化不由这份历史证明保证。
## 2. 业务流程
1. 每个网络独立运行参数采样、参数确认、事件扫描三个后台通道。采样读取FullNode最新头 H1、全网资源参数、最新头 H2,高度与哈希都一致才按网络/高度持久化到 `rent_history_sample`,同高度去重,冲突不覆盖。确认通道核对确认区块哈希后提升到 `rent_history_block` 并删除缓冲;分叉采样只丢弃。重启后继续确认已持久化采样,漏采高度不补造。`RentalChain.snapshot` 刷新 `rent_wallet` 时也可提交本次成功夹读的同高度参数,避免重复查询;旧 `rent_wallet` 记录不能充当历史参数。
2. 首次采集从当前确认头开始;已有派单前基线时,从最早基线的下一高度开始。以后从数据库游标下一高度补采确认区块。
3. 每个区块按原交易顺序解析成功的 `DelegateResourceContract` 和 `UnDelegateResourceContract`,保存全网委托/回收事件。相关交易没有完整回执时整个区块不推进。
4. 写入区块事件、标记区块完整和推进游标在同一事务中完成;父哈希不连续、重复高度哈希不同、同高度参数冲突时拒绝覆盖。
5. 派单优先复用地址对已有基线及完整连续事件,重放本金为0后追加检查点,减少后续重放量;游标近期未推进或区块不完整时退回确认节点。首次地址对使用确认头前后夹读 `/walletsolidity/getdelegatedresourcev2`,锁定与非锁定本金合计必须为0,不再等待最新头再确认一轮。不支持该接口、RPC返回错误或头变化时保持等待,不能用最新关系冒充确认基线。原有当前关系检查继续保留;全局参数采样超过默认15秒不新鲜时暂停新派单。
6. 本地 Agent 按原流程执行,云端原有核验继续检查真实交易、owner/receiver、网络、资源类型、非锁定、SUN、回执、确认深度及当前关系。
7. 内置服务查找目标交易之前最近的关系基线,验证从基线到交易区块的所有区块连续且事件完整,按区块高度和交易序号重放本金变化。目标交易必须真实存在于归档,不能用请求的本金代替事件。
8. 从目标区块读取当时保存的额度和权重,返回目标交易前后本金及资源参数。云端以原有精确整数公式换算资源,达标且租期未结束时才扣款、记供应商收入。
9. 完整历史证明进入 `rent_transaction.evidence` JSON,供审计查看;不会把额外证明字段当作交易表的新列写入。
10. 订单事务提交后进入有界异步派单队列,任务事务提交后立即定向推送对应节点。同一订单执行去重,同一连接的即时推送与定时扫描串行,继续复用原投递ID与签名任务。回滚不投递,队列满、重启或临时失败由3秒派单扫描和2秒推送扫描补偿。默认4个工作线程、队列容量200;不在下单HTTP线程执行链上调用。正常在线且RPC及时返回时以约10秒内接单为目标,不承诺在限流、链上故障或队列拥塞下仍满足。
```text
派单前确认基线 B
↓
连续归档 B+1 … H 的成功委托/回收事件
↓
重放到指定交易 → baseline_sun / after_sun
+
实时采到的区块 H 全网额度 / 权重
↓
完整历史证明 → 原有交付核验与资金状态机
```
公式保持:
```text
交付资源 = floor(委托本金SUN × 当时全网资源额度 ÷ (当时全网资源权重 × 1,000,000))
```
## 3. 四张表的具体设计
额外的 `rent_history_sample` 只保存网络、高度、哈希、四个全网参数和原始采样时间,主键为网络/高度。它是耐重启的待确认缓冲,不供履约证明直接读取。确认后写入下述原有证据表,`parameters_at` 保留原始采样时间,不能以较晚的归档时间伪装新鲜采样。
### rent_history_cursor:采集进度和网络租约
| 字段 | 类型 | 功能 |
| --- | --- | --- |
| network | VARCHAR(16),主键 | NILE/MAINNET,各自独立 |
| scanned_height | BIGINT,可空 | 已完整入库事件的最后区块高度,首次采集前为空 |
| scanned_block_id | VARCHAR(64),可空 | 游标区块哈希,下一块必须引用它 |
| lease_owner | VARCHAR(64),可空 | 本轮采集实例随机令牌 |
| lease_until | DATETIME(3),可空 | 以数据库 UTC 时钟计算的60秒租约 |
| cleanup_owner / cleanup_until | VARCHAR(64) / DATETIME(3),可空 | 清理器独立60秒网络租约,与扫描租约互不覆盖 |
| last_success_at | DATETIME(3),可空 | 最近完整区块成功入库时间 |
| last_error | VARCHAR(255),可空 | 脱敏状态,不保存RPC原始异常或密钥 |
| updated_at | DATETIME(3) | 最近更新UTC时间 |
每网络一次只允许一个实例采集。RPC结束后、落库前持锁检查租约,过期实例不得写入或推进游标;释放租约也匹配原令牌,不能释放新实例的租约。
### rent_history_block:区块事实和历史参数
| 字段 | 类型 | 功能 |
| --- | --- | --- |
| network + block_height | VARCHAR(16) + BIGINT,复合主键 | 唯一定位网络内区块 |
| block_id / parent_id | VARCHAR(64) | 当前/父区块哈希,检查连续性 |
| block_time | BIGINT | 链上区块时间戳,毫秒 |
| events_complete | TINYINT | 1表示本块全部相关成功事件已完整归档 |
| energy_limit / energy_weight | BIGINT,可空 | 该区块确认状态的全网能量参数 |
| bandwidth_limit / bandwidth_weight | BIGINT,可空 | 该区块确认状态的全网带宽参数 |
| parameters_at | DATETIME(3),可空 | 实时夹读采样经确认哈希校验后入库的UTC时间;区块高度仍是原采样高度 |
| created_at | DATETIME(3) | 首次记录UTC时间 |
唯一索引 `(network, block_id)` 防止同哈希被绑定不同高度。参数全部为空且 `parameters_at` 为空表示**该高度资源参数漏采**,即使区块交易成功补齐也不能把后来参数填入该行。
### rent_history_event:全网成功 Stake 2.0 委托事件
| 字段 | 类型 | 功能 |
| --- | --- | --- |
| network + tx_id | VARCHAR(16) + VARCHAR(64),复合主键 | 同网络交易幂等去重 |
| block_height / tx_index | BIGINT / INT | 所在区块及原始交易顺序 |
| owner_address / receiver_address | VARCHAR(64) | 统一小写41前缀十六进制地址 |
| resource_type | VARCHAR(16) | ENERGY/BANDWIDTH,分别重放 |
| operation | VARCHAR(16) | DELEGATE/UNDELEGATE |
| amount_sun | BIGINT | 正整数本金,SUN单位 |
| locked | TINYINT | 是否锁定;目标交付交易必须非锁定 |
| created_at | DATETIME(3) | 归档UTC时间 |
唯一索引 `(network, block_height, tx_index)` 保证位置唯一;关系重放索引为 `(network, owner_address, receiver_address, resource_type, block_height)`。失败交易不改变关系,不记录为成功事件。
### rent_history_anchor:派单前关系基线
| 字段 | 类型 | 功能 |
| --- | --- | --- |
| network | VARCHAR(16) | 所属网络 |
| owner_address / receiver_address | VARCHAR(64) | 规范化十六进制地址对 |
| resource_type | VARCHAR(16) | 资源类型 |
| block_height | BIGINT | 真实采样的确认区块高度 |
| block_id | VARCHAR(64) | 基线区块哈希 |
| balance_sun | BIGINT | 锁定及非锁定Stake2.0本金合计 |
| created_at | DATETIME(3) | 采样UTC时间 |
复合主键 `(network, owner_address, receiver_address, resource_type, block_height)`。当前派单只接纳余额0的基线;相同主键的事实必须一致,不能修改旧基线以通过结算。
### 表之间及与业务表的协作
| 来源 | 去向 | 协作 |
| --- | --- | --- |
| rent_wallet、rent_order | rent_history_anchor | 派单前按钱包地址、接收地址、网络和资源建立基线 |
| rent_history_cursor | rent_history_block | 确定下一采集高度、校验父哈希及网络租约 |
| rent_history_block | rent_history_event | 同事务写入该块全部相关事件后才标记完整 |
| rent_history_anchor + block + event | 内置证明 | 连续区块重放出目标交易前后本金,读取目标区块参数 |
| 内置证明 | rent_transaction、rent_order、rent_account、rent_ledger | 复用既有核验、证据JSON、订单及资金事务,不直接修改业务余额 |
历史表按网络和链上事实归属,不存在 `user_id`;不生成普通用户任意增删改接口。采用逻辑外键,不影响旧业务表结构。
## 4. 安装与同进程部署
1. 检查并备份目标数据库;新环境先执行 `sql/rent_init.sql`,再执行 `sql/rent_history_init.sql`。既有业务库只需执行后者,不要重建业务表。
2. 使用JDK8执行 `mvn -o -pl ruoyi-admin -am package -DskipTests`。当前项目采用瘦JAR加外部依赖目录:部署时同时更新 `ruoyi-admin/target/ruoyi-admin.jar` 和 `ruoyi-admin/target/lib/`,不能只替换入口JAR,否则可能继续加载旧的ruoyi-system。仍使用原来的MySQL和启动方式,载入 `rental` profile,不需要新增独立Java进程。
3. 设置环境变量,先在NILE验收:
```text
RENT_ENABLED=true
RENT_HISTORY_EMBEDDED_ENABLED=true
RENT_HISTORY_NETWORKS=NILE
RENT_HISTORY_POLL_MS=1000
RENT_HISTORY_BATCH_SIZE=30
RENT_NILE_RPC=https://你的固定且状态一致的TRON-RPC
RENT_RPC_KEY=按所用RPC要求提供
```
`RENT_HISTORY_PROBE_ADDRESS` 可设置为该网络已激活的公开TRON地址,只用于读取全网额度/权重,不需要私钥,不发生扣费。默认是TRON零地址;若节点对未激活地址不返回全网参数,应配置已激活的地址。
4. 保留原有主密钥等业务配置。**内置模式不需要设置 `RENT_NILE_HISTORY` 或 `RENT_MAINNET_HISTORY`,不要把它们设为本机HTTP地址。** 代码直接调用内置Java服务,避免自请求、登录认证及线程池依赖。
5. 使用具有 `rent:manage:audit` 的运营账号调用 `GET /rental/history/status`,确认目标网络产生游标和参数高度,再测试注册、下单、委托及回收。没有新菜单授权要求,复用既有运营核对权限;业务角色不授予这个权限。
6. 主网验收后显式配置 `RENT_HISTORY_NETWORKS=NILE,MAINNET`,并提供主网RPC。该配置只启用只读采集,不会打开本地Agent的广播授权。
完整配置项:
| 配置 | 默认值 | 说明 |
| --- | --- | --- |
| rental.history.embedded-enabled | false | 开启内置核验;采集器还要求rental.enabled=true |
| rental.history.networks | NILE | 逗号分隔,允许NILE、MAINNET;未启用网络不建立派单基线 |
| rental.history.poll-interval-ms | 1000 | 每网络轮询间隔,允许200至60000毫秒 |
| rental.history.batch-size | 30 | 每轮最多补采区块数,允许1至200 |
| rental.history.parameter-grace-seconds | 120 | 已归档区块参数暂未提升时的重试窗口,0至3600秒;超时仍缺失才走人工核对 |
| rental.history.max-sample-age-seconds | 15 | 派单要求最近全局参数采样新鲜,1至300秒 |
| rental.delivery.workers | 4 | 即时派单/推送线程数,1至32 |
| rental.delivery.queue-capacity | 200 | 有界队列容量,1至10000;满时依靠持久化扫描恢复 |
| rental.history.probe-address | TRON零地址 | 查询全网参数的公开地址 |
| rental.history.nile/mainnet | 空 | 保留外部历史服务兼容;内置开启时不使用 |
每个启用网络有三个独立守护任务,正常关闭时停止线程。网络间互不阻塞;多实例利用数据库租约避免重复扫描,采样与参数归档通过唯一键、行锁及不可变事实校验幂等合并。既有Agent WebSocket单入口限制不因历史采集多实例而改变。
## 5. 查询接口
两接口都要求若依登录态和 `rent:manage:audit`,没有匿名开放,没有供应商写入历史数据的接口。
### GET /rental/history/status
标准若依AjaxResult,data为每网络采集状态:`network`、`scanned_height`、`scanned_block_id`、`last_success_at`、`last_error`、`last_parameter_height`、`parameter_gap_count`、`pending_sample_count`、`latest_sample_height`。后两项分别为待确认缓冲数量及最新待确认高度,需结合已归档参数高度判断。
`parameter_gap_count` 为已有完整事件区块中参数为空的区块数,不代表遗漏区块没有交易,也不代表所有订单都会受影响。应监控游标停滞、错误和参数缺口。
### POST /rental/resource-proof
请求:
```json
{
"network": "NILE",
"tx_id": "64位十六进制交易哈希",
"block_height": 12345678,
"owner": "供应商Base58地址",
"receiver": "租赁接收Base58地址",
"resource_type": "ENERGY"
}
```
成功直接返回证明对象,兼容既有数据字段,另外包含 `network`、`block_id`、`owner`、`receiver`、`resource_type`、`anchor_height` 和 `source=EMBEDDED_SOLIDITY_REPLAY_V1`。不会接受请求方指定的 `baseline_sun`、`after_sun`、额度或权重。
该接口用于运营排查,**自动核验不通过此HTTP接口**。它不是原外部无登录RPC模式的替换地址。内部本金、区块高度为精确Java long;HTTP继续复用租赁响应转换器,将BIGINT转为十进制字符串、UTC时间转为ISO8601,并设置no-store。运营脚本应保留精度,不用浮点数解析。
## 6. 失败处理与运维边界
| 场景 | 行为 |
| --- | --- |
| 扫描游标尚未到交易高度 | 核验抛出待重试错误,原有后台核验下轮继续 |
| 交易高度暂时没有历史参数 | 在参数等待窗口内保持重试;超时仍缺失则不出具证明,已确认委托进入原有MANUAL_REVIEW,保留冻结资金 |
| 无交易之前的基线 | 不出具证明;不能用交易之后的状态倒造基线 |
| 缺区块、父哈希断裂、目标区块哈希与RPC不符 | 拒绝核验,保留占用和资金,等待运营检查 |
| 同区块同关系在目标交易后继续变化 | 若最终本金不等于目标交易后本金则拒绝证明 |
| 目标交易锁定、交易不存在、资源类型不符 | 拒绝证明 |
| 重放本金为负或整数溢出 | 拒绝证明 |
| 基线到目标区块跨度超过10000 | 拒绝自动重放,避免无界查询 |
| 停机后重启 | 从持久游标补交易;已错过的全网参数保持NULL |
采集间隔小于出块间隔不保证每个高度都能捕获:节点确认头跳跃、网络慢、RPC限流和采集停机均可能造成参数缺口。生产需要低延迟且有容量保障的RPC,并根据状态接口告警;**本实现不会声称公共RPC轮询等同完整历史归档节点**。需要任意历史补录能力时,应另外建设可回放状态的归档节点/节点侧采集,而不是手工向历史表填当前参数。
历史表已提供下述归档后清理策略。单网络每天约有28800个三秒区块,事件量取决于全网委托交易;仍应评估磁盘、备份与索引容量。状态接口中的缺口统计可能随数据规模增加成本,应控制调用频率。
## 7. 历史表安全清理
仅在 `rental.enabled=true` 且内置历史服务开启时加载清理器。默认每天 **03:15 UTC** 执行,在线保留 **30天**,每个表每批最多500条,每网络每轮最多200批。订单、任务、链上交易、资金流水、结算、退款、回调和业务事件均不删除、不改状态。
### 升级与配置
旧环境先执行 `sql/rent_history_cleanup_upgrade.sql`,再更新后端JAR及完整lib目录并重启。脚本通过 `information_schema` 判断列和索引是否存在,可重复执行,只增加 `rent_history_cursor.cleanup_owner`、`cleanup_until` 及基线表的 `(network,block_height)` 清理索引。新环境初始化脚本已经包含这些字段和索引。这里未连接实际MySQL执行迁移。
```yaml
rental:
history:
cleanup:
enabled: true
cron: '0 15 3 * * ?' # 固定使用UTC
retention-days: 30
batch-size: 500
max-batches: 200
archive-directory: ./data/rental-history-archive
```
对应环境变量:`RENT_HISTORY_CLEANUP_ENABLED`、`RENT_HISTORY_CLEANUP_CRON`、`RENT_HISTORY_RETENTION_DAYS`、`RENT_HISTORY_CLEANUP_BATCH_SIZE`、`RENT_HISTORY_CLEANUP_MAX_BATCHES`、`RENT_HISTORY_ARCHIVE_DIRECTORY`。保留期允许1至3650天,单表批量1至1000条,批次数1至10000。超过单轮批次数的数据留到下次;积压较大时可调整批次或cron。
归档目录相对于服务进程工作目录解析,必须放在可写、支持同目录原子移动的持久存储上。多实例应使用统一备份的共享目录,或分别持久化并收集所有实例的归档目录;不要使用容器临时层。关闭cleanup开关只停止定时历史清理,原有确认成功/确认分叉的采样处理继续运行。
### 保留边界
每批获取数据库游标行锁并重新计算网络保护水位。默认从 `scanned_height - 10000` 开始保护最近重放窗口,再根据以下任务对应的最早存续基线向前扩大保护范围:
- 订单尚未终结、资金仍冻结、地址对占位未释放、回收未完成或租期未结束。
- 任务结果未知、尚未终结、链上执行占位未释放,或交易尚未明确确认/失败。
- 保留期内更新过的订单、任务或交易,即使已业务闭环,也保留其重放证据供近期核对。
使用任务冻结intent中的owner/receiver定位基线,不依赖后来可能换绑的钱包地址;相同地址对去重,每100个地址对批量查询。受保护任务缺失、intent损坏、基线不存在、网络/资源不匹配或保护任务超过单批100000条时,停止该网络删除并记录日志,不忽略异常继续删。一个长期悬挂订单可能保留整个网络的一段旧数据,这是有意采用的保守策略。
基线及其后的连续区块/事件均保留,不将 `UNKNOWN`、`MANUAL_REVIEW` 当作过期记录。未分配供应钱包的等待订单尚无旧证据依赖;已分配钱包却找不到对应任务的异常在途订单会阻止清理。
### 五张表的行为
| 表 | 清理规则 |
| --- | --- |
| rent_history_event | 仅删除保护水位之前、区块完整且链上时间/区块入库时间/事件入库时间均超过保留期的事件;先归档完整原始行 |
| rent_history_block | 仅删除水位之前且链上时间和入库时间都过期的完整区块;该块必须已无事件、无待确认采样。大区块的事件分批删完后,下批才删区块 |
| rent_history_anchor | 仅删除水位之前且入库已过期的检查点。已保护订单的基线不会删;已超出10000区块可复用窗口且无人依赖的旧地址对基线可退休,下次派单重新读取确认节点建立基线 |
| rent_history_sample | 清理器只处理与已确认归档的哈希及四个参数完全一致的冗余缓冲。未确认或冲突采样不按年龄删,仍由确认通道确认/判定分叉 |
| rent_history_cursor | 永久保留,扫描高度及哈希不重置;清理器仅维护自身租约 |
没有完整事件的区块、有冲突待确认采样的区块、刚补采的老区块都不会被误删。保留期只是最小保留条件,并非保证恰好只留30天。
### 归档、事务与并发
每批归档含格式版本、网络、截止时间、保护水位、游标快照及实际待删的四类完整记录。JSON先写 `.pending` 文件并强制落盘,再原子发布为带SHA-256摘要的唯一 `.json` 文件,重新校验摘要后才执行数据库删除;每批删除同事务提交。归档写入失败、校验失败、租约失效或SQL错误均回滚本批数据库变更;此前已提交的批次不回滚。
写盘后数据库回滚可能留下冗余归档,崩溃也可能留下 `.pending`;它们不是再次执行交易或自动恢复的指令。归档文件不会自动删除,需单独备份并按审计要求管理其保留期。恢复旧证据时应在隔离环境校验文件名中的SHA-256、按表主键去重后审计恢复,不能向历史表补入当前参数。在线证明接口不自动读取归档文件。
清理器有独立数据库租约,多实例仅一个清理器执行同一网络;扫描仍使用原租约。每批清理、证明数据库快照读取、基线写入及参数写入共用网络游标行锁,因此不会读到半删的重放链。所有链上RPC仍在该锁事务外执行;文件归档在受限批次内完成。日志记录网络、水位、各表数量、归档文件名和失败的安全定位摘要,不输出密钥或交易签名。
## 8. 代码与测试
| 文件 | 职责 |
| --- | --- |
| `ruoyi-system/.../rental/RentalHistoryService.java` | 最新状态夹读、暂存等待确认、哈希核对、不可变入库、网络租约、区块解析、关系重放、证明 |
| `ruoyi-system/.../rental/RentalHistoryCollector.java` | 独立后台线程、分网络轮询、关闭 |
| `ruoyi-system/.../rental/RentalHistoryCleaner.java` | 定时清理、独立租约、保护水位、分批删除 |
| `ruoyi-system/.../rental/RentalHistoryGuard.java` | 多实例共用的短事务网络保护锁 |
| `ruoyi-system/.../rental/RentalHistoryArchive.java` | 删除前写盘、原子发布和摘要校验 |
| `ruoyi-system/.../rental/RentalHistoryController.java` | 受保护的状态/证明查询 |
| `RentalChain.java` | 内置/外部证明选择,原链上核验保留 |
| `RentalTasks.java` | 派单前采集基线,完整证明写入evidence JSON |
| `ruoyi-system/src/test/.../rental/RentalHistoryTest.java` | H2真实DDL与SQL、可控RPC隔离测试 |
运行:
```shell
mvn -o -pl ruoyi-system -am test -Dtest=Rental*Test -Dsurefire.failIfNoSpecifiedTests=false
```
Windows PowerShell需要给含逗号的 `-Dtest=...` 参数加引号。H2不支持MySQL的UTC_TIMESTAMP,测试仅为该时钟函数注册等价UTC实现,不改变生产SQL。
本次JDK8租赁回归共162项全部通过,包含43项历史服务、23项清理、58项业务状态机测试,以及定价、权限、充值、提现等租赁测试。清理覆盖未知/人工核对/回收/冻结资金保护、近期闭环审计、分批大区块、重复运行、独立租约、归档失败、SQL失败回滚、租约过期、真实归档摘要及并发证明读取;完整业务DDL测试验证账户及流水保持不变。公共NILE确认关系接口先前只读探测返回HTTP200,不等同MySQL、固定RPC以及真实订单端到端验收;本次未执行数据库迁移或任何链上广播。
+175
View File
@@ -0,0 +1,175 @@
# 租赁模块三端实现与运行说明
地址上链扩展(2026-10-29):已加入ADDRESS_ONCHAIN订单、两个Agent的固定1TRX转账、USDT折价计费及原交易恢复。部署需执行 `sql/rent_address_onchain_migration.sql`,配置两网报价并由供应商显式授权;详见 [地址上链实现与部署](../rental-address-onchain.md)。公开网页文档路径 `/rental-api` 同步更新。
供应商/租赁账户首页现为统计图表与运行监控看板,不嵌入业务操作菜单;接口、指标口径和可选索引升级见[角色统计看板](role-dashboard.md)。
用户套餐绑定增量:核心表新增 rent_user_package,管理员授权具体套餐版本;应用按 user_id 选择已绑定套餐,报价/下单必须提交 network/resource_type 选择分类,禁止提交 package_id;每用户每网络每资源类型最多一个当前套餐。部署前执行增量表SQL并配置用户绑定,见 [用户套餐绑定与脚本](user-package-bindings.md)。历史订单和在途处理不受绑定变更影响。
本文对应当前工作区的 V2.2 实现。设计依据仍为 [schema-design.md](schema-design.md) 和 [rent_init.sql](../../sql/rent_init.sql)。代码交付不等于生产迁移或真实链上验收;本次没有修改现有数据库,没有执行任何真实广播。
## 1. 三端职责
| 端 | 入口 | 职责 |
| --- | --- | --- |
| Java 8 后端 | `ruoyi-system/.../rental` | 归属及权限、钱包控制权、固定套餐、冻结与不可变流水、任务调度、独立核验、回收、退款、人工结算、持久回调 |
| Vue 2 前端 | `usdt-ui/src/views/rental` | 商户/供应商工作台与运营操作;原16个管理菜单和3个用户菜单路径保留,复用业务组件 |
| 本地 Node.js Agent | `rent-agent/src` | 主动WSS连接、双向签名心跳、加密可靠日志、钱包本地限制、只构建签名一次、原交易恢复 |
| 本地 JavaFX Agent(替代实现) | `rent-agent-java/src` | JDK17 + JavaFX20.0.2,使用同一节点协议;桌面启停、广播确认、本地签名与原交易恢复 |
供应商可选择 Node.js 24 + TronWeb 6.0.4,或独立的 JDK17 + JavaFX20.0.2 桌面Agent。Java版安装、配置与验证见 [Java Agent README](../../../rent-agent-java/README.md),不依赖Node运行时,不修改示例JavaFX钱包程序,不要求供应商运行完整TRON节点。同一节点/钱包不能同时运行两种实现;原签名交易的本地存储结构不同,存在在途或未知任务时不能直接互换日志接管。
核心链路:商户下单冻结USDT → 后端按可信动态资源参数预留SUN → 推送冻结任务意图 → Agent先保存再ACK、复核后本地签名、原交易落盘后广播 → 云端独立核验 → 达标且未到期则扣款及记供应商净应收 → 到期按原SUN撤销 → 资源实际恢复后释放地址对占位。
生成器的 `/system/rentXxx` 接口已由 `RentalLegacyGuard` 拒绝,包括读取、导出及写入。这样既防止任意覆盖余额/状态,也防止旧凭证导出接口泄露密文。新页面使用 `/rental`,不要再调用旧CRUD。旧Service/Mapper保留作为已生成基础代码,业务链路不调用其任意修改方法。
### 角色配置与资金账户
角色编码、专属首页及完整接口授权 SQL 见 [角色首页与权限配置](role-permissions.md)。
| 角色 | 需要配置的业务主体 | 资金账户用途 |
| --- | --- | --- |
| 供应商(仅出租) | `rent_node`、节点凭证、本地 Agent 及 `rent_wallet`;无需 `rent_app` | 通过 `rent_account` 记录净待结算收入、退款冲正和结算 |
| 租赁用户(购买资源的商户) | `rent_app`;使用外部 API 时配置应用凭证 | 通过 `rent_account` 记录充值、可用余额、订单冻结和扣款 |
供应商无需手动创建或配置 `rent_account`:当前代码在调度选中供应商时,根据 `rent_node.user_id` 与订单网络自动创建或复用账户,并将其固定到订单的 `supplier_account_id`。这不意味着供应商不需要资金账户记录。
`rent_account` 是平台内部 USDT 账本账户,不是链上钱包,不需要配置私钥。每个用户在每个网络只有一个账户(`user_id + network` 唯一),不按应用或节点单独开立;同一用户可以同时出租和购买资源,共用对应网络的账户。NILE 和 MAINNET 的资金分别记账。完整角色与表关系见 [设计说明](schema-design.md)。
## 2. 数据库、菜单和后端配置
1. 新环境检查MySQL5.7.8+/8.0配置后执行 `sql/rent_init.sql`。已有旧表不能靠 `IF NOT EXISTS` 升级,必须按实际结构和在途数据编写增量迁移;本次未运行脚本。
2. 执行 `sql/rent_menu.sql` 创建租赁工作台、16个运营查询菜单及按钮权限,不自动向任何现有角色授权。通过若依角色管理分配商户、供应商、运营、退款申请人、独立财务审批人。
3. 使用 JDK8;在 Spring Boot 配置中包含 `rental` profile,载入 `application-rental.yml`。通过环境变量注入配置。默认 `RENT_ENABLED=false`,不开调度或节点Socket。
4. `RENT_MASTER_KEY` 必须为外部生成的32字节随机密钥的Base64。不要使用测试代码中的零值密钥,也不要把实际值提交到仓库。`RENT_MASTER_KEY_VERSION` 标识当前版本;当前运行实例必须保留解密历史Secret所需的相同主密钥。本实现不自动迁移主密钥版本,换主密钥前须另行完成离线重封装。
5. 配置 `RENT_NILE_RPC` / `RENT_MAINNET_RPC`、可选 `RENT_RPC_KEY`,以及每个网络的租赁USDT收款地址 `RENT_NILE_DEPOSIT` / `RENT_MAINNET_DEPOSIT`。USDT合约地址复用 `TronServiceProvider.getServiceForNetwork()`,不随支付全局网络切换。
6. 单实例Socket入口启用 `RENT_ENABLED=true`,通过HTTPS反向代理暴露 `/node/v1/socket`。代理保留WebSocket Upgrade,读超时大于45秒,对API及Socket入口设置连接数和速率限制。首版不承诺跨实例Socket路由;数据库持久事实可以多worker争抢,但节点WSS须固定一个入口实例。
可在本地用以下命令生成随机主密钥,仅把输出放入安全配置:
```shell
node -e "console.log(require('node:crypto').randomBytes(32).toString('base64'))"
```
租赁 `DATETIME(3)` 使用服务器/JVM本地时间,MySQL连接会话同步采用LOCAL,说明见[时间修复与部署](../timezone-fix.md)。本次不处理历史数据,不需要迁移确认开关。租赁HTTP响应把BIGINT和USDT转为字符串,防止浏览器浮点数丢精度;时间仍输出UTC ISO8601真实时间点,响应设置 `Cache-Control: no-store`。
## 3. 首次开通流程
1. 商户进入租赁工作台,创建应用,开通所需网络的租赁账户,在凭证页为本人APP签发Secret并立即安全保存。充值发到配置的租赁收款地址后,运营填写原USDT交易哈希、Transfer日志序号及精确金额审核;后端独立校验合约、接收地址、金额及确认深度,同一日志不能给不同用户重复入账。
2. 供应商注册节点,运营用不同账号审核通过;供应商为本人NODE创建凭证。节点审核与连接在线是两个不同状态。
3. 供应商绑定公开钱包,TronLink切换到该地址,点击一次性消息验证。挑战绑定平台域、用户、钱包、网络、nonce及有效期;后端恢复地址并原子消费挑战。此步骤不广播、不收取验证费。
4. 运营审核钱包;供应商分别开启能量/带宽出租并设置SUN本金留存。平台不接受钱包私钥。Agent首版只支持owner权限单签,不自动处理多签或自定义active权限;不满足时拒绝执行。
5. 运营新增不可变套餐版本,显式填写正数量、正冗余、租期、售价、供应商毛收入、0至100之间的正手续费率及正费用预算,然后审核上架。改价新增版本,不覆盖旧订单快照。
6. Agent启动且同步完成后节点才ONLINE;对应钱包可信快照有效时才可调度。
## 4. Agent安装与恢复
在 `rent-agent` 目录执行:
```shell
npm ci --ignore-scripts
node --env-file=.env src/index.js
```
复制 `.env.example` 为本机 `.env` 并填写。`.env`、`data` 和 `node_modules` 已忽略提交。私钥只留在本地;日志密钥 `RENT_JOURNAL_KEY` 必须与云端主密钥、API Secret分离。填写本人 `RENT_NODE_ID`、`RENT_NODE_NO`、NODE凭证、网络RPC和本地额度。默认 `RENT_ALLOW_BROADCAST=false`,任务会明确拒绝为未构建;供应商在本地审核后才可改为true并重新启动。平台无法替本地开启广播。
`RENT_MAX_SUN`、`RENT_MAX_FEE_SUN` 为每笔上限;`RENT_ENERGY_ENABLED` / `RENT_BANDWIDTH_ENABLED` 是本地独立出租开关,默认false,需供应商明确开启。关闭某类出租不阻止原授权本金回收,但全局广播关闭仍不广播。两个资源各有留存本金;另有 `RENT_TRX_RETAIN_SUN` 费用留存。Agent查询实时 `getTransactionFee`,用600字节保守预算检查原生交易费用,构建后再次限制实际原文和签名预留不超过预算字节;这是本地预算策略,不是协议的 `fee_limit` 硬上限。SDK无法精确表示的整数超过 `Number.MAX_SAFE_INTEGER` 时直接拒绝,绝不转成不精确数字广播。
本地 `journal.gcm` 保存完整原任务、原签名交易、txId和待ACK事件,使用AES-256-GCM;写临时文件、fsync、原子rename,成功后才ACK或广播。重复任务相同内容只恢复,内容变化拒绝。广播超时、断线、租约过期或重启均不能构造新交易;过期原交易只查询。无已保存交易的BUILDING/UNKNOWN保持隔离,不重新构建。未知不等于失败。
同一数据目录用 `agent.lock` 排除并发进程。正常关闭会先停止接单并等待RPC归档,再释放锁。崩溃保留锁:先确认原进程已退出、只有一套Agent使用该钱包、备份整个加密数据目录,再人工移除该精确锁文件后重启。不得删除日志“重置”任务。丢失日志密钥、签名交易或原Secret时停止接单并核对云端与链上,不按空记录重新执行。
凭证轮换时通过 `RENT_OLD_KEYS` 保留仍有在途任务的旧 `api_key:secret` JSON映射。云端新连接使用当前ACTIVE凭证,历史任务内层意图使用原凭证验签。REVOKED不再投递;历史链上独立核验继续进行。
## 5. HTTP业务接口
所有 `/rental` 接口使用若依JWT及明确 `rent:*` 权限,用户归属由服务端关联查询决定。分页每页50条,页码从1开始。
| 接口 | 功能 |
| --- | --- |
| `GET /rental/mine/{resource}` | 本人的应用、节点、钱包、订单、资金及公开上架套餐 |
| `GET /rental/manage/{resource}` | 运营16表脱敏查询,不返回Secret、签名或挑战 |
| `POST /rental/register/{app,node,wallet}` | 创建本人业务主体 |
| `POST /rental/credential/issue`、`/{id}/revoke` | 凭证轮换、吊销;Secret仅一次展示 |
| `POST /rental/wallet/{id}/{challenge,prove,policy}` | 钱包挑战、TronLink验证和出租策略 |
| `POST /rental/package`、`/status/{resource}/{id}` | 套餐版本创建及运营审核启停 |
| `POST /rental/account/open`、`/account/{id}/topup` | 开户及独立校验充值 |
| `POST /rental/order`、`/order/{id}/cancel` | 订单幂等冻结及未派单取消 |
| `POST /rental/order/{id}/refund`、`/refund/{id}/review` | 退款申请、不同账号审批和内部入账 |
| `POST /rental/settlement` | 按同一供应商同网络的订单净来源建立结算 |
| `POST /rental/settlement/{id}/{approve,reject,pay,unknown,confirm}` | 独立审批、原付款授权及核验;PAYING/UNKNOWN不可拒绝释放 |
| `POST /rental/wallet/{id}/refresh`、`/task/{id}/verify` | 可信快照和原交易独立核验 |
| `POST /rental/task/{id}/attach` | 只给原在途任务补充已独立核对的原交易哈希 |
| `POST /rental/order/{id}/resolve` | 仅MANUAL_REVIEW、HELD且回收DONE的异常单可解冻终结 |
| `POST /rental/webhook/{id}/retry` | 人工修正配置后重新投递DEAD事件,原编号和业务内容不变 |
| `GET /rental/reconcile?afterId=0` | 分批核对余额与不可变流水、钱包SUN预留与任务占用 |
每天UTC02:00自动进行账账核对,发现差异只告警,不直接修复余额或释放未知本金。运营可在资金账户/流水页主动执行完整分页核对。
新结算单使用 `INTERNAL_TRANSFER` 模式,其他管理员 `approve` 后将供应商净收益从待结算转入可用余额,状态为 `SETTLED`,不执行链上付款。对外付款统一通过提现处理。`LEGACY_PAYOUT` 仅兼容升级前付款单,保留原授权和交易核验,不转入内部余额。见 `../rental-income-settlement.md`。
## 6. 外部商户签名接口
资源租赁:`POST /api/rental/v1/quote`、`create`、`query`、`packages`。地址上链:`POST /api/rental/v1/address-onchain/quote`、`create`、`query`;独立路径确定ADDRESS_ONCHAIN类型,无需提交order_type,原资源接口不再接收地址上链订单。仅JSON,最多512KiB(524,288字节),不允许查询串。请求头为 `X-Rent-Key`、`X-Rent-Timestamp`(Unix毫秒)、`X-Rent-Nonce`、`X-Rent-Signature`。认证窗口前后60秒,nonce保留180秒后可清理。签名必须使用服务端实际完整路径,包含address-onchain子路径,不能沿用资源接口签名。
签名原文用换行连接,末尾不加换行:
```text
RENT_HMAC_SHA256_V1
API
api_key
timestamp
nonce
POST
/api/rental/v1/create
SHA256(实际UTF-8请求体)的小写十六进制
```
使用Secret做HMAC-SHA256,输出小写64位十六进制。scope为API/NODE/TASK/WEBHOOK,不能互换;不共用支付MD5。下单必填字段:`network`、`resource_type`、`merchant_order_no`、`receiver_address`,可选 `notify_url`、`duration_seconds`、`resource_quantity`、`expected_amount`;禁止提交 `package_id`,由服务端按分类解析套餐。APP和用户从凭证推导。`query` 用 `merchant_order_no`;`packages` 用 `network`。
跨语言固定向量:Secret=`test-secret`、scope=`API`、key=`test-key`、timestamp=`1700000000123`、nonce=`abcdefghijklmnop`、method=`POST`、path=`/api/rental/v1/create`、body=`{"amount":"1.000000"}`,结果为 `47241a34f0813881384317eafbfc068dc9f7c6061a8fe269cb815e7820d48430`。此值仅用于测试,不是有效运行凭证。
回调使用相同请求头但scope=WEBHOOK;支持HTTPS 443及内网HTTP(可自定义有效端口)、无用户信息/fragment/query,实际DNS连接地址逐个检查,不跟随重定向。`rental.webhook.allow-private-network`通过`RENT_WEBHOOK_ALLOW_PRIVATE_NETWORK`控制,当前默认true,允许IPv4私网和IPv6 ULA;false恢复仅公网,回环、链路本地等特殊目标始终拒绝。HTTPS证书校验保持开启。HTTP200且正文精确为 `ok` 才确认。最多10次,失败指数退避,终止为DEAD;每次新timestamp/nonce,业务event_no、payload和订单事件序号不变。商户按event_no去重并按序号识别乱序。无回调地址的事件直接确认,不发HTTP。
## 7. WSS协议与历史资源证明
通道 `/node/v1/socket`:CHALLENGE → AUTH → 签名AUTH_OK → 分页SYNC_STATE/SYNC_ACK → ONLINE。未同步不得接新单。外层帧的 `body` 是原始JSON字符串;信封含 `api_key,timestamp,nonce,body,signature`,NODE域、method=FRAME、path固定。body含type、方向、session_id、session_epoch、sequence、message_id、payload。双方向序号各自从1递增。每15秒签名PING/PONG,45秒超时断开,nonce重复或旧会话帧拒绝。
Java Agent启动地址校验:签名 `AUTH_OK.payload` 增加 `node_id`(字符串)、`network` 和 `verified_wallets`(`[{address,network}]`)。地址仅从当前节点 `rent_wallet.ownership_verified_at IS NOT NULL` 的记录读取;网络来自钱包记录,节点表本身没有网络字段。Java Agent先验证帧签名及挑战,再要求已认证地址恰好一个,节点ID、网络及本地私钥派生地址全部一致,才发送 `SYNC_STATE`。缺字段、未认证或不一致时禁止上线,撤销本次广播授权并停止自动重连,界面显示固定错误说明;需停止并修正配置或换绑认证后重启。该响应不包含私钥,不需数据库迁移;先升级服务端再升级Java Agent,旧服务端缺字段时新Agent拒绝降级放行。
TASK_PUSH中保留稳定delivery_message_id、原api_key/intent/timestamp/nonce/signature。TASK域、method=PUSH、path=`/node/v1/task`。任务intent为按键排序的紧凑JSON;任务字段只含ASCII字符串/布尔值。MySQL JSON规范化后由后端按同一规则重建,再传输原意图,不改变授权内容。
Agent事件先落本地可靠队列,云端同事务以 `NODE:nodeId:eventId` 去重后RESULT_ACK。ACK只说明持久接收,ACCEPTED只说明本地接受,BUILT/BROADCASTED/RESULT只说明执行线索。云端另查交易合约、owner/receiver、网络、资源类型、非锁定、SUN、回执、确认深度和关系,不能凭节点消息扣款。
普通TRON RPC没有任意确认区块的资源历史查询。内置采集/证明与云端同进程部署:执行 `sql/rent_history_init.sql` 创建4张历史证据表及1张待确认缓冲表(升级可重复执行),设置 `RENT_HISTORY_EMBEDDED_ENABLED=true` 和 `RENT_HISTORY_NETWORKS=NILE`。全局参数采样、确认归档与事件扫描异步独立,复用钱包本次一致性夹读及地址对连续事件基线;订单/任务提交后立即异步派单/推送,持久扫描兜底。交付核验直接调用Java服务,不需要填写 `RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY`。表设计、接口、配置、采集缺口与部署详见 [内置历史证明服务](history-service.md)。
历史清理默认每天03:15 UTC执行,保留30天并保护未闭环订单的连续证据,先归档后分批删除。已有历史库还需执行 `sql/rent_history_cleanup_upgrade.sql`,为游标增加独立清理租约及基线表清理索引;配置持久归档目录后部署,订单与资金表不清理。
外部服务模式继续兼容:内置关闭时,`RENT_NILE_HISTORY` / `RENT_MAINNET_HISTORY` 可以指向运营部署、独立于供应商的可信历史证明服务。后端向 `/rental/resource-proof` POST `network,tx_id,block_height,owner,receiver,resource_type`,服务必须基于该实际区块状态返回:
```json
{"tx_id":"原交易哈希","block_height":123,"baseline_sun":0,"after_sun":1300000000,"total_limit":60000000,"total_weight":1000000}
```
示例参数不代表当前链。内置实现从启用时开始保存真实确认状态,不会补造上线前或停机期间漏采的全网参数。**未配置历史服务,或内置服务缺少该高度参数/派单前基线时,可以确认真实委托,但订单转MANUAL_REVIEW、保留HELD资金并按原SUN回收,不自动记SUCCESS或供应商收入。** 内置区块尚未采集到交易高度则保持待核验并重试。交易已确认而交付不足、核验时已过期,同样人工隔离。可在确认回收DONE后通过受保护的resolve解冻。外部擅自变更委托关系会告警并转人工,不能任意释放关系占位。
## 节点钱包管理
供应商节点详情提供单钱包卡片、TronLink 所有权认证、出租设置和换绑。
`POST /rental/register/wallet` 在节点行锁内限制每节点一个地址;已有历史多钱包不会自动清理,页面提示联系管理员处理。
`GET /rental/node/{id}` 仅返回本人节点及其钱包展示字段,不受全局列表前50条分页限制。
出租设置复用 `POST /rental/wallet/{id}/policy`,可独立开启能量、带宽出租并设置留存本金;SUN 使用整数串传递,1 TRX = 1,000,000 SUN。
开启出租不代替认证、审核、资源快照、本地授权和节点在线检查。
`POST /rental/wallet/{id}/rebind` 使用钱包绑定权限,并在事务中检查归属、单钱包、节点离线和资源预留。
只允许相同网络的新 TRON 地址;新地址不能已被同网络其他记录绑定。
换绑清空原所有权认证、链上权限、出租开关/留存策略和资源快照,恢复待审核状态;必须更新本地 Agent 配置并重新认证、审核和配置出租。
存在任意历史或在途订单/任务的钱包禁止原地换绑,请为新地址注册新节点,避免改变历史资源所有者含义。
## 8. 验证与边界
具体命令、结果及尚未验收的外部条件见 [validation-implementation.md](validation-implementation.md)。
已提供后端 `RentalBusinessTest` 与 Agent `test/agent.test.js`,分别覆盖资金/并发/状态机/协议和本地加密持久化/原交易恢复。H2测试从权威16表DDL只替换H2不支持的存储及JSON声明,保留字段与唯一键;不等同真实MySQL并发验收。Socket测试使用可控会话,不等同公网TLS/半开连接验收。前端构建输出到独立目录,不覆盖现有dist。
未接入项目数据库、实际部署WSS、真实TronLink浏览器签名、NILE委托/回收或历史证明服务进行联调;这些必须在专用测试环境验收后再启用业务。本实现不自动开放主网广播、不自动建设历史节点、不自动出金。
@@ -0,0 +1,65 @@
# 租赁API下单与商户回调示例
## 首页立即租赁
PROXY_ACCOUNT 的“我的套餐”点击立即租赁,填写资源接收地址、应用 API Key / Secret、租期(秒)、API对接基地址、可选回调地址、商户订单号。先获取预计费用,再点击确认费用并租赁。移除了该按钮对后台 `rent:order:create` 权限的依赖,实际下单仍由应用凭证验签和所属用户的套餐绑定、账户余额共同校验。
Secret只在弹窗内存中用于签名,关闭弹窗清除,不写浏览器缓存、不作为请求参数发送。浏览器签名使用Web Crypto,需要HTTPS页面或localhost。应用Secret只在签发时展示,遗失时请重新签发。不要填节点凭证。所填凭证决定实际应用和扣费用户;填写当前账户自己的应用凭证。
默认API基地址为当前前端配置的代理前缀,例如 `/prod-api`。远程对接填写 `https://rent.example.com`,不含 `/api/rental/v1/create`;远程服务需允许浏览器当前来源、POST和X-Rent-*请求头。反向代理应将前缀去除,使服务端看到原始 `/api/rental/v1/quote` 或 `/api/rental/v1/create` 路径。时钟需同步。
## 报价与计费
`POST /api/rental/v1/quote` 和 `create` 都要求 `X-Rent-Key`、`X-Rent-Timestamp`(毫秒)、`X-Rent-Nonce`、`X-Rent-Signature`。HMAC协议保持不变:API域、POST、服务端实际路径、原始UTF-8请求体SHA256,按换行连接后HMAC-SHA256,小写十六进制。签名后不得重新序列化JSON。
示例请求体(两接口共用,create额外带expected_amount):
```json
{
"network": "NILE",
"resource_type": "ENERGY",
"duration_seconds": 7200,
"receiver_address": "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf",
"merchant_order_no": "WEB_UNIQUE_ORDER_NO",
"notify_url": "https://merchant.example.com/api/rental/v1/demo/callback/async"
}
```
network和resource_type为报价与下单必填项,服务端按所属用户匹配分类套餐;禁止提交package_id。弹窗可切换网络、资源类型,切换后必须重新报价。
报价返回 `amount`(精确十进制字符串)、`currency=USDT`、`duration_seconds`、`network`、`resource_quantity`。确认下单传 `expected_amount`,服务端重新计算并比较,价格变更则拒绝。所有费用使用BigDecimal。
租期为套餐基础租期的1至720个整数倍,总售价、供应商毛收入同比例增加,资源数量同步按租期倍数增加。例如基础3600秒、售价3USDT,7200秒为6USDT。该规则同时作用于登录入口及外部API;不传租期继续使用基础租期,兼容现有调用。实际资源回收按订单租期快照执行。请求超时后使用相同商户单号及原参数重试;不要更换单号重复扣费。
回调地址只允许公网HTTPS、443端口、无查询参数,不允许内网或回环目标。留空沿用应用默认地址。订单创建成功是同步API响应,不代表链上已经交付;以查询API及已验签异步通知为准。当前协议没有浏览器return_url跳转回调。
## 同步、异步验签Controller
实现:`RentalCallbackDemoController`,默认关闭,仅演示商户接收端。部署于同一云端项目中,或连同验签工具、事务仓储迁入商户项目。
先执行 `sql/rent_callback_demo.sql` 创建独立演示收件箱;租赁基础表(含rent_nonce)仍需先初始化。然后通过外部配置启用,凭证必须是该应用当前ACTIVE凭证:
```yaml
rental:
callback-demo:
enabled: true
api-key: ${RENT_DEMO_API_KEY:}
api-secret: ${RENT_DEMO_API_SECRET:}
```
接口使用既有 `/api/rental/v1/**` 公开入口,但每个请求都验证WEBHOOK域签名、Key、60秒时间窗、随机数和原始请求体;没有关闭认证。不要在日志输出Secret、签名或请求体。轮换应用凭证后同步更新接收端凭证;生产建议支持受控的多Key过渡。
| 接口 | 处理流程 | 成功确认 |
| --- | --- | --- |
| POST /api/rental/v1/demo/callback/sync | 验签→随机数防重放→event_no去重→同步事务记录处理结果 | 事务提交后返回HTTP 200、纯文本ok |
| POST /api/rental/v1/demo/callback/async | 验签→随机数防重放→event_no去重→持久化待处理收件箱 | 持久化提交后返回HTTP 200、纯文本ok;每3秒扫描事务处理 |
无效签名返回400,持久化失败返回503,不返回ok。并发事件冲突会回滚并让云端用新随机数重投;重复事件内容一致则确认,内容冲突拒绝。同一HTTP报文重放不通过随机数唯一约束。异步处理不使用易丢失的内存队列,重启后扫描继续。
示例业务仅记录验签事件/消费标记,不执行真实商户履约或入账。接入实际业务时,应保存所需通知字段,在同一事务中按本地订单号及event_no更新业务,并利用order_event_sequence防止乱序状态回退;外部副作用使用事务发件箱。不要照搬演示标记替代实际业务处理。
租赁云端仅在回调HTTP 200且正文严格为`ok`时确认,失败按既有任务重试,达到上限保留DEAD记录供处理。应用当前有效凭证用于签名,WEBHOOK域与API域严格隔离。
## 验证
JDK8下64项租赁测试通过,覆盖已签名报价/下单、报价不扣费、租期计费、冻结资金、幂等重试、价格变化拒绝,以及回调原文/路径/域/时间窗验签、落库确认、重复事件及异步消费。前端ESLint、Vue模板/CSS解析、独立HMAC及UTF8签名校验通过,staging完整构建成功;保留其他模块已有导出缺失和资源体积警告。实际浏览器、公网回调、数据库迁移及链上交付尚需部署后联调。
+24
View File
@@ -0,0 +1,24 @@
# 立即租赁资源调整
我的套餐 → 立即租赁支持选择基础资源数量、租赁时长、接收地址及回调地址,再获取报价,确认费用后下单。修改任一参数会清除旧报价。
`quote`、`create` 新增可选参数 `resource_quantity`:表示选择的基础资源,省略采用套餐基础资源,必须是套餐基础资源的1~720整数倍。网络、资源类型不允许脱离绑定套餐切换。
## DURATION
资源倍数 = 请求基础资源 / 套餐基础资源;租期倍数 = 请求租期 / 套餐基础租期。
最终资源 = 套餐基础资源 × 资源倍数 × 租期倍数。
费用及供应商毛收入 = 对应套餐基础金额 × 资源倍数 × 租期倍数。
例如套餐65000 Energy、3600秒、3 USDT,请求resource_quantity=130000、duration_seconds=7200,最终资源260000 Energy,费用12 USDT。
## PER_ORDER
资源数量和租期固定,不允许提高资源数量或延长租期后按原固定价格下单。
## 结果与重试
quote返回requested_resource_quantity(选择的基础资源)、resource_quantity(最终资源)、billing_mode和精确amount字符串。create/query返回的resource_quantity为最终资源。订单资源快照、交付目标和供应商收入均使用服务端计费结果。
create推荐带expected_amount=quote.amount。修改参数必须重新报价确认。同一商户单号重试时resource_quantity的数值及是否提交必须保持一致;改变数量不会覆盖原订单或重复冻结资金。订单成功后在我的订单查看履约结果,失败或未知结果保持原单号查询。
+48
View File
@@ -0,0 +1,48 @@
# 供应商与租赁账户首页看板
两个角色首页只展示统计、图表和监控,不再嵌入节点/套餐操作列表,不新增内部菜单。业务管理统一使用框架菜单。供应商使用绿色点缀,租赁账户使用蓝色点缀;窄屏自动单列布局,图表跟随框架侧栏和窗口尺寸变化。
## 查询与隔离
`GET /rental/dashboard/{persona}?network=NILE&days=14`,persona仅允许supplier/account;days仅支持7、14、30,network仅支持NILE/MAINNET。复用rent:portal:view权限,不需要新增菜单授权。user_id始终来自当前登录会话,客户端不能指定他人身份;管理员也仅展示本人数据。persona仅切换本人供应/租赁视角,不授予操作权限。
服务使用只读REPEATABLE_READ事务聚合,不调用TRON、不创建账户、不调整业务状态。图表统计全部匹配记录,不使用通用列表的50条分页结果。没有业务数据时展示0和空图,没有订单时成功率展示“—”;未开户显示“未开通”,不会自动开户。
## 时间与网络
统计窗口为UTC今天及此前days-1天,截止本次查询时刻。前端明确标注UTC,日期零补齐。网络筛选隔离订单、账本、余额、钱包、任务及回调;应用和节点本身没有network字段,按本人跨网络展示并明确标注。
“核心区间订单/状态分布/订单趋势/资源租赁量”按订单创建日及当前状态聚合,因此历史订单核验后曲线可能变化。“净应收/净消费”按实际账本记账日统计,与订单创建日口径不同。余额、监控、最近订单均为当前状态,不受日期筛选限制;最近订单最多6条,节点健康最多8条且离线优先。
## 供应商
| 区域 | 口径 |
| --- | --- |
| 区间履约订单 | supplier_user_id等于当前登录用户,所选网络的已分配订单 |
| 区间成功率 | 当前SUCCESS数量/区间全部订单,含处理中/失败/取消的分母 |
| 净应收及趋势 | 本人所选网络账本SUPPLIER_EARN、SUPPLIER_FEE、REVERSAL的delta_supplier_pending合计,扣手续费及冲正,不把SETTLE转出当收入 |
| 待结算及余额 | 当前rent_account余额快照,与区间净应收不同 |
| 在线节点 | connection_status=ONLINE且heartbeat_expires_at晚于查询时刻;在线与审核/接单状态分别展示 |
| 有效快照资源 | 所选网络、ACTIVE且已验证钱包、快照未过期、快照区块不低于最小屏障,按资源启用开关分别汇总max(0,available) |
| 资源监控 | 非有效快照钱包、UNKNOWN任务、SUCCESS到期未DONE回收、履约或回收MANUAL_REVIEW订单 |
| 结算处理中 | PENDING、APPROVED、PAYING、UNKNOWN结算单数量 |
有效快照资源包含节点可能已离线的钱包,表示可信投影中的资源,不等于当前可调度容量;最终执行仍检查心跳、资源保留、额度和链上状态。能量Energy与带宽bytes绝不相加。
## 租赁账户
订单仅沿rent_order.app_id→rent_app.user_id归属查询,不与同用户供应商订单混合。净消费为CHARGE的-delta_frozen减REFUND的delta_available,不包含HOLD/RELEASE;退款来自早期订单时本期净消费可能为负。金额统一BigDecimal,响应返回6位十进制字符串,卡片按字符串展示;图表坐标使用近似数值,不用于账务计算。
当前租赁中为SUCCESS且服务未到期、回收未DONE;处理中为WAITING/EXECUTING/VERIFYING。人工核对包含履约或回收MANUAL_REVIEW。回调沿本人应用订单归属,DEAD为重试耗尽,PENDING/SENDING为待确认。应用启用状态、有效APP凭证数量、当前网络下的能量与带宽套餐分别展示名称和上架状态,绝不返回Secret或签名;不读取或冒充其他网络的套餐。
## 刷新与部署
默认每30秒刷新,可关闭并手动刷新。隐藏页面或离开缓存标签时暂停轮询,重新显示时刷新;网络/天数/角色切换使旧响应失效,防止串图。刷新失败保留上次成功数据及其更新时间,并展示错误提示;切换筛选失败不显示旧筛选数据。
不需要新增业务表或修改字段。全量初始化SQL已包含供应商订单、账户记账日期的索引;旧库可在维护窗口执行`sql/rent_dashboard_indexes.sql`增加两个只读看板索引,脚本可重复执行。未自动执行生产数据库DDL。
## 验证记录
JDK8下68项租赁测试通过,新增看板用例覆盖用户/角色/网络隔离、全量聚合、日期补齐、账务口径、心跳有效期、过期快照、资源非负、跨期退款负消费及历史监控告警。前端ESLint、Vue模板/CSS解析及staging完整构建通过,原有无关模块导出与包体积警告保留。
当前组件使用合成数据在Chrome渲染,供应商与租赁账户1440px桌面、租赁账户390px移动视口均通过三图渲染和无横向溢出检查,已人工查看预览;这不等同实际账号/数据库联调。未执行项目数据库DDL、RPC或真实广播。
+50
View File
@@ -0,0 +1,50 @@
# 供应商与租赁账户:首页及接口权限
角色编码严格区分大小写:供应商为 `PROXY_SUPPLIER`,购买资源的租赁账户为 `PROXY_ACCOUNT`。登录后的 `/index` 根据角色展示首页,同时拥有两种角色时可切换;其他用户保留支付首页。菜单入口分别为 `/rental/supplier`、`/rental/account-home`。
## 安装 SQL
先执行 [rent_menu.sql](../../sql/rent_menu.sql),再执行 [rent_role_permissions.sql](../../sql/rent_role_permissions.sql)。后者包含角色、首页菜单、细分按钮权限和 `sys_role_menu` 关联插入,可重复执行,不给任何用户自动绑定角色。请通过若依用户管理分配角色,重新登录以刷新权限。
脚本保留原角色状态、已有授权及用户绑定,不自动恢复停用/软删除角色。已有角色若含运营或历史通用注册权限,应通过角色管理复核,插入脚本不会删除原授权。脚本末尾提供实际授权查询。
## 角色权限及对应接口
| 权限 | 接口 | 供应商 | 租赁账户 |
| --- | --- | --- | --- |
| `rent:supplier:home` | 供应商首页菜单(无独立HTTP统计接口) | 是 | 否 |
| `rent:account:home` | 租赁账户首页菜单(无独立HTTP统计接口) | 否 | 是 |
| `rent:portal:view` | `GET /rental/mine/{resource}?page=1` | 是 | 是 |
| `rent:node:create` | `POST /rental/register/node` | 是 | 否 |
| `rent:wallet:create` | `POST /rental/register/wallet` | 是 | 否 |
| `rent:wallet:bind` | `POST /rental/wallet/{id}/challenge`、`prove`、`policy` | 是 | 否 |
| `rent:app:create` | `POST /rental/register/app` | 否 | 是 |
| `rent:account:open` | `POST /rental/account/open` | 是 | 是 |
| `rent:credential:issue` | `POST /rental/credential/issue`、`/credential/{id}/revoke` | 是 | 是 |
| `rent:order:create` | `POST /rental/order`、`/order/{id}/cancel` | 否 | 是 |
查询权限覆盖本人关联记录,仍由服务端检查归属;供应节点和应用凭证也只能操作本人主体。角色首页按业务侧重点展示不同标签,查询返回分页实际记录,不把最近50条伪装成全量统计。
供应商首页包含节点、钱包、任务、履约订单、收入账户、流水、结算记录及凭证。本人资金账户页按所选网络展示单个账户详情,不再展示账户列表;没有账户时引导创建。供应商可主动开通账户,派单时仍会自动创建或复用,不需要商户应用。租赁账户首页包含套餐、订单、应用、账户、流水、退款记录及凭证。
一个供应商在同一网络对应一个账户,主网和测试网独立,不能合并余额。开户接口从登录态取得用户ID,以 `user_id + network` 唯一约束和幂等插入避免重复创建。页面默认主网,可切换NILE;加载失败时提示重试,不将请求失败误判为没有账户。运营全体账户管理页继续保留列表。
已有部署需执行 [供应商开户增量授权](../../sql/rent_supplier_account_permission.sql),或重新执行更新后的 `rent_role_permissions.sql`,再重新登录;未获开户权限时页面提示联系管理员。新授权仅能开通本人零余额账户,不能设置余额或为他人开户。
两个角色均不授予 `rent:manage:*`、`rent:account:topup`、`rent:refund:create`、`rent:refund:approve`、`rent:settlement:create`、`rent:settlement:approve`、`rent:package:edit`。充值审核、退款申请/审批、结算申请/审批及付款由独立运营财务角色处理。外部商户API与Agent WSS分别使用APP/NODE HMAC凭证,不使用若依菜单权限替代协议认证。
内置历史服务复用运营 `rent:manage:audit` 权限,保护 `GET /rental/history/status` 和 `POST /rental/resource-proof`。供应商、租赁用户不授予此权限,不提供历史表普通CRUD;自动交付核验使用进程内部调用,无需开放匿名证明接口。见 [历史服务部署说明](history-service.md)。
旧 `rent:portal:register` 保留兼容既有运营配置;新角色脚本不授予此宽权限,前端根据细分权限显示创建按钮。未执行本脚本或未获 `rent:portal:view` 时,首页提示联系管理员,不调用支付统计接口。
## 本次验证
供应商通过旧 `system/rentNode/index` 菜单进入时,页面自动使用本人节点视图,提供“注册供应节点”;运营仍使用全体审核列表。注册填写最长100字符节点名称,调用 `POST /rental/register/node`,后端生成节点编号、绑定当前登录用户并设为PENDING。审核通过后再绑定钱包、签发NODE凭证并连接Agent。无 `rent:node:create`(或兼容注册权限)时显示授权提示;可重新执行 `rent_role_permissions.sql` 补齐角色授权并重新登录,无需新增业务接口或修改表结构。
供应商本人资金账户详情新增“Agent API 凭证”区域:选择本人供应节点,生成或轮换NODE凭证。复用 `POST /rental/credential/issue`,要求 `rent:credential:issue`,服务端继续校验节点归属;不在 `rent_account` 增加Secret字段。凭证属于节点,不随资金账户网络切换。无节点时引导先注册节点,无权限时提示管理员授权。
生成前提示旧凭证转为VERIFY_ONLY;生成后弹窗仅本次展示API_KEY/API_SECRET,支持分别复制及复制包含节点ID、编号的本地Agent配置,关闭确认后清空组件内存。Secret不写浏览器持久存储,不支持历史查看;轮换时用户需保留旧凭证到本机RENT_OLD_KEYS。复制使用浏览器安全剪贴板,不支持时提示手动复制。
JDK8下租赁业务23项测试通过;新增2项权限测试从真实控制器注解读取并执行SpEL,验证应用、节点、钱包创建权限隔离及旧权限兼容。新页面ESLint通过,生产构建通过。构建仍提示其他模块既有的3处API导出缺失、Browserslist数据过旧及资源体积警告,未将其扩大为本次修改范围。
未对真实数据库执行权限SQL,未绑定实际用户角色,尚需部署环境验证登录后的菜单及页面操作。数据库权限更新后应重新登录,避免使用旧会话权限。
+327
View File
@@ -0,0 +1,327 @@
# 能量/带宽出租表结构与业务流程 V2.2
2026-10-29扩展:新增地址上链订单ADDRESS_ONCHAIN,供应商固定转1TRX,用户USDT账户承担本金折价及服务费;复用订单、任务、交易及账务,新增字段和节点能力见 [地址上链完整设计与实现](../rental-address-onchain.md)。该类型不绑定套餐、不做资源换算、无租期及回收;原有资源租赁规则保持本基线。
资金账户新增可用USDT提现:申请冻结、后台/Telegram审核、管理员Hash核验及链上监听自动到账,完整表、状态、配置及部署见 [租赁资金账户提现](../rental-withdraw.md)。提现不保存付款私钥、不自动广播,所有到账均以已确认USDT Transfer为依据。
2026-10-25增量:新增第17张表 rent_user_package,按系统用户+网络+资源类型绑定当前套餐;已有库先执行 sql/rent_user_package_scope.sql;下单从应用user_id确定授权,见 [用户套餐绑定](user-package-bindings.md)。以下16表描述为原设计基线。
状态:V2.2设计基线;当前已新增后端、Vue及本地Node.js Agent实现,运行配置、接口与验证边界见[三端实现说明](implementation.md)。未执行现有数据库迁移或真实链上广播。当前权威 DDL 为 [rent_init.sql](../../sql/rent_init.sql),共16张表;历史设计复核见[业务复核与修正说明](business-review-v2.2.md),逐表说明见[table-functional-flows.md](table-functional-flows.md)。下文“本次仅设计”描述设计审查阶段,不替代当前实现记录。
## 1. 简化范围和保留边界
本版采用以下明确设计假设:同时出租Energy和Bandwidth,固定套餐,一单一种资源、一个供应钱包,全额交付、单币种USDT内部记账;供应商自行质押并提供可委托本金,平台不替其质押。一个钱包首版只绑定一个Agent,Agent通过主动出站WSS长连接收取任务并上报,具有双向心跳和断线恢复,不再长轮询领取。套餐价格和供应商成本由运营预先配置,无独立报价流程。
登录、Google、用户、角色、菜单和按钮权限沿用若依sys_*体系,不增加成员/角色表。租赁应用、凭证、订单、资金和任务独立,不复用支付apps、orders、wallet_address或余额。通过现有TRON查询service获取链上事实,业务调度、交易执行和核验编排独立。
首版暂缓动态报价、多级代理佣金、自动续租、复杂供应商竞价、自动链上充值识别和自动出金。人工充值审核和供应商结算仍必须有依据、去重、余额流水及审计;未来需要这些功能时再增量扩展,不能把暂缓功能隐含进JSON自动执行。
保留供应商本地密钥、默认禁止广播、链上独立核验、订单幂等、原交易恢复、未知状态隔离、资金冻结、资源预留、到期回收、回调持久队列和不可变流水。
### 参与角色与应用、节点、资金账户
“租赁用户”指购买资源的商户;“供应商”指提供质押资源的一方。两种身份均依托若依 `sys_user`,同一用户可以同时承担两种角色。
| 表 | 仅出租资源的供应商 | 购买资源的租赁用户(商户) |
| --- | --- | --- |
| `rent_node` | 需要,代表供应节点并连接本地 Agent;通过 `user_id` 归属供应商 | 不需要;同时经营供应业务时才需要 |
| `rent_app` | 不需要;同时购买资源时才需要 | 需要,承载订单归属、应用 API 认证和回调 |
| `rent_account` | 需要,记录供应商待结算收入、退款冲正和结算 | 需要,记录充值余额、订单冻结和扣款 |
`rent_account` 是平台内部 USDT 账本账户,不是链上钱包,不存储私钥,也不按应用或节点分别开立。账户按 `user_id + network` 唯一;同一用户兼任商户和供应商时,共用同一网络下的账户,NILE 与 MAINNET 分开记账。
供应关系为 `sys_user → rent_node → rent_wallet`;供应钱包用于提供链上资源,本地 Agent 保管私钥。供应收入根据节点所属用户及订单网络定位 `rent_account`。当前实现在调度选中供应商时自动创建或复用该账户,因此供应商无需手动配置资金账户,但数据库仍须保留账户记录以完成收入及结算记账。不能将“不需要手动配置”理解为“不需要这张表”。
## 2. 16张表及职责
以下为业务核心16表。内置历史证明复用4张采集/审计证据表,另有1张 `rent_history_sample` 保存待确认参数,独立增量安装,详细字段及协作见 [内置历史服务表设计](history-service.md) 和 [历史DDL](../../sql/rent_history_init.sql)。按该业务核心口径合计21张,不修改原16表结构。待确认缓冲不用于直接结算,确认并核对哈希后提升至证据表。
| 表 | 作用 |
| --- | --- |
| rent_app | 独立商户应用,user_id关联sys_user |
| rent_credential | APP/NODE统一api_key与加密api_secret,轮换保留历史 |
| rent_nonce | HMAC认证域内防重放 |
| rent_node | 供应商节点、审核、心跳,直接关联供应商sys_user |
| rent_wallet | 公开钱包授权、能量/质押带宽可信快照、按资源类型隔离的可委托SUN与预留 |
| rent_package | 固定套餐版本、数量、时长、USDT售价、供应商应付及费用约束 |
| rent_account | 用户在某网络的可用USDT、冻结USDT及供应商待结算USDT |
| rent_order | 下单、价格快照、履约、退款累计、租期和回收调度 |
| rent_task | 委托/回收执行任务、重试历史、原子资源占用和持久队列 |
| rent_transaction | 任务唯一链上交易与回执、关系增量和独立核验 |
| rent_ledger | 不可变余额变更流水与业务幂等键 |
| rent_settlement | 人工供应商结算审核及付款证据 |
| rent_settlement_item | 每个订单的供应商应收只能结算一次 |
| rent_refund | 内部余额退款审批、业务幂等、费用承担及逐次退款来源 |
| rent_webhook | 订单事件回调持久队列 |
| rent_event | 关键操作、状态转换及节点消息去重的追加审计 |
简化方式:供应商不再单独建档(使用节点user_id);产品、规则和报价合并为不可变版本套餐;快照/资源池合并到钱包,预留明细合并到任务;委托关系与回收调度放订单和任务,链上证据独立;资金采用余额+不可变流水,不建设整套复式会计总账;业务任务表和回调表直接作可靠队列,不额外建设消息中间件与通用Outbox。
### 资源类型与字段约定
- rent_package、rent_order、rent_task、rent_transaction均有resource_type,允许ENERGY或BANDWIDTH,不设默认值;套餐、订单、任务及实际链上类型必须一致。
- 套餐、订单、任务使用resource_quantity正整数:ENERGY单位Energy,BANDWIDTH单位bytes;不再使用energy_quantity。单位由类型唯一确定,不另存可冲突的单位字段。
- 每个套餐及订单只租一种资源;同一用户需要两种资源时分别下单,价格和供应商应付独立配置。套餐同一package_code各版本不允许变换资源类型,新类型使用新代码。
- 钱包保留energy_available并增加bandwidth_available(仅可出租质押带宽,不含免费带宽)。energy_enabled/bandwidth_enabled独立开关,默认关闭。
- 能量本金字段为energy_delegatable_sun、energy_reserved_sun、energy_retain_sun;带宽对应bandwidth_delegatable_sun、bandwidth_reserved_sun、bandwidth_retain_sun。同一钱包行锁串行修改,只更新本任务的资源类型字段;未知能量任务不占用带宽本金,反之亦然。
- total_energy_limit/weight及total_bandwidth_limit/weight分别表示各自全网额度/权重,使用同一时点可信快照;两类快照未完整成功时不推进共同snapshot_at/expires_at,失败不能用零值覆盖另一类型占用。
- 链上BANDWIDTH的resource_code=0,ENERGY=1;免费带宽不可委托,账户普通TRX余额、收到代理量均不能直接视为可出租本金。RECLAIM必须使用原委托的resource_type和对应SUN,不能撤销另一类本金。
- HMAC意图、下单摘要、商户查询、回调、管理列表及审计都须明确资源类型和数量;内部统计按类型分组,不把Energy数量和bytes相加。
- 任务唯一键仍按order_id/task_type/active_slot,因为一个订单只含一种资源;钱包地址唯一键保持(network,address),不为两类资源重复创建钱包。
- V2.2 订单以 `(wallet_id,receiver_address,resource_type,relation_slot)` 限制同地址对同类型只有一笔在租或待回收订单,任务以 `(wallet_id,resource_type,wallet_execution_slot)` 限制同钱包同类型只有一个在途操作。两个占位均只能为 1 或 NULL;未知不可释放。不同接收者可分别在租,但同钱包同类型的链上操作串行。
- 钱包 `snapshot_block_height / snapshot_min_block_height` 配合 version CAS 防止旧快照覆盖。确认交易、释放预留与快照失效屏障同事务;获取新快照前不能再调度。详细顺序见复核说明第 3 节。
- 首版仅 `delegate_lock=0` 非锁定 Stake 2.0 委托,套餐 rules 和任务 intent 必须一致。不得直接复用现有 NILE/MAINNET 通用 `delegateResourceV2`(写死 `lock=true,86400` 且直接签名广播)。租赁只复用只读查询,本地 Agent 自行构建、持久化再广播。
### 请求资源量、冗余和委托TRX换算
链上Stake 2.0委托提交的是该资源类型对应的质押等值TRX本金,接口单位SUN,不直接提交Energy或bytes,也不是将TRX转账给接收人。Energy和Bandwidth必须使用各自当前网络总额度及权重,禁止固定TRX/资源汇率。
设Q为用户请求resource_quantity,R为锁定的redundancy_percent(20表示20%),L为该类型当前全网资源总额度,W为该类型当前全网总权重(协议的TRX权重单位,不是SUN):
```text
目标资源量 T = max(Q + 1, ceil(Q × (1 + R / 100)))
委托TRX本金 P = ceil(T × W / L)
委托SUN本金 S = P × 1,000,000
预计可交付资源 E = floor(S × L / (W × 1,000,000))
必须满足:Q > 0,R > 0,L > 0,W > 0,E >= T > Q
```
本版选择按整TRX向上取整,是避免不足的业务保守策略,不声称链上只能接受整TRX;若未来支持更细SUN步长,必须另定精度策略并验证节点最小委托限制及实际资源映射。公式使用BigDecimal/BigInteger和显式CEILING/FLOOR,中间乘积不能用long直接相乘或double;转换为BIGINT入库前执行精确范围检查。Q+1也必须检查溢出。
示例仅用于说明计算,不是当前网络价格:Q=65000 Energy,R=20%,T=78000;若当时L/W=60 Energy/TRX,则P=1300 TRX,S=1300000000 SUN,E=78000。带宽Q=1000 bytes、R=20%,若当时L/W=1.5 bytes/TRX,则T=1200、P=800 TRX。两种比例均从实时网络取得,不能把示例常量写入代码。
冗余仅放大用户购买的资源额度,不凭空增加同额TRX费用预算,也不自动扩大商户计价数量。固定套餐仍按resource_quantity收取快照售价,供应商成本和费用限制须已覆盖冗余;不能因实时换算需要更多本金而绕过本地额度/费用上限。Q表示本次应委托增加的资源量,不默认减去接收地址已有可用资源。
字段分工:套餐保存resource_quantity和默认20%的redundancy_percent;订单锁定二者及target_resource_quantity;任务保存原请求、冗余目标、换算参数/区块/时间、estimated_resource_quantity和delegate_sun;链上交易保存实际amount_sun、verified_total_limit/weight和verified_resource_quantity。TRX展示从SUN用BigDecimal除1000000得到,不额外存一份可冲突的本金TRX字段。
任务生成前可信查询L/W及可委托本金,按S而非未加冗余的估算量预留对应类型SUN。Agent签名前再次查询L/W、可委托额度、链上限制和费用:若原任务S已不足覆盖T,明确未构建/广播时拒绝旧任务并释放旧占位,由云端重新计算、预留、签发新attempt;Agent不可悄悄改大已签HMAC的S。原任务已构建/广播或结果未知时只按原交易恢复,不重签或新建一笔补额交易。
云端在确认区块用实际amount_sun与该区块L/W核验资源额度及链上委托增量,必须满足verified_resource_quantity >= T > Q才可结算成功。这里核验的是本单委托所对应的资源额度,不是接收方瞬时可用余额差;后者会受已有委托和并发消费影响,不能直接当作本单交付。
交易已成功但参数变化导致不足T时,不回滚链上事实、不将其标为未执行失败,不释放已委托本金、不重复委托;订单进入MANUAL_REVIEW并保留资金,按原确认SUN追踪回收,经审核选择撤销/退款等处置。首版不自动补委托以维持一单一笔成功委托的模型。冗余只是确认时的交付缓冲,不保证租期内全网参数永不变化,不能承诺资源额度恒定。
撤销以原已确认amount_sun为准,保持同资源类型,绝不能按到期时L/W重新换算原resource_quantity,否则可能多撤或少撤。RECLAIM任务的换算字段仅复制原委托审计快照,不用于决定撤销SUN。发生本金已委托但订单未成功的异常也必须进入回收扫描,不能仅扫描SUCCESS订单。
## 3. 业务流程示意图
```mermaid
flowchart TD
A["商户选择能量或带宽固定套餐并下单"] --> B{"HMAC、幂等、余额校验"}
B -->|不通过| X["拒绝请求"]
B -->|通过| C["事务:创建订单、冻结USDT"]
C --> R["请求数量加正冗余,得到更大的目标量"]
R --> D["按当前资源参数换算TRX并向上取整,预留SUN"]
D --> E["本地Agent复核额度并签名广播"]
E --> F{"云端独立核验链上结果"}
F -->|明确最终失败| G["释放冻结资金与预留资源"]
F -->|明确未执行且允许重试| V["释放旧资源占位,保留冻结资金"]
V --> D
F -->|结果未知| H["保持占用,查询原txId或人工核对"]
H --> F
F -->|确认且资源额度覆盖冗余目标| I["事务:扣款、供应商应收、回调入队"]
F -->|已委托但额度不足或核验已到期| U["人工核对、保留资金及本金记录,不重复委托"]
U --> K
I --> J["商户使用能量或带宽"]
J --> K["租期结束,生成撤销任务"]
K --> L["Agent撤销,云端核验"]
L --> M{"本金回收且资源恢复?"}
M -->|未恢复或被锁定| N["等待链上条件并告警"]
N --> L
M -->|是| O["回收完成,资源可再次出租"]
I --> P["运营人工审核供应商结算"]
```
### 3.1 开通与充值
1. 用户通过共用系统登录,运营在系统角色/菜单中授予rent:*权限。商户创建rent_app,获取独立API凭证;供应商创建rent_node并申请钱包接入。
2. 供应商在平台通过TronLink完成一次性消息签名验证,后端恢复的地址必须与待绑定地址一致;不要求发送链上证明交易或支付验证费用。运营审核与链上委托权限检查另行执行,未通过验证和审核的钱包不可接单。
3. 供应商Agent配置自己的钱包、留存本金/费用上限,默认广播关闭。人工确认后在本地允许广播;平台无法替节点打开。
4. 商户提交充值依据,运营通过受保护接口审核,原子增加rent_account.available_amount并追加TOPUP流水及rent_event。TOPUP的business_key使用规范化唯一充值凭据,例如TOPUP:network:txid:logIndex,唯一约束阻止同一凭据给不同用户重复入账。币种仅USDT且网络必须一致,凭据必须独立核验;不以截图作为到账真相。此版无待审充值单表,未审核请求不先增加余额。
### 3.2 下单与调度
TronLink钱包验证的完整规则见下方“TronLink钱包控制权验证”;下单仍使用原有HMAC或系统登录认证。
1. 请求提交network、resource_type、merchant_order_no、receiver_address(禁止提交package_id,由服务端按用户与分类匹配套餐),可指定回调URL。应用/用户由认证结果派生。查同一(app_id,merchant_order_no),相同规范化摘要返回原单,不同摘要拒绝。
2. 事务内锁套餐及账户,校验上架、网络、价格、地址和余额,保存订单/规则快照:可用减售价、冻结加售价,写HOLD流水和订单WAITING。同事务写状态审计。套餐改价新增revision,旧行不直接改金额。
3. 后台扫描WAITING并条件抢占。按锁定正冗余比例计算target_resource_quantity,再选在线、审核通过且快照有效的供应钱包,以当前该资源L/W换算整TRX向上取整后的delegate_sun。预计资源必须覆盖冗余目标,并保存完整换算快照;Energy和Bandwidth参数不能混用。
4. 事务内锁订单与钱包,按订单 resource_type 检查对应 delegatable_sun-retain_sun-reserved_sun 足够,取得地址对占位和钱包执行占位,固定 supplier_account_id,仅增加该类型 reserved_sun、创建 DELEGATE 任务并置订单 EXECUTING。任务显式保存 network,意图固定网络、类型、数量、地址、本金、非锁定参数、期限、费用和目标节点。签名前还须核验接收账户可委托条件及同类型地址对基线为零。
5. 创建订单时将等待上限固化为 dispatch_deadline,任务 deadline 不得晚于它。WAITING 超时且从未生成任务时取消并解冻。已投递的任务不因截止或断线被推定未执行;查原交易并隔离。明确未执行的可重试任务在截止前保留商户 HELD 资金,释放旧任务及地址对占位后重新调度;终结失败才解冻。用户仅可取消从未生成执行任务的 WAITING 单,取消与调度锁同一订单行裁决。
### 3.3 委托与确认
1. Agent持久化接单,验HMAC及本地授权/资源/费用,实时检查可委托额度;拒绝可返回明确未执行结果。
2. 本地仅构建签名一次,先持久化原签名交易及txId再广播;任何重试先查原txId,不重签另一笔交易。云端租约过期不能证明未执行。
3. 云端独立检查网络、owner、receiver、资源类型(ENERGY或BANDWIDTH)、SUN、回执、确认深度、委托前后差异;节点自报成功及HTTP200均不代表成功。
4. 确认成功后同事务:订单 SUCCESS、fund_status=CHARGED,冻结余额减售价;供应商先记 SUPPLIER_EARN 毛收入,再记 SUPPLIER_FEE 扣费,待结算净增加 supplier_net_amount;流水、审计和 SUCCESS 回调原子提交。service_started_at 使用独立核验交易的 block_time,service_expires_at=起点+租期;核验延迟不得延长租期。核验时已到期或无法取得足够历史证据则转人工核对,不静默扣款。多账户按 account_id 升序加锁,同账户只锁一次。
5. 链上事实确认即将对应委托预留转 COMMITTED 并扣除 reserved_sun,提升钱包 snapshot_min_block_height 至确认区块,令 snapshot_expires_at=NULL,再释放任务 wallet_execution_slot;与订单是否达到交付目标分开处理。后台按版本和区块屏障应用新的可信快照,之后才可接新任务;不能沿用旧值或先释放后异步补屏障。
6. 明确未执行的可重试失败只释放资源并重新调度,不写终态 FAILED 回调或解冻;决定最终失败时才同事务释放冻结、写 RELEASE 和 FAILED 回调。UNKNOWN 保留占位及预留,扫描任务及交易的 next_check_at;即使没有 txId 也必须扫描任务恢复,不能只扫描交易表。未知不能改钱包。已构建交易只有证实链上失败或超过原交易有效期且独立确认未上链才可重试;未找到一次、租约超时或 Agent 丢记录都不算证明。
### 3.4 到期回收
1. 业务服务到期只生成RECLAIM任务,不改已成功的履约状态,不自动退租金。
2. Agent查询实际锁定及可撤销量,按链上规则撤销;云端确认撤销交易后仍需核对资源实际恢复。
3. 首版同钱包、同 receiver、同类型仅允许一笔占位订单,拒绝存在该类型外部委托基线的钱包地址对;同地址对的下一笔单排队或选择其他钱包。RECLAIM 的 source_transaction_id 必须指向本单原确认 DELEGATE;仅撤销原 amount_sun。回收任务 reservation_status=NONE,不新增可委托本金预留,但要取得钱包执行占位。部分可回收或关系变化转人工,不撤销他人份额。
4. 链上仍锁定则 next_reclaim_at 等待;未知保留执行占位。撤销确认后更新快照区块屏障并失效旧快照,再释放执行占位;本金已回收但资源未恢复为 RECOVERING,按新的 getCanDelegatedMaxSize 及资源使用证据核对,不机械等待数值回到旧快照。确认本单恢复后才置 DONE 并释放订单 relation_slot。回收未发起前也要持久化 next_reclaim_at,不能遗漏异常委托。
5. active_slot保留成功DELEGATE任务用于定位原始SUN和链上证据;RECLAIM任务独立占位,不能把履约与回收混成一个status。
### 3.5 人工结算与退款
### 供应商手续费
平台在订单链上履约核验成功、订单转SUCCESS时向供应商扣取手续费;不在下单冻结、节点自报、未知状态、到期回收或结算付款时重复收取。商户售价不因此额外增加。套餐显式配置supplier_fee_percent(百分数,5代表5%),不擅自指定实际费率;下单锁定费率及金额,后续调费新增套餐版本,不改历史订单。
```text
供应商毛收入 G = supplier_amount
平台供应商手续费 F = round(G × supplier_fee_percent / 100, 6, HALF_UP)
供应商净应收 N = G - F
必须满足:0 < 费率 < 100,0 < F < G,N > 0,G <= 商户售价
```
例如毛收入10 USDT、配置费率5%,则平台手续费0.5 USDT、供应商净应收9.5 USDT。5%仅为示例,不是初始化默认费率。若极小金额舍入后手续费为0,拒绝启用套餐/创建订单,不能无提示按0收费或额外收最低费。
同一成功事务写两条供应商rent_ledger:SUPPLIER_EARN的delta_supplier_pending=+G、delta_platform_fee=0;SUPPLIER_FEE的delta_supplier_pending=-F、delta_platform_fee=+F。分别使用包含订单与事件类型的唯一business_key;只有首次成功状态转换可记账,重复扫描/回报不能再次扣费。三种余额的after值按两条流水顺序连续保存,事务提交后净增加N。平台手续费事实以不可变流水delta_platform_fee累计,不将其放入用户可用余额;这是简化收入统计,不是另一个可提款账户。
平台经营统计分别展示商户售价、供应商毛收入、供应商手续费、净应付和售采差价。平台总服务收入为商户售价减G再加F(仍需另计实际其他成本),不能将F重复加进已经按售价减N计算的收入。
结算来源金额为 supplier_net_amount-supplier_reversed_amount+supplier_fee_returned_amount,不能使用原 supplier_amount 或再次扣手续费。失败及未执行取消不计应收不抽手续费;已委托但资源不足的人工核对单也不能提前收取。
每次退款先创建 rent_refund,以 (order_id,request_no) 和 request_hash 幂等。只处理已 CHARGED 且已确认收入的订单。PENDING 不改余额;独立审批时重新校验累计金额,APPLIED 与订单累计、余额、各事件流水及退款回调同事务。分别保存商户退款额、供应商原净额冲正、平台手续费退回额及 fee_return_to。手续费退商户时已经包含在 refund_amount,不得再次加余额;退供应商时增加待结算及 supplier_fee_returned_amount。手续费退回累计不超过原手续费,原净额冲正累计不超过 supplier_net_amount,商户退款累计不超过售价。fee_return_to=NONE 当且仅当手续费退回为零;退商户手续费不得大于本次退款额。若来源已结算或已被结算占用,涉及供应商或手续费变化的退款不得应用;商户单方由平台承担的退款可单独审核。无外部退款出金。
结算发起时锁供应商账户及订单来源,检查订单SUCCESS、已核验、净应付未被占用;rent_settlement_item的(order_id,active_slot)唯一。结算金额按订单净应付汇总,不能超过账户待结算余额。结算审核不提前减少待结算,所有已占用来源都禁止再入其他结算单。
人工付款前先将 APPROVED 条件更新为 PAYING,持久化唯一 payout_no、payment_started_at 及审计,提交后才允许出款。付款后独立核验凭据,再同事务扣待结算、写 SETTLE、标记 PAID 并审计。PAYING/UNKNOWN 禁止普通拒绝、释放明细或重新出款;恢复时查询原 payout_no 和凭据。只有独立核验明确未付款且原授权已作废后,才可审核拒绝并释放来源。payment_reference 全局唯一。创建、审批职责分离,首版每来源整笔结算。
普通执行失败是解冻,不叫退款。退款按锁定规则和上述退款单审批执行,禁止制造负应付或修改已付历史。每次部分退款产生独立 event_key=REFUND:refund_no;回调不再按 (order_id,event_type) 唯一,而按业务事件键及订单事件序号唯一,避免第二次退款无法通知。
结算拒绝、退款及调度恢复都必须写审计,不能仅手工UPDATE数据库余额。
## 4. 状态和必须执行的约束
- 履约order.status:WAITING → EXECUTING → VERIFYING → SUCCESS;失败/取消明确终态FAILED/CANCELLED,结果不确定MANUAL_REVIEW。任务UNKNOWN不直接映射FAILED。
- 资金fund_status:HELD → CHARGED或RELEASED;退款累计refunded_amount另记,不覆盖原扣款事实。
- 回收reclaim_status:NOT_STARTED → WAITING → RUNNING → RECOVERING → DONE;异常MANUAL_REVIEW。
- 任务status:PENDING → ACCEPTED → BROADCASTED → VERIFIED,另有REJECTED/FAILED/UNKNOWN;任务类型DELEGATE/RECLAIM。
- 关联记录的network必须一致,用户id逻辑关联sys_user。API权限不等于数据归属,所有操作校验app.user_id或node.user_id,管理操作另查rent:*权限。
- available/frozen/supplier_pending均不得负数。余额变更、流水、状态、回调和审计同事务提交;相同business_key不重复变动余额。
- 不可变流水记录三种余额的正负增量及变更后值,可根据历史重建;不冒充双重记账总账。每日校验冻结合计与HELD订单、供应商待结算与未结应付、余额投影与流水。差异记录在rent_event并人工核对,不静默补差。
- 云端扫描数据库持久任务后经节点WSS连接推送,回调仍由数据库队列重试;数据库扫描是云端内部恢复机制,不是Agent长轮询。按状态/version及worker租约条件更新,先验证租约再落结果;Socket只负责传输,任务状态与节点本地持久化才负责副作用幂等。
- 一个任务唯一交易,(network,tx_id)全局去重;task(node_id、credential_id)和钱包节点归属必须一致。节点事件用rent_event.event_no唯一键原子去重,相同事件编号不同内容必须拒绝。
- HMAC通过后原子预留nonce;业务幂等与nonce是两种约束,重试新nonce、原merchant_order_no。云端定时任务都需限流、分页、超时及显式关闭。
- 所有表和字段有COMMENT;日期UTC DATETIME(3),金额DECIMAL(30,6),使用BigDecimal;MYSQL5.7跨表约束必须应用落实。禁止记录Secret、私钥及口令。
## 5. HMAC规则与共享权限
### TronLink钱包控制权验证
此流程是用户明确指定的钱包验证例外:使用TRON原生消息签名证明地址控制权,不引入RSA、公钥认证表,也不改变API/节点/任务/回调的HMAC体系。签署消息不是链上交易,不广播、不转账、不收链上手续费,平台不索取私钥、助记词或钱包密码。
1. 已登录供应商进入钱包绑定页,连接TronLink并获取当前地址,选择NILE或MAINNET。平台检查rent:*权限、node.user_id归属及(network,address)唯一性;Base58格式不能区分网络,网络必须作为独立声明和后续RPC校验条件。
2. 后端生成至少32随机字节的nonce和建议5分钟有效期,保存到rent_wallet的ownership_challenge、ownership_message及签发/到期字段。文本应可读,明确写明“仅验证钱包控制权,不授权转账或委托”,并包含固定协议版本、受信任站点域名、登录user_id、wallet_id、network、address、nonce、签发及过期UTC时间。站点域名来自受信任配置,不盲信请求Host。nonce不得由客户端指定;重新签发前将旧记录写rent_event,再覆盖当前挑战并清空本次签名和消费状态。
3. 前端将后端返回的原文原样传入TronLink提供的tronWeb.trx.signMessageV2(message),不预先SHA256、不二次hex编码,不使用sign交易接口或旧signMessage接口替代。签名前后核对当前连接地址与目标地址一致;用户拒签、钱包锁定、账户切换或不支持该版本时显示明确错误,不自动降级到其他签名协议。
4. 前端只提交wallet_id、challenge及signature,后端读取已保存原文,校验登录归属、当前地址/网络、有效期及未消费。Java后端使用与TronWeb verifyMessageV2相同的TRON消息前缀、UTF-8字节长度和签名恢复规则,恢复Base58Check地址并严格比较address;不能仅接受前端验签布尔值。JDK8实现应选兼容库并用TronLink真实样本及跨语言向量验证,不能假设Ethereum personal_sign直接兼容。
5. 验签通过后以当前challenge、version及未消费状态做条件更新,原子保存signature、恢复地址、ownership_verified_at和challenge_consumed_at,并写rent_event。同一挑战只接受一次;并发仅一方成功,重复完成请求可返回既有验证状态,但不再次产生授权或审核副作用。旧nonce、过期、改原文、跨用户/钱包/域/网络的签名均拒绝。
6. 服务端验证当前账户的链上委托权限、本金和网络状态,运营确认后才将钱包设为ACTIVE。地址签名通过仅说明该地址密钥控制能力,不保证质押资源充足、Agent拥有足够的Active Permission,也不证明TronLink实际连接网络;多签/权限密钥不能恢复为目标owner时首版明确拒绝,后续需专门设计多签证明,不能绕过校验。
7. 已验证钱包更换地址或网络必须新建/重新验证并先处理在途任务;禁止直接修改已承载订单的钱包地址。认证签名原文与结果作为公开证明数据仍应仅向所属用户/运营展示,日志只记录必要标识和摘要。
建议接口(共用系统登录与权限,不要求为网页再签一次API HMAC):POST /system/rental/wallet/{id}/challenge、POST /system/rental/wallet/{id}/verify。前者返回message/challenge/expires_at/签名版本,后者返回验证状态和恢复地址;不提供私钥输入框。前端增加连接、签名中、验证成功、拒签/过期/账户切换状态。
```mermaid
sequenceDiagram
participant U as 供应商
participant P as 平台网页
participant T as TronLink
participant S as 后端
U->>P: 登录并绑定钱包地址
P->>S: 申请一次性挑战
S-->>P: 完整原文、nonce、有效期
P->>T: signMessageV2(原文)
T->>U: 展示原文并请求确认
U->>T: 确认签名
T-->>P: 消息签名
P->>S: 提交挑战与签名
S->>S: 验签恢复地址、检查归属与有效期
S->>S: 原子消费挑战并保存验证结果
S-->>P: 钱包验证成功,等待审核/权限核验
```
旧版若已建ownership_tx_id,仅为旧链上证明字段,不直接当成TronLink验证结果;按实际数据做增量迁移,新验证字段先置空并要求新挑战。旧供应商在途任务保持可核对,不自动将旧签名或历史交易转换为本次签名证明。当前仅修改初始化DDL设计,未执行数据库迁移。
统一rent_credential:APP主体owner_id为rent_app.id,NODE为rent_node.id;新版本生成新api_key/api_secret,保留旧行。Secret仅在受认证TLS通道创建时展示一次,云端保存AES-GCM封装,主密钥在外部配置。ACTIVE用于新消息,VERIFY_ONLY仅接受明确绑定旧在途任务的有效验证,REVOKED一律拒绝。
HMAC-SHA256小写64位十六进制;签名覆盖协议版本RENT_HMAC_SHA256_V1、scope、api_key、Unix毫秒timestamp、nonce、HTTP方法、规范化path/query、SHA256实际body。字段以换行分隔,限制字段中换行,查询编码/排序及空body规则需固定跨语言测试向量;签名自身置于外层信封不参与body哈希。常量时间比较,Secret不上传请求,TLS提供传输加密。
API、NODE、TASK、WEBHOOK四域区分方向和用途。TASK使用节点凭证,完整intent及task_no、node_id、deadline纳入认证,按deadline验时效;回调只选择该订单APP的ACTIVE凭证,每次重试新timestamp/nonce,同一event_no保持不变。商户返回HTTP200且正文ok才确认,失败退避直至最大次数后DEAD并告警。回调逐次执行SSRF、DNS及重定向校验。共享Secret不具不可否认性,独立链上核验不可省略。
系统登录沿用GoogleOauthService及若依权限;后端@PreAuthorize和前端v-hasPermi使用rent:order:list、rent:node:audit、rent:account:topup、rent:settlement:approve等。不创建新角色表,凭证只供外部API/Agent使用,不能替代用户菜单权限。
## 6. 实施步骤与验证
### 云端与节点Socket通信和心跳
本版明确采用WebSocket(生产WSS)作为双向Socket协议,建议入口wss://平台域名/node/v1/socket。由Agent主动连接,适配NAT且无需开放本地公网端口;服务端复用当前JDK8/Spring Boot可兼容的WebSocket能力,Agent选兼容JDK8的客户端。API及商户回调仍用HTTPS,浏览器TronLink流程不走节点通道。
**认证与会话:**TLS升级后连接仍未认证,云端先发短期随机挑战,Agent在5秒内提交AUTH(node_no、api_key、timestamp、nonce、挑战及HMAC);Secret不放URL、查询参数或消息正文。AUTH按NODE域覆盖协议版本、用途、挑战、请求路径和全部业务字段,查rent_credential的NODE归属/状态、节点审核状态及防重放记录。只有成功后才能处理心跳和业务消息。服务端响应AUTH_OK也用该节点Secret认证并回显挑战,生成session_id及原子递增session_epoch。不能把HTTP升级成功当认证成功。
每节点仅允许一个当前认证会话。新连接认证成功后以node行CAS替换旧会话、递增epoch并关闭旧连接;每帧携带且签名覆盖当前session_id/epoch、方向、type、message_id、timestamp、递增sequence及payload摘要。节点上行和云端下行各自独立sequence,从1递增;字段/nonce不可跨NODE/TASK签名域复用。服务端下行序号由持连接进程串行维护,重启必须重新认证新会话,不能从旧序号继续。数据库last_client_sequence用于上行去重和连接恢复审计,不支持一个节点被多个实例并发接单。
节点业务status和连接connection_status分离:PENDING审核、ACTIVE允许接单、PAUSED暂停、REVOKED吊销不因连接变化而更改;OFFLINE离线、SYNCING恢复、ONLINE可通信独立变化。PAUSED可保持连接用于上报和核对在途任务,不能分配新单;REVOKED立即关闭通道并拒绝认证,云端继续独立链上核对历史交易。
**双向心跳:**默认每15秒发带HMAC的应用层PING,对端立即回PONG并回显ping message_id;云端和Agent都维护最近有效PONG及超时,默认45秒未收到则断开并重连。只接受属于当前会话、有效签名及未过期的心跳,重复旧PONG或任意TCP字节不能续租;云端用接收时间更新heartbeat_at/heartbeat_expires_at,不能信任节点自报时钟。WebSocket原生Ping/Pong可辅助探活,但不替代带身份的应用心跳。任务执行在线程池中进行,不能阻塞Socket事件线程而丢心跳。
所有节点状态、心跳、业务帧及断线回调更新都带node_id/session_epoch条件;旧会话close事件不得把新会话置OFFLINE。云端定时扫描过期心跳并条件标离线,调度只选status=ACTIVE、connection_status=ONLINE且租约未过期的节点,同时资源快照必须有效。数据库心跳可按15秒粒度合并写入,不将每次PING/PONG写rent_event以免无限增长。
**消息类型和可靠交付:**AUTH/AUTH_OK、PING/PONG、TASK_PUSH/TASK_ACK、TASK_ACCEPT/TASK_REJECT、TASK_EVENT/TASK_RESULT、RESULT_ACK、SYNC_REQUEST/SYNC_STATE/SYNC_ACK、PAUSE/ERROR。TASK_ACK只表示节点已持久化接收到的任务;TASK_ACCEPT才表示本地策略与资源允许执行,二者均不是广播成功。Socket发送成功不能将任务设ACCEPTED,更不能设SUCCESS。
云端先提交rent_task再推送,保留delivery_message_id;丢ACK时只重发同一任务及同一message_id,外层会话签名可以重新生成,原任务intent/HMAC和txId不可重构。Agent先持久化task_no及消息摘要再ACK,已存在任务相同内容返回本地状态,不同内容拒绝。过期任务即使重投也不能新执行。delivery_count仅投递计数,不是交易重试次数。
节点事件先存本地可靠发送队列,云端以rent_event.event_no=nodeId:eventId同事务去重、更新任务及交易后才发RESULT_ACK;ACK丢失可重发同事件,不能重复扣费/结算。云端当前帧sequence防会话重放,跨会话message_id/eventId/task_no负责持久幂等。逐帧HMAC与TASK内层HMAC分开:外层认证当前连接,内层认证冻结授权意图。
**重连恢复:**断线采用带随机抖动的指数退避,建议1、2、4、8秒逐步到最大30秒;连接并完成稳定认证后复位。新会话先SYNCING:Agent发送未完成task_no、已持久化txId、最后本地状态及待确认事件;云端与数据库及链上证据核对,ACK历史结果,返回需重发的原任务及禁止执行/过期状态。完成SYNC_ACK才ONLINE并允许新单。不能仅根据“本地没有该任务”就认定未执行;云端已有广播线索或未知副作用时仍先核对链上。
断线/心跳超时不等于链上失败,已接受/已广播/UNKNOWN任务继续保留资金和对应资源占用。Agent断线后不得接受新任务;尚未签名广播的任务暂停直到恢复认证并核对授权,已广播的交易仅本地查询原txId和持久化结果,重连回传;不因断线重签另一笔交易。网络恢复不能延长原deadline。
**多实例及限流:**session_id/epoch及server_instance_id落node表,Socket对象仅存在持连接实例内存。首版可单Socket入口;多实例时任务只能由连接所属实例投递,其他实例通过受控路由/发布通知唤醒持连接实例,持久事实始终在MySQL。进程重启连接失效并重新认证;Redis只作路由缓存。配置认证超时、帧大小上限(建议64KiB)、JSON深度、每节点消息速率、发送队列和线程池上限,慢消费者背压/断开而非无限堆积;日志禁止Secret和完整认证材料。
```mermaid
sequenceDiagram
participant A as 本地Agent
participant C as 云端WSS
participant D as 数据库
A->>C: 主动建立WSS连接
C-->>A: 一次性认证挑战
A->>C: AUTH(api_key及HMAC)
C->>D: 校验身份、分配session及epoch
C-->>A: AUTH_OK(HMAC)
A->>C: SYNC_STATE(历史任务及txId)
C-->>A: SYNC_ACK,允许接单
loop 每15秒双向心跳
C->>A: PING
A-->>C: PONG
A->>C: PING
C-->>A: PONG
end
C->>A: TASK_PUSH(持久化原任务)
A-->>C: TASK_ACK(已本地持久化)
A-->>C: TASK_ACCEPT / TASK_RESULT
C->>D: 原子更新并去重事件
C-->>A: RESULT_ACK
Note over A,C: 45秒无有效心跳则离线;重连先核对原任务,不盲目重派
```
测试增加:认证超时/伪造HMAC、旧PONG重放、心跳与长链上调用并发、网络半开、丢TASK_ACK、丢RESULT_ACK、重复推送、连接代次抢占、旧close不能影响新会话、重连未同步禁止接单、节点吊销、多实例路由、帧超限/背压、离线已广播成功后的恢复。现有表需新增会话与投递字段的版本化迁移,不能靠IF NOT EXISTS升级。本次仅设计,不声称已实现Socket服务或真实断线测试。
1. 建 16 表及 Mapper、共享菜单权限、HMAC 测试向量,隔离 MySQL 检查 DDL 及逻辑归属;验证本文及复核说明中的跨表约束。
2. 套餐、应用、节点/钱包审核、人工充值和不可变流水。
3. 下单冻结、单节点调度及Fake Agent闭环,覆盖并发/崩溃/幂等/未知。
4. NILE真实委托、云端独立核验、回调、到期撤销及资源恢复证据。
5. 人工结算/退款、每日账实核对、权限及限额、暂停接单与持续核对在途任务。
6. 主网上线单独批准,小额限额逐步开放;未完成资金及链上规则验收不得自动广播。
本文件与 DDL 是 V2.2 新设计,不是 V2.1 或旧 53 表的就地升级。初始化脚本不含 DROP 或 ALTER;已有表必须按实际历史数据另写增量迁移,不能依赖 IF NOT EXISTS 覆盖。字段回填、冲突隔离和旧 HMAC 兼容要求见复核说明。本次只改设计文件,无现有数据库操作。
测试至少覆盖:重复下单不同参数、余额不足、两个节点/任务抢同钱包、套餐改价、广播超时但实际成功、重启后按原交易恢复、未知单取消/重派拒绝、回收锁定/未恢复、同地址对同类型多订单及异类型并发、重复回调和SSRF、充值凭据重复、结算占位和未知付款、退款冲正、越权及UTC映射。Fake通过不等于NILE真实验证,编译通过不等于资金并发测试通过。
### V2单能量稿升级说明
若V2单能量表已执行,不能重跑IF NOT EXISTS完成升级。须备份后编写版本化ALTER:历史套餐/订单/task/transaction明确回填resource_type=ENERGY;energy_quantity改为resource_quantity;钱包原delegatable_sun/reserved_sun/retain_sun分别迁为energy_*,保留原金额与预留;新增带宽字段初始为0、bandwidth_enabled=0,重新可信查询并审核后才能启用。任务新增resource_quantity从原订单快照回填。旧HMAC任务的intent和签名不能原地篡改,应保留旧协议验证直到在途完成,新任务才使用包含资源类型的版本。最终去掉resource_type临时迁移默认值并验证非空。此处为迁移要求,本次未执行ALTER或修改数据库数据。
+9
View File
@@ -0,0 +1,9 @@
# 当前分类套餐规则
此前“一人一个当前套餐”的全局限制已被“每用户 + 网络 + 资源类型一个当前套餐”取代。
NILE、MAINNET 下的 ENERGY、BANDWIDTH 分别绑定,最多四个当前套餐;相同分类更换套餐才会停用旧绑定。所有应用共用所属用户的分类绑定,历史订单快照和幂等重试保持不变。
完整流程、API兼容规则、字段约束及部署顺序见 [用户分类套餐绑定与下单](user-package-bindings.md)。
已有数据库必须先执行 sql/rent_user_package_scope.sql 再部署新版代码。不能只运行 CREATE TABLE IF NOT EXISTS。sql/rent_user_package_single.sql 已调整为分类收敛,不再按用户全局停用其他分类。
+534
View File
@@ -0,0 +1,534 @@
# 能量与带宽租赁:逐表功能流程及协同关系
## 1. 文档依据与业务范围
本文依据 [rent_init.sql](../../sql/rent_init.sql) 及 [schema-design.md](schema-design.md) 的 V2.2 设计整理,覆盖全部16张表。复核发现、并发协议和迁移要求见 [business-review-v2.2.md](business-review-v2.2.md)。三端实现已新增,入口、配置及验证边界见[implementation.md](implementation.md);没有执行数据库迁移或真实链上广播。
业务范围:商户通过内部 USDT 余额购买固定能量或带宽套餐,平台选择供应商钱包,由供应商本地 Agent 签名广播,云端独立核验后扣款、确认供应商应收;租期结束再回收资源。充值和供应商付款由人工审核处理。
共享若依 `sys_user`、登录及 RBAC 权限;租赁应用、订单和资金独立,不复用支付业务的 `apps`、`orders`、`wallet_address`。平台不保存供应商私钥或助记词。
### 1.1 供应商与租赁用户的表使用关系
租赁用户是购买资源的商户,供应商是提供资源的一方,均关联若依 `sys_user`。仅出租资源的供应商需要 `rent_node` 及其 `rent_wallet`,不需要创建 `rent_app`;购买资源的商户需要 `rent_app`,不需要供应节点。同一用户可同时承担两种角色。
两方都需要 `rent_account`,但用途不同:商户使用可用余额及订单冻结余额,供应商使用待结算收入并处理退款冲正、结算。它是内部 USDT 账本账户,不是链上钱包,不需要配置私钥。账户按 `user_id + network` 唯一,而不是按应用或节点创建;同一用户兼任两种角色时共用该网络下的账户。
当前供应商入账流程为:调度选中 `rent_wallet` → 取得所属 `rent_node.user_id` → 按供应商用户及订单网络自动创建或复用 `rent_account` → 在订单固定 `supplier_account_id` → 独立核验履约后记入供应商净待结算收入 → 通过结算流程付款。供应商无需手动配置账户,但不能省略账户及流水记录。
### 1.2 通用字段与一致性约定
- `id` 为表内主键;业务编号和唯一键另行承担幂等职责。
- `version` 用于 CAS 乐观锁,更新时带原版本条件并递增;追加记录保持 0。
- `created_at / updated_at` 为应用显式写入的服务器/JVM本地 `DATETIME(3)`,说明见[时间修复与部署](../timezone-fix.md);不修改历史数据。
- USDT 金额使用 `DECIMAL(30,6)`,业务计算使用精确十进制。
- 表间采用逻辑外键;归属、网络、状态机、金额非负及跨表一致性由应用落实。
- `ENERGY` 数量单位为 Energy,`BANDWIDTH` 为 bytes;本金单位为 SUN,1 TRX = 1,000,000 SUN。
## 2. 逐表功能与流程
### 2.1 rent_app:商户应用
**设计功能:** 区分不同商户应用,确定订单归属、API 主体及默认回调地址。
| 关键字段 | 功能 |
| --- | --- |
| `user_id` | 应用所属 `sys_user.user_id` |
| `name` | 应用名称 |
| `status` | `ACTIVE` 启用、`DISABLED` 禁用 |
| `notify_url` | 默认 HTTPS 回调地址,需要 SSRF 校验 |
**功能流程:** 用户登录并获得权限 → 创建应用 → 签发应用凭证 → 商户认证下单 → 订单保存应用 ID 和回调地址快照。查询、取消等操作检查应用归属,不能仅凭传入 ID 操作。
**协同关系:** 一个用户可以创建多个应用,一个应用有多版 `rent_credential` 和多笔 `rent_order`。应用不保存余额,通过所属用户和订单网络定位 `rent_account`。
### 2.2 rent_credential:商户与节点统一凭证
**设计功能:** 管理 HMAC 身份、加密 Secret、密钥轮换及历史在途消息验证。
| 关键字段 | 功能 |
| --- | --- |
| `owner_type / owner_id` | `APP` 指向应用,`NODE` 指向节点 |
| `api_key` | 全局唯一公开标识 |
| `api_secret / master_key_version` | AES-GCM 密文及外部主密钥版本 |
| `status` | `ACTIVE` 可签发新消息;`VERIFY_ONLY` 仅验历史在途;`REVOKED` 吊销 |
| `expires_at / revoked_at` | 到期和吊销时间 |
**功能流程:** 创建主体 → 生成凭证 → 受认证通道一次性展示 Secret → 请求签名与服务端验证 → 轮换时新增凭证行并保留历史 → 必要时吊销。Secret 不随请求传输,也不写日志。
**协同关系:** 与 `rent_nonce` 协作防重放;`rent_task.credential_id` 固定节点授权版本;`rent_webhook.credential_id` 记录最近发送使用的应用凭证。主体归属是多态关联,需根据 `owner_type` 校验。
### 2.3 rent_nonce:认证消息防重放
**设计功能:** 阻止合法签名消息被重复使用。
| 关键字段 | 功能 |
| --- | --- |
| `api_key` | 对应凭证 |
| `scope` | API、NODE、TASK、WEBHOOK 认证域 |
| `nonce` | 高熵随机数 |
| `expires_at` | 安全清理时间,必须晚于消息有效期 |
**功能流程:** 验签并检查时效 → 原子插入 `(api_key, scope, nonce)` → 唯一键冲突则拒绝重放 → 超出有效窗口后清理。各方向的接收方落实防重放;Agent 和商户接收端同样需要相应机制,不能仅依赖云端此表。
**协同关系:** 关联 `rent_credential.api_key`。消息防重放与业务幂等分开:重试请求使用新 nonce,但保留原商户订单号。
### 2.4 rent_node:供应商本地执行节点
**设计功能:** 管理供应商 Agent 的审核、接单资格、在线状态、会话和心跳。
| 关键字段 | 功能 |
| --- | --- |
| `user_id / node_no` | 供应商及全局节点编号 |
| `status` | PENDING、ACTIVE、PAUSED、REVOKED |
| `connection_status` | OFFLINE、SYNCING、ONLINE |
| `session_id / session_epoch` | 当前会话及连接代次,隔离旧连接 |
| `server_instance_id` | 当前连接所在云端实例 |
| `heartbeat_at / heartbeat_expires_at` | 最近有效心跳及在线租约 |
| `last_client_sequence` | 当前会话上行认证帧去重序号 |
**功能流程:** 供应商注册 → 运营审核 → Agent 主动建立 WSS → 节点凭证认证 → 原子更新会话代次 → SYNCING 同步历史任务 → ONLINE → 持续心跳。默认心跳周期 15 秒、超时 45 秒,按云端接收时间判定。
**协同关系:** 一个节点绑定多个 `rent_wallet`,执行多个 `rent_task`,并持有节点凭证。仅审核允许接单、连接在线且租约有效的节点可获新单。PAUSED 可核对在途任务;离线不能作为交易失败依据。旧会话断开事件必须带 epoch 条件,避免覆盖新会话。
### 2.5 rent_wallet:供应钱包与两类资源池
**设计功能:** 保存公开钱包、控制权证明、可信资源快照、本金保留及在途预留。首版一个钱包只绑定一个执行节点。
| 字段组 | 功能 |
| --- | --- |
| `node_id / network / address` | 执行节点、网络、资源所有者地址 |
| `ownership_challenge / ownership_message` | 平台保存的一次性挑战和完整待签原文 |
| `ownership_signature / ownership_verified_address` | TronLink 消息签名及后端恢复地址 |
| `challenge_* / ownership_verified_at` | 挑战期限、消费及验证时间 |
| `energy_enabled / bandwidth_enabled` | 两类资源独立出租开关,默认关闭 |
| `*_delegatable_sun / *_reserved_sun / *_retain_sun` | 各类可委托本金、在途预留、供应商保留本金 |
| `energy_available / bandwidth_available` | 查询投影;带宽只含可出租质押带宽 |
| `total_*_limit / total_*_weight` | 两类全网换算参数 |
| `snapshot_at / snapshot_expires_at` | 可信快照有效期 |
| `snapshot_block_height / snapshot_min_block_height` | 当前快照高度及允许应用快照的最低确认区块 |
**功能流程:** 绑定钱包 → 平台签发挑战 → 用户通过 TronLink `signMessageV2` 签署原文 → 后端恢复地址、验证归属和有效期并原子消费挑战 → 检查链上执行权限及运营审核 → 启用出租 → 刷新可信快照 → 调度时锁钱包行并预留对应类型本金 → 委托成功后转换预留并刷新链上状态 → 回收且资源恢复后重新出租。
```text
对应类型可调度本金 = delegatable_sun - retain_sun - reserved_sun
```
**协同关系:** 节点决定供应商归属;订单记录选定钱包,任务记录预留明细,交易表提供实际委托和回收证据。能量与带宽本金不互借,免费带宽、普通 TRX 余额和收到的代理资源不能直接视为可出租本金。验证地址控制权不等于审核通过或 Agent 已具备委托权限。
异步刷新必须先读取 version,再查询可信节点,最后 CAS 更新;确认交易时原子提升最低区块、失效旧快照并处理预留,再释放钱包执行占位。新快照必须覆盖屏障区块,才能再调度;可委托本金取对应类型 `getCanDelegatedMaxSize`,不能简单用总质押减已委托。
### 2.6 rent_package:固定套餐与价格版本
**设计功能:** 定义资源数量、租期、售价、供应商毛收入、手续费及执行规则。
| 关键字段 | 功能 |
| --- | --- |
| `package_code / revision` | 套餐代码与递增版本 |
| `network / resource_type / resource_quantity` | 网络、资源类型、购买数量 |
| `redundancy_percent` | 正冗余比例,默认 20%,订单创建时锁定 |
| `duration_seconds / sale_amount` | 租期与商户售价 |
| `supplier_amount / supplier_fee_percent` | 供应商毛收入与平台手续费率 |
| `fee_limit_sun / rules` | 单笔链上费用上限及锁定、偏差、退款规则 |
| `delegate_lock` | 首版固定 0 非锁定,1 拒绝上架 |
| `status` | ACTIVE 上架、DISABLED 下架 |
**功能流程:** 运营配置 → 校验数量、价格、毛收入、正手续费及完整规则 → 上架 → 商户下单保存快照 → 改价或调整商业规则时新增 revision,历史订单不变。
**协同关系:** 一个套餐版本关联多笔订单;同一代码各版本不能改变资源类型。供应商金额已包含约定链上操作成本;费用上限为零时不能广播。
### 2.7 rent_account:租赁内部资金账户
**设计功能:** 按用户和网络隔离 USDT 可用、冻结和供应商待结算余额。
| 关键字段 | 功能 |
| --- | --- |
| `user_id / network` | 唯一账户归属 |
| `available_amount` | 商户可消费余额 |
| `frozen_amount` | 订单资金冻结余额 |
| `supplier_pending_amount` | 供应商扣手续费后的待结算余额 |
| `status` | ACTIVE 可操作、FROZEN 冻结业务 |
**功能流程:** 人工充值核验后增加可用余额 → 下单由可用转冻结 → 成功扣冻结;明确失败或取消则冻结转回可用 → 供应商成功履约增加净待结算 → 人工付款核验后减少待结算。成功订单退款按审核规则返还内部余额。
**协同关系:** 所有余额变化必须与 `rent_ledger` 同事务;订单引用付款账户,结算单引用供应商账户。同一用户可同时是商户和供应商,同网络仍只有一个账户。三类余额均不得为负。
### 2.8 rent_order:租赁业务主订单
**设计功能:** 汇总下单、资源交付、价格快照、资金、退款、租期及回收计划。
| 字段组 | 功能 |
| --- | --- |
| `order_no / app_id / merchant_order_no / request_hash` | 平台编号、商户归属和业务幂等 |
| `package_id / package_snapshot` | 套餐版本及规则快照 |
| `resource_* / redundancy_percent / target_resource_quantity` | 购买量及含冗余目标 |
| `sale_amount / supplier_*` | 售价、毛收入、手续费、净应收及累计冲正 |
| `wallet_id / supplier_user_id` | 选定供应钱包与供应商快照 |
| `supplier_account_id / relation_slot` | 固定供应商账户及同钱包、接收者、资源类型的持久占位 |
| `dispatch_deadline` | 下单时锁定最晚新任务执行时间,不能用于推定已投递任务失败 |
| `supplier_fee_returned_amount` | 退回供应商的手续费累计,增加结算来源金额 |
| `payer_account_id / fund_status / refunded_amount` | 付款账户、资金状态和退款累计 |
| `status` | 履约状态 |
| `service_* / reclaim_status / next_reclaim_at` | 租期及独立回收调度 |
| `notify_url` | 本单回调地址快照 |
**功能流程:** 请求校验与幂等 → 同事务创建 WAITING 订单和冻结资金 → 选择钱包并创建委托任务,进入 EXECUTING → VERIFYING 独立核验 → 成功则 SUCCESS 并扣款、确认应收、回调入队 → 到期推进回收。明确未执行失败可解冻,结果不确定进入核对流程。
| 状态维度 | 主路径 |
| --- | --- |
| 履约 `status` | WAITING → EXECUTING → VERIFYING → SUCCESS;另有 FAILED、CANCELLED、MANUAL_REVIEW |
| 资金 `fund_status` | HELD → CHARGED 或 RELEASED |
| 回收 `reclaim_status` | NOT_STARTED → WAITING → RUNNING → RECOVERING → DONE;异常 MANUAL_REVIEW |
**协同关系:** 连接应用、套餐、账户、钱包、任务、交易、流水、结算明细、回调和审计。一单一种资源、一个供应钱包。未知执行结果不能改派;用户只能取消尚未生成任务的 WAITING 订单。无供应方时有明确等待上限,避免无限冻结。
同钱包同接收地址同资源类型只允许一个 relation_slot=1,直到明确未执行释放或本金回收且资源恢复;下一单排队或改选其他钱包。服务起点采用核验交易的区块时间,不能使用核验完成时间;延迟核验时已到期转人工。退款不覆盖 CHARGED 事实。
### 2.9 rent_task:委托与回收任务
**设计功能:** 兼任持久执行队列、授权意图、尝试历史和资源预留明细。
| 字段组 | 功能 |
| --- | --- |
| `order_id / wallet_id / node_id` | 订单及执行归属 |
| `network / source_transaction_id` | 显式网络;回收任务绑定原确认委托交易 |
| `wallet_execution_slot` | 同钱包同资源类型最多一个在途操作,未知保留 |
| `task_type` | DELEGATE 委托、RECLAIM 回收,不支持转账 |
| `conversion_* / estimated_resource_quantity / delegate_sun` | 换算证据、预计交付量和授权本金 |
| `attempt_no / active_slot` | 尝试序号及有效占位 |
| `credential_id / intent / signature / deadline` | 固定凭证、HMAC 意图和执行期限 |
| `status / reservation_status` | 执行状态及 HELD、COMMITTED、RELEASED 资源状态 |
| `lease_owner / lease_until` | worker 处理租约 |
| `delivery_* / last_sent_at` | 稳定消息编号、投递代次、次数及持久接收 ACK |
**功能流程:** 查询可信全网参数 → 锁订单与钱包 → 预留本金并创建任务 → 提交后 WSS 推送 → Agent 持久化后 TASK_ACK → 策略与资源检查后 ACCEPTED → 原交易广播 BROADCASTED → 云端核验 VERIFIED。明确拒绝或失败才可释放相应占用;UNKNOWN 保留隔离并查原交易。
**协同关系:** 一个订单可以保留多个历史尝试,但同类型有效或成功任务由 `(order_id, task_type, active_slot)` 限制。MySQL 唯一键允许多个 NULL,因此明确未执行失败后可置空占位并创建新尝试。任务最多对应一笔 `rent_transaction`。成功委托占位保留以追溯原本金,回收任务另行占位。
委托的 reservation_status 使用 HELD、COMMITTED、RELEASED;回收固定 NONE,不再次预留委托本金。钱包执行占位在终结并写入快照屏障后置 NULL,订单关系占位继续保留。可重试失败保留订单资金 HELD;最终失败才解冻,不能既解冻又重试。
投递 ACK 不表示接受或成功;发送次数不是链上执行次数。丢 ACK 重发同任务及 message_id,不能重构授权意图或重签另一笔交易。
### 2.10 rent_transaction:链上事实与核验证据
**设计功能:** 保存任务唯一交易及云端独立核验结果。
| 关键字段 | 功能 |
| --- | --- |
| `task_id / network / tx_id` | 任务与链上交易身份 |
| `owner_address / receiver_address / transaction_type / resource_type` | 实际交易参数 |
| `amount_sun` | 实际委托或回收本金 |
| `verified_total_* / verified_resource_quantity` | 确认区块参数及本单资源额度 |
| `baseline_sun / after_sun` | 同地址对同资源类型的前后关系证据 |
| `block_height / evidence / confirmed_at` | 确认高度、证据和时间 |
| `block_time` | 独立查询交易所在区块的时间,转换为服务器本地DATETIME保存,作为服务起点 |
| `status / next_check_at` | REPORTED、CONFIRMED、FAILED、UNKNOWN 及核对计划 |
**功能流程:** Agent 上报原 txId → 云端查询交易、回执和委托关系 → 校验网络、地址、类型、金额及确认规则 → 委托额覆盖冗余目标才可认定交付成功 → 更新任务和订单。未知则继续查询原 txId。
**协同关系:** `task_id` 唯一,每任务最多一笔交易;`(network, tx_id)` 唯一,防止同笔交易重复归属。节点自报、HTTP 成功或接收方瞬时可用余额变化不能直接作为本单交付依据。
链上 CONFIRMED 与订单 SUCCESS 分开:实际已委托但资源不足也应确认链上事实、转换本金预留并安排回收,订单转 MANUAL_REVIEW,不能谎报链上失败或提前扣款。
### 2.11 rent_ledger:不可变资金流水
**设计功能:** 记录余额变化及平台供应商手续费,提供幂等、追溯和对账依据。
| 字段组 | 功能 |
| --- | --- |
| `account_id / business_key / event_type` | 账户、全局唯一记账键和业务事件 |
| `delta_available / delta_frozen / delta_supplier_pending` | 三类余额增量 |
| `after_available / after_frozen / after_supplier_pending` | 变更后余额 |
| `delta_platform_fee` | 平台供应商手续费收入变化,不是用户可提款余额 |
| `order_id / settlement_id / reversal_of_id` | 来源订单、结算单及冲正对象 |
| `refund_id` | 本次退款和相关冲正来源,关联 rent_refund |
| `operator_user_id / evidence_ref / reason` | 操作者及核验依据 |
**功能流程:** 锁账户 → 校验业务状态和记账键 → 修改余额并追加流水 → 同事务更新业务状态和审计。纠错通过追加 REVERSAL 等流水,不覆盖旧记录。
| 事件 | 典型余额变化 |
| --- | --- |
| TOPUP | 可用 +金额 |
| HOLD | 可用 -售价,冻结 +售价 |
| CHARGE | 冻结 -售价 |
| RELEASE | 冻结 -售价,可用 +售价 |
| SUPPLIER_EARN | 待结算 +毛收入 |
| SUPPLIER_FEE | 待结算 -手续费,平台手续费 +手续费 |
| SETTLE | 待结算 -结算额 |
| REFUND / REVERSAL | 按审核规则追加退款或冲正增量 |
**协同关系:** 关联账户、订单、结算及原流水。账户是余额投影,流水是变更历史。充值必须通过规范化全局唯一凭据构造 business_key;`evidence_ref` 自身没有唯一索引,不能单靠该字段防重复入账。
### 2.12 rent_settlement:人工结算单
**设计功能:** 管理供应商净应收的审核、人工付款和付款核验。
| 关键字段 | 功能 |
| --- | --- |
| `settlement_no / account_id / amount` | 结算编号、供应商账户及总额 |
| `status` | PENDING、APPROVED、PAYING、PAID、REJECTED、UNKNOWN |
| `payout_no / payment_started_at` | 出款前持久化的唯一付款授权及时间 |
| `payment_reference / payment_evidence` | 全局唯一标准化付款凭据和核验结果 |
| `created_by / approved_by / paid_at` | 发起、审批及核验时间 |
**功能流程:** 锁账户和来源订单 → 检查可结算净应收 → 创建结算单及明细 → 独立人员审批 → 先提交 PAYING 和唯一 payout_no → 人工付款 → 核验唯一付款凭据 → 同事务扣待结算余额、写 SETTLE 流水、标记 PAID 并审计。
**协同关系:** 账户确定付款对象,明细确定来源订单,流水记录实际扣减。审批不提前扣余额。UNKNOWN 保留来源占用,不得重付;仅明确未付并拒绝时释放。
PAYING 同样禁止普通拒绝和重复出款;必须先核验原授权明确未付且作废,才能拒绝释放。超时不能自动认定未付款。
### 2.13 rent_settlement_item:结算来源明细
**设计功能:** 关联结算单和订单,防止同一来源重复结算。
| 关键字段 | 功能 |
| --- | --- |
| `settlement_id / order_id` | 结算单及来源订单 |
| `amount` | 本单净可结算额 |
| `active_slot` | 占用或已付款取 1,明确拒绝且未付款才置 NULL |
**功能流程:** 锁定成功且核验通过的订单 → 计算 `supplier_net_amount - supplier_reversed_amount + supplier_fee_returned_amount` → 插入明细占位 → 汇总结算总额 → 付款后永久保留有效占位。唯一键 `(order_id, active_slot)` 防止重复占用和重复付款。
**协同关系:** 一张结算单包含多笔订单;首版每笔订单只全额结算一次,不能拆到多个批次。结算按净应收计算,不再次扣手续费。
### 2.14 rent_webhook:商户回调持久队列
**设计功能:** 可靠通知商户订单 SUCCESS、FAILED、CANCELLED、REFUNDED、RECLAIMED 事件。
| 关键字段 | 功能 |
| --- | --- |
| `event_no / order_id / event_type` | 稳定事件编号及订单事件类型 |
| `event_key / order_event_sequence` | 业务事件去重键及订单内递增序号,支持逐次部分退款 |
| `payload` | 固定业务内容,不暴露内部成本或 Secret |
| `status` | PENDING、SENDING、ACKED、DEAD |
| `attempt_count / next_attempt_at` | 重试次数与退避计划 |
| `credential_id` | 最近使用的商户凭证 |
| `lock_owner / lock_until / last_error` | worker 租约及脱敏失败信息 |
**功能流程:** 订单状态变更同事务入队 → worker 抢占 → 校验地址、DNS、重定向等 SSRF 风险 → 使用所属 APP 的有效凭证签名发送 → HTTP 200 且正文 ok 才 ACKED → 失败退避重试 → 超限 DEAD 并告警。
**协同关系:** 订单提供应用归属和回调地址快照,凭证表提供认证。重试保持同一 event_no、event_key、序号和业务内容,重新生成时间戳和 nonce。普通事件键为 ORDER:id:type,退款为 REFUND:refund_no;移除旧的 `(order_id,event_type)` 唯一限制,改用 event_key 和 `(order_id,order_event_sequence)` 唯一。锁订单后分配序号,商户按 event_no 去重并按序号识别乱序。
### 2.15 rent_event:追加业务审计
**设计功能:** 记录关键操作、状态变化及节点结果事件去重。
| 关键字段 | 功能 |
| --- | --- |
| `event_no` | 全局唯一事件编号,节点来源使用 nodeId:eventId |
| `object_type / object_id` | APP、NODE、WALLET、PACKAGE、ORDER、TASK、ACCOUNT、SETTLEMENT 等对象 |
| `action / actor_user_id / node_id` | 动作、用户和节点来源 |
| `detail / reason` | 脱敏前后状态、证据和操作依据 |
**功能流程:** 关键操作产生事件 → 与业务状态同事务写入 → 节点重复回报按唯一事件去重,相同编号不同内容拒绝 → 提交成功才返回 RESULT_ACK → 按对象查询完整操作历史。
**协同关系:** 横向关联各业务表,记录操作依据;资金以 `rent_ledger` 为准,链上事实以 `rent_transaction` 为准。普通心跳不逐条写审计,避免无效膨胀。
### 2.16 rent_refund:内部余额退款与费用调整
**设计功能:** 让每次部分退款具有独立审批、稳定幂等编号及对应流水和回调,避免重复点击重复退款。
| 关键字段 | 功能 |
| --- | --- |
| `refund_no / order_id / request_no / request_hash` | 平台编号、原订单和同订单请求幂等 |
| `refund_amount` | 商户内部余额返还额,大于 0,含退商户手续费部分 |
| `supplier_reverse_amount` | 供应商原净应收冲正额 |
| `platform_fee_reverse_amount / fee_return_to` | 平台退费金额及 NONE、MERCHANT、SUPPLIER 方向 |
| `status / created_by / approved_by / applied_at` | PENDING、APPLIED、REJECTED;独立审批及生效时间 |
**功能流程:** 创建请求 → 同编号同摘要返回原单,不同摘要拒绝 → 独立审批 → 重新锁定校验订单、账户、结算来源和累计上限 → 同事务返还余额、调整应收及平台手续费、写流水、更新订单累计和退款 APPLIED、创建独立 REFUNDED 回调并审计。
**协同关系:** 仅处理已 CHARGED 且已记收入订单;HELD 走解冻。PENDING 不改余额也不占用退款额度,审批时竞争同一订单行重新核验。退供应商手续费增加订单 supplier_fee_returned_amount 和待结算,纳入结算来源;退商户的手续费已包含在 refund_amount,不能另加一次。涉及供应商或手续费变化且来源已结算/被占用时拒绝应用,转人工处置。
## 3. 主要表间协同关系
```mermaid
flowchart TD
U["共享 sys_user"] --> A["rent_app 商户应用"]
U --> N["rent_node 供应节点"]
U --> AC["rent_account 资金账户"]
A --> C["rent_credential 凭证"]
N --> C
C --> NO["rent_nonce 防重放"]
N --> W["rent_wallet 供应钱包"]
A --> O["rent_order 订单"]
P["rent_package 套餐版本"] --> O
AC --> O
W --> O
O --> T["rent_task 委托与回收任务"]
W --> T
N --> T
T --> TX["rent_transaction 链上证据"]
AC --> L["rent_ledger 资金流水"]
O --> L
AC --> S["rent_settlement 结算单"]
S --> SI["rent_settlement_item 结算明细"]
O --> SI
S --> L
O --> WH["rent_webhook 回调队列"]
O --> R["rent_refund 退款单"]
R --> L
R --> WH
E["rent_event 关键审计"] -.-> O
E -.-> T
E -.-> AC
E -.-> S
```
图中为主要业务关联,不表示数据库已声明物理外键;审计还覆盖应用、节点、钱包和套餐。
| 关联 | 基数及用途 |
| --- | --- |
| sys_user → rent_app / rent_node | 一对多,分别为商户应用及供应节点归属 |
| sys_user → rent_account | 一对多,按网络唯一 |
| rent_app / rent_node → rent_credential | 一对多,通过 owner_type、owner_id 区分 |
| rent_credential → rent_nonce | 一对多,通过 api_key 关联认证记录 |
| rent_node → rent_wallet | 一对多;钱包首版只绑定一个节点 |
| rent_app / rent_package → rent_order | 一对多,保存订单归属和套餐来源 |
| rent_account → rent_order | 一对多,payer_account_id 指定商户付款账户 |
| rent_wallet → rent_order | 一对多,调度前订单钱包可为空 |
| rent_order → rent_task | 一对多,委托、回收及历史尝试 |
| rent_task → rent_transaction | 一对零或一,每任务最多一笔链上交易 |
| rent_account / rent_order → rent_ledger | 一对多,余额与订单资金变动 |
| rent_account → rent_settlement | 一对多,供应商结算批次 |
| rent_settlement → rent_settlement_item | 一对多,批次订单来源 |
| rent_order → rent_settlement_item | 可有历史拒绝明细,最多一个有效或已付占位 |
| rent_order → rent_webhook | 一对多,按业务事件去重,退款逐次独立 |
| rent_order → rent_refund | 一对多,每次部分退款保留独立记录 |
| rent_refund → rent_ledger | 一对多,商户退款、应收冲正和手续费调整分别记账 |
| 各业务对象 → rent_event | 一对多,通过 object_type、object_id 审计 |
## 4. 完整业务协同流程
### 4.1 开通和人工充值
1. 共用系统登录和权限授予;商户创建应用、供应商注册节点及钱包。
2. 为 APP 和 NODE 分别签发凭证;钱包完成消息签名验证、链上权限核验及审核。
3. Agent 配置本地钱包、保留本金和费用限制;广播默认关闭,只能供应商本地明确允许。
4. 运营独立核验 USDT 充值凭据,锁账户后增加可用余额,同事务写 TOPUP 流水及审计。
5. 充值凭据规范化并构造全局唯一 business_key,阻止同凭据给不同账户重复入账。本版无待审核充值单表。
### 4.2 下单与资金冻结
1. 校验应用凭证、签名、消息时效及 nonce,或使用系统登录身份和权限。
2. 按 `(app_id, merchant_order_no)` 查重;相同摘要返回原订单,不同内容拒绝。
3. 锁套餐和账户,检查上架、网络、地址、资源、规则、费用及余额。
4. 同事务创建订单并锁定快照,扣可用、加冻结,追加 HOLD 流水和审计。
5. 订单进入 WAITING,资金 HELD,回收 NOT_STARTED,保存 dispatch_deadline。
### 4.3 冗余换算与资源预留
设请求数量为 Q,正冗余百分数为 R,该资源全网总额度为 L、TRX 权重为 W:
```text
目标资源量 T = max(Q + 1, ceil(Q × (1 + R / 100)))
委托本金 TRX = ceil(T × W / L)
委托本金 SUN = 委托本金 TRX × 1,000,000
预计资源量 E = floor(SUN × L / (W × 1,000,000))
要求:Q > 0,R > 0,L > 0,W > 0,E >= T > Q
```
1. 选择已审核、在线、快照有效且对应资源开启的钱包。
2. 使用对应资源的当前参数精确换算,不能用固定 TRX 汇率。
3. 锁订单和钱包,检查截止、地址对占位、钱包执行占位、可信快照屏障及可调度本金,增加该类型 reserved_sun,固定供应商账户。
4. 创建包含完整授权意图及换算证据的 DELEGATE 任务,订单进入 EXECUTING。
5. 事务提交后推送任务。链上调用不作为数据库原子事务的一部分,通过持久状态恢复衔接。
### 4.4 Agent 执行与云端核验
1. Agent 持久化原任务后回 ACK,再验证 HMAC、期限、本地授权、费用及实时资源。
2. 如原授权本金已不足且明确未构建或广播,可拒绝任务,由云端释放旧占位并重新换算新尝试;Agent 不能擅自放大本金。
3. 一次构建签名交易,先持久化原交易及 txId 再广播;重试查原交易,不重签另一笔。
4. 云端独立核验网络、地址、资源类型、SUN、回执、确认区块及关系变化。
5. 实际确认资源量覆盖冗余目标,才能成功记账。
6. 链上已委托但交付不足时进入人工核对,保留资金及本金记录并安排回收,不自动补委托。
### 4.5 成功扣款与供应商应收
云端核验交付达标且尚未到期后,同事务完成:交易 CONFIRMED、任务 VERIFIED、订单 SUCCESS、资金 CHARGED、扣冻结、供应商收入和手续费流水、预留转换、钱包快照屏障及执行占位释放、服务起止、回收计划、SUCCESS 回调及审计。服务起点取交易 block_time,核验时间不延长租期。已委托但交付不达标也必须确认链上事实和处理预留、回收,订单保持人工核对。
```text
供应商毛收入 G = supplier_amount
手续费 F = round(G × supplier_fee_percent / 100, 6, HALF_UP)
净应收 N = G - F
要求:0 < 费率 < 100,0 < F < G,N > 0,G <= 商户售价
```
先追加 SUPPLIER_EARN:待结算 +G;再追加 SUPPLIER_FEE:待结算 -F、平台手续费 +F。最终供应商待结算净增 N。各流水按顺序保存变更后余额,多账户按 account_id 顺序加锁,同一账户只锁一次。
例如售价 12 USDT、毛收入 10 USDT、示例费率 5%,供应商净应收 9.5 USDT。平台收入统计为售价减毛收入加手续费,即 2.5 USDT(未扣其他成本);不能在售价减净应收后再次加手续费。5% 仅为示例。
### 4.6 明确失败、取消及未知结果
| 情况 | 协同处理 |
| --- | --- |
| WAITING 且未生成执行任务的取消 | 锁订单裁决,解冻资金,写 RELEASE、CANCELLED 回调及审计 |
| 明确未执行的可重试失败 | 只释放资源及旧任务占位,保留订单 HELD 资金,截止前重试;不发终态 FAILED |
| 明确终结失败 | 释放资金及资源,写 RELEASE 和 FAILED 回调,不再重试该订单 |
| 无供应方等待超时 | 按公开等待上限取消并释放资金 |
| 已广播但结果未知、节点离线 | 保留资金和资源占用,核对原 txId,不盲目重派 |
| 链上已委托但交付不足 | MANUAL_REVIEW,保留事实并追踪回收,经审核处置 |
普通失败释放冻结是解冻;成功扣款后返还内部余额才是退款。
### 4.7 到期回收
1. 扫描订单回收计划,包括已委托但未正常成功的异常订单。
2. 使用原确认交易的资源类型和 SUN 本金创建 RECLAIM 任务并保存 source_transaction_id,不按当前参数重算撤销金额;回收 reservation_status=NONE。
3. 同钱包同类型链上操作串行,同地址对同类型只允许一笔占位订单,避免混入其他订单份额。
4. 未解锁则安排下次检查;结果未知继续隔离;部分可回收或份额异常转人工。
5. 撤销确认后若资源尚未恢复,回收状态 RECOVERING。
6. 撤销确认时先写快照屏障、失效旧快照再释放执行占位;本金回收且资源恢复后应用可信新快照,回收 DONE,释放订单 relation_slot,写 RECLAIMED 回调及审计。
回收不改变原履约成功事实,也不自动退款。
### 4.8 人工结算与退款
**结算:** 锁供应商账户及来源订单 → 选择已核验且未被占用的净应收 → 创建结算单及明细 → 独立审批 → 提交 PAYING、唯一 payout_no → 人工付款 → 独立核验唯一付款凭据 → 同事务扣待结算、写 SETTLE、标记 PAID 并审计。PAYING 或付款未知不得重付或释放来源。
**退款:** 创建 rent_refund 幂等请求 → 独立审批费用承担 → 按统一顺序锁账户、订单、退款单并检查结算来源及累计上限 → 追加 REFUND / REVERSAL → 更新订单累计和退款 APPLIED → 同事务写本次退款独立回调及审计。供应商或手续费变化遇到已结算、结算占用或应付不足时转人工;单纯平台承担的商户退款可独立审核。不得制造负余额或重复返还手续费。
## 5. 关键事务与幂等边界
| 操作 | 必须原子协同的主要记录 |
| --- | --- |
| 充值 | account + ledger + event |
| 下单冻结 | order + account + ledger + event |
| 分配执行任务 | order + wallet 预留 + task + event |
| 委托核验成功 | transaction + task + order + wallet + account + ledger + webhook + event |
| 明确失败释放 | task / transaction 状态 + order + wallet + account + ledger + webhook + event,按实际发生阶段处理 |
| 创建结算 | settlement + settlement_item + 来源资格及账户余额锁定校验 + event |
| 确认付款 | settlement + account + ledger + event,明细有效占位继续保留 |
| 退款冲正 | refund + order + account + ledger + webhook + event,并锁定校验结算来源状态 |
| 保护层 | 主要唯一约束或机制 |
| --- | --- |
| 消息重放 | nonce(api_key, scope, nonce) |
| 重复下单 | order(app_id, merchant_order_no) + request_hash |
| 重复有效任务 | task(order_id, task_type, active_slot) |
| 重复任务投递 | 稳定 delivery_message_id + Agent 本地持久幂等 |
| 重复交易归属 | transaction(task_id)、transaction(network, tx_id) |
| 重复记账 | ledger(business_key) |
| 重复结算来源 | settlement_item(order_id, active_slot) |
| 重复付款凭据 | settlement(payment_reference) |
| 重复退款请求 | refund(order_id, request_no) + request_hash |
| 重复回调事件 | webhook(event_no)、webhook(event_key)、webhook(order_id, order_event_sequence) |
| 地址对在租互斥 | order(wallet_id, receiver_address, resource_type, relation_slot) |
| 钱包链上操作互斥 | task(wallet_id, resource_type, wallet_execution_slot) |
| 节点重复上报 | event(event_no),相同编号不同内容拒绝 |
| 旧连接覆盖新连接 | node.session_epoch 条件更新 |
### 2.17 rent_user_package:系统用户套餐绑定
系统用户与具体套餐版本多对多绑定。user_id 对应 sys_user,package_id 对应 rent_package;network/resource_type 从套餐复制,status 控制新单授权,default_slot=1 为该网络该资源的当前项,其他为 NULL。唯一(user_id,package_id)防重复,唯一(user_id,network,resource_type,default_slot)保证分类唯一。created_by 记录管理员,version 和服务器本地时间用于更新与追溯。
管理员选用户→绑定已上架套餐→替换同网络同资源的当前项;应用通过 rent_app.user_id 使用绑定。新单必须指定网络和资源类型,禁止提交套餐ID,服务端匹配此分类的当前有效绑定;订单快照保存绑定编号和用户编号。停用不影响历史订单。详见 [绑定与部署说明](user-package-bindings.md)。当前核心表总计17张,前述16张为原基线。
## 6. 对账与实现注意事项
1. 每日核对账户冻结余额与 HELD 订单、待结算余额与未结净应收、余额投影与不可变流水;差异记录审计并人工处理。
2. 钱包在途预留与 HELD 任务逐笔对应;确认成功时避免链上已扣减和本地预留重复扣减,保留其他未知任务占用。
3. 资源快照必须可信且未过期;Agent 签名前再次查询。冗余是确认时缓冲,不保证整个租期资源额度恒定。
4. Socket 仅负责传输;任务数据库和 Agent 本地持久化负责恢复。断线重连先同步,再允许新单。
5. 本版不是完整复式会计总账,也不包含自动充值识别、自动出金、动态报价或供应商竞价。
6. 初始化脚本的 `IF NOT EXISTS` 不能升级已有旧表;本文仅说明设计,没有执行建表、迁移或资金操作。
+115
View File
@@ -0,0 +1,115 @@
# 租赁资金账户在线充值
资金账户详情页新增「在线充值」和充值记录。用户只需选择账户网络、填写 USDT 金额,不需要输入支付 API 凭证。NILE 测试资产与主网资产严格隔离,充值不会跨网络增加余额。
## 部署与数据库
1. 支付服务数据库执行 `sql/payment_topup_upgrade.sql`,为 `orders` 增加 `payment_network`。此列是新版支付实体必需字段,即使暂不启用在线充值也须执行。脚本为一次性迁移,重复执行前先检查字段。
2. 租赁服务数据库执行 `sql/rent_topup_init.sql`,新增 `rent_topup_order` 与 `rent_topup_notify`,不删除历史表或数据。
3. 同步部署新版支付后端、租赁后端和前端。两套后端可以部署在同一个应用实例,也可以独立部署。
4. 在支付平台创建应用及有效 API 凭证,准备该应用对应的 RSA 公钥文件,确保支付钱包池有可分配地址,并将 `payment.checkout-url` 设置为真实 HTTPS 收银台地址。
`rent_topup_order` 保存用户、账户、网络、请求幂等号、支付单号、金额、收款地址、支付通道公钥快照、状态、补偿租约和最终链上事件。`rent_topup_notify` 保存已经通过 RSA 验签的通知摘要和事件,不保存 Secret、私钥或原始签名。余额与流水继续复用 `rent_account`、`rent_ledger`。
## application-rental.yml 配置
配置位于 `rental.payment`,默认关闭。以下是环境变量示例,替换域名和凭证后再启用:
```properties
RENT_PAYMENT_ENABLED=true
RENT_PAYMENT_NILE_ENABLED=true
RENT_PAYMENT_NILE_BASE_URL=https://pay.example.com
RENT_PAYMENT_NILE_API_KEY=<支付应用API_KEY>
RENT_PAYMENT_NILE_API_SECRET=<支付应用API_SECRET>
RENT_PAYMENT_NILE_PUBLIC_KEY=file:/opt/ruoyi/keys/nile-payment-public.pem
RENT_PAYMENT_NILE_NOTIFY_URL=https://rent.example.com/api/rental/payment/notify/NILE
RENT_PAYMENT_NILE_MIN_AMOUNT=1.00
RENT_PAYMENT_NILE_MAX_AMOUNT=10000.00
RENT_PAYMENT_MAINNET_ENABLED=false
RENT_PAYMENT_MAINNET_BASE_URL=https://pay.example.com
RENT_PAYMENT_MAINNET_API_KEY=<主网支付应用API_KEY>
RENT_PAYMENT_MAINNET_API_SECRET=<主网支付应用API_SECRET>
RENT_PAYMENT_MAINNET_PUBLIC_KEY=file:/opt/ruoyi/keys/mainnet-payment-public.pem
RENT_PAYMENT_MAINNET_NOTIFY_URL=https://rent.example.com/api/rental/payment/notify/MAINNET
RENT_PAYMENT_MAINNET_MIN_AMOUNT=1.00
RENT_PAYMENT_MAINNET_MAX_AMOUNT=10000.00
```
`BASE_URL` 是外部可访问的后端基地址,适配器追加 `/api/v1/order/create-transaction` 和 `/api/v1/order/query`。如果反向代理有路径前缀,基地址需要包含此前缀。`NOTIFY_URL` 必须是支付服务能访问的完整 HTTPS 地址,通道名使用大写。RSA 公钥不是 TLS 证书,也不是租赁应用凭证;应使用支付应用配置中对应的公钥。自签 TLS 证书需要导入运行租赁服务的 JVM 信任库,不能通过关闭证书验证处理。
可选超时配置:`RENT_PAYMENT_CONNECT_TIMEOUT_MS=5000`、`RENT_PAYMENT_READ_TIMEOUT_MS=15000`、`RENT_PAYMENT_RECONCILE_MS=15000`。单次支付 HTTP 总时限为 30 秒。后台核对需要现有 `rental.rpc` 正常可用及对应网络的 USDT 合约配置。
在途订单保存 API Key、公钥、基地址快照,但不保存 API Secret。存在未完成充值时应保持对应通道旧凭证有效;本实现不支持通过覆盖配置无缝轮换在途 Secret,应先完成在途核对再轮换。停止某网络通道也会暂停该网络的支付查询。
## 业务流程与资金安全
### 自签HTTPS支付服务
支付客户端支持独立信任证书,无需修改全局JVM信任库:
```properties
RENT_PAYMENT_NILE_TLS_CERTIFICATE=file:/etc/nginx/certs/fullchain.pem
# 主网若需要独立证书,可另外配置:
RENT_PAYMENT_MAINNET_TLS_CERTIFICATE=file:/etc/nginx/certs/fullchain.pem
```
对应 `rental.payment.nile.tls-certificate-location` / `mainnet.tls-certificate-location`。文件须为经过管理员核对的X.509证书或CA证书(PEM/DER),不能使用privkey.pem或支付RSA公钥。运行后端的用户须有读取权限;容器需挂载文件。证书SAN必须包含支付域名或IP,例如 `IP:192.168.3.103`。修改后重启服务,原充值单会后台重试。
本功能合并当前JVM默认信任锚与指定证书,仅作用于支付HTTP客户端,保留证书有效期和域名校验。请移除此前仅为自签支付服务添加的全局 `-Djavax.net.ssl.trustStore...` 参数(如其他业务仍需要自定义全局信任库,应保留包含完整CA的合并库),恢复TronGrid等调用使用的正常默认CA。不会修复证书域名不匹配、过期或错误代理地址。
1. 登录用户创建充值,服务端校验账户归属、ACTIVE 状态、网络、金额上下限和最多两位小数;以 `user_id + client_request_no` 幂等落库。
2. 在数据库事务外调用项目支付加密协议,明文业务参数包含 `network=NILE/MAINNET`、`amount_currency=USDT`,避免充值金额被业务币汇率转换。未传币种的原支付客户端继续使用原汇率逻辑。
3. 展示真实支付地址、准确金额、二维码、倒计时和收银台链接。每笔充值使用 `rent:<充值单号>` 支付用户标识,隔离支付金额槽位;因此需要持续补充或维护支付钱包池容量。
用户点击「创建支付单并前往支付」后,支付单就绪即自动跳转支付接口返回的 `url`。支付服务的 `payment.checkout-url` 应配置为 `https://你的前端域名/public/usdtPay`,服务端会追加 `tradeId`。旧配置的 `/public/usdtCheckout` 在生成新支付链接时自动转换为 `/public/usdtPay`。若暂未生成支付单,弹窗显示失败阶段并持续轮询,就绪后自动跳转;关闭弹窗不会触发跳转。已有订单可以从详情点击「前往支付」。
4. 支付通知必须通过 `X-Payment-Api-Key` 和 `X-Payment-Rsa-Signature` 验证,仅保存通知收件箱并返回纯文本 `ok`,不会直接修改余额。通知缺失时后台主动查单仍可完成充值。
5. 后台比较支付查询结果的订单号、交易号、网络、地址和金额,随后独立核验对应网络的已确认 USDT Transfer 日志、时间窗口、金额、收款人和交易执行结果。仅链上核验成功才可入账。
6. 同一事务内锁定充值单及资金账户,写入 TOPUP 流水、增加可用余额、标记 CREDITED。人工和自动充值共享 `TOPUP:<network>:<txhash>:<logindex>` 幂等键,避免重复入账。多实例补偿使用数据库租约与所有者校验,过期任务不能回写终态。
支付新订单保存网络快照,扫描按订单网络选择节点;历史 NULL 网络订单继续使用原全局网络配置。历史 NULL 数据不能凭猜测批量回填。
## 接口与状态
支付页在新窗口(或浏览器新标签页)打开,当前资金账户页保留并继续刷新状态。点击创建或重试时同步预留支付窗口,异步生成订单后载入付款链接,减少浏览器拦截;若窗口被拦截或已被用户关闭,页面保留「前往支付」和收银台链接供手动打开。关闭充值弹窗时仅关闭尚未载入付款链接的等待窗口,不关闭已经打开的支付页。
登录接口复用 `rent:portal:view` 权限,不新增菜单:
| 方法 | 路径 | 用途 |
| --- | --- | --- |
| POST | `/rental/topup/create` | 请求体:`network`、字符串 `amount`、唯一 `client_request_no` |
| GET | `/rental/topup/list?network=NILE&page=1` | 当前用户指定网络记录,每页 20 条 |
| GET | `/rental/topup/{topup_no}` | 当前用户充值详情 |
| POST | `/rental/topup/{topup_no}/retry` | 核对本人原单,遵守现有租约和重试间隔,不新建支付订单 |
| POST | `/api/rental/payment/notify/{channel}` | 支付 RSA 通知,channel 为 NILE 或 MAINNET |
支付查单接口增加 `network`、`payment_address`、`payment_amount`、`expiration_time` 字段,保留原有响应字段。创建接口新增可选 `network`、`amount_currency=USDT` 参数,所有参数仍须进入 SecureClient 加密与认证。
公共收银台使用只读接口 `GET /api/v1/order/checkout/{tradeId}`。随机32位交易号应当视为支付链接访问凭据,不公开传播;接口仅返回交易号、网络、金额、地址、状态与有效期,不返回商户订单号、用户身份、回调地址或密钥。反向代理应对公共查询配置限流。支付成功展示收款结果,租赁余额仍由后台独立链上核验入账。无 `tradeId` 时保留原演示创建表单;有 `tradeId` 时直接展示现有订单,不调用演示创建接口或依赖浏览器已有缓存。
状态流转:CREATING → WAITING_PAYMENT → VERIFYING → CREDITED。创建响应不确定进入 CREATE_UNKNOWN 并使用原单号重试;支付端明确过期进入 EXPIRED。订单数据不一致、账户冻结、转账已通过其他入口入账进入 MANUAL_REVIEW。暂时网络异常和链上确认不足继续后台补偿,不生成新支付订单。浏览器关闭不影响后台核对。
仅 `rent_topup_order` 存在不代表支付创建已成功。正常情况下保存本地单后立即调用支付创建接口,无需额外操作。失败会保留原单和安全的 `payment_hint` 阶段提示,后台继续重试。支付创建已成功但查单超时时保留可支付状态与收银台入口。历史错误通道快照需要管理员核对:配置修正并不会自动覆盖已经保存的基地址、公钥或API Key。
运维可以在数据库只读检查 `topup_no/status/query_attempts/last_error/next_query_at`、支付订单及 TOPUP 流水。MANUAL_REVIEW 为人工处理终态,当前没有专用人工审核页面;不得直接改余额或删除幂等流水。确认原因并完成业务审核后,由受控运维流程恢复核对或按既有人工充值流程处理,恢复前须核对原链上事件是否已入账。
## 验证范围
### 充值失败日志定位
默认 INFO 级别即可看到充值阶段日志,不需要打开全局 DEBUG。搜索 `充值创建失败` 或 `充值核对失败`,按 `diagnosticId`、`topupNo` 或 `orderId` 关联同一次处理。
启动及创建充值时会输出「充值配置诊断」「充值开关来源」「充值配置层级检查」。`boundEnabled/boundChannelEnabled` 是配置对象实际绑定值;`resolved` 是当前Spring环境解析值;`source` 列出配置来源(按优先级排列),可发现命令行、系统属性、环境变量或外部YAML覆盖。`ABSENT` 表示未找到配置,`NON_BOOLEAN` 表示值不是true/false,`RESOLUTION_FAILED` 表示占位符解析失败。同时输出激活profile与进程实例标识,方便核对是否重启了正确实例。只检查已知开关,其他环境变量和凭证不会输出。总开关和网络开关现分别返回明确错误提示。
- `CHANNEL_CONFIG`:检查该网络启用状态及凭证是否配置,日志只记录布尔值。
- `PUBLIC_KEY_LOAD`:公钥文件读取或 RSA 解析失败;`fileResource=false` 时检查是否遗漏 `file:` 前缀。
- `LOCAL_ORDER_TRANSACTION`:账户检查、本地充值表查询或插入失败。
- `PAYMENT_RECONCILE`:补偿租约申请等失败,包括旧表缺少 `lease_token` 字段。
- `PAYMENT_CREATE` / `PAYMENT_QUERY`:支付连接、TLS、认证、解析失败;结合支付 HTTP 状态和 businessCode 检查。
若定位到支付响应校验,搜索「充值支付业务失败」:包含HTTP状态、businessCode、dataType、safeMessage及响应字符数。safeMessage只允许项目已知固定错误,未知消息显示UNKNOWN_MESSAGE_REDACTED,避免响应中的SQL或认证信息进入日志。JSON解析失败单独输出安全异常位置,不输出响应正文。
若支付订单已生成但未跳转,搜索「充值支付跳转校验」「充值支付链接已保存」,核对HTTPS、tradeId、有无未来有效期以及本地状态。浏览器充值详情会明确提示链接无效或有效期异常;创建成功后的跳转优先于二维码和列表刷新,避免展示异常影响付款。有效期兼容毫秒时间戳和ISO日期。旧记录中已经保存的错误域名不会随新配置自动改写,需要核对记录来源后处理,不可将支付URL指向仍为占位符的“你的前端域名”。
- `PAYMENT_CREATE_RESPONSE_VALIDATE`:支付返回单号、金额、地址、有效期或收银台地址不符合要求。
- `CHAIN_VERIFY` / `LEDGER_CREDIT`:链上核验或账务事务失败。
异常摘要保留异常因果类型、前五个堆栈位置及 SQLState/数据库错误码,不记录异常原文,避免 SQL 参数、支付响应、Secret、公钥正文和签名进入日志。日志定位到阶段后,再检查对应服务器文件或配置;不要向日志追加完整配置对象。
隔离测试使用 H2 事务和可控支付/链上适配器,覆盖通知验签、重复请求、超时补偿、双网络金额核对、冻结账户、共享幂等键、并发补偿及租约接管。测试不会访问真实支付账户、修改线上数据库或广播交易。上线前仍需在 NILE 配置真实支付通道完成端到端验收。
+56
View File
@@ -0,0 +1,56 @@
# 用户分类套餐绑定与下单
当前规则:一个系统用户在每个“网络 + 资源类型”分类最多一个当前套餐。同一用户最多四个分类:NILE/ENERGY、NILE/BANDWIDTH、MAINNET/ENERGY、MAINNET/BANDWIDTH。所有租赁应用通过 rent_app.user_id 共用绑定。DURATION、PER_ORDER 是计费模式,不增加独立绑定名额;地址上链不需要套餐。
## 数据与业务流程
rent_user_package 保存 user_id、package_id、network、resource_type、status、default_slot、created_by、version、created_at、updated_at。network/resource_type 从服务端套餐记录复制,不接受客户端覆盖。唯一键 (user_id,package_id) 防止重复绑定,(user_id,network,resource_type,default_slot) 保护分类唯一。当前项 ACTIVE/default_slot=1,停用和历史项 DISABLED/default_slot=NULL。
管理员在“租赁套餐”的用户套餐绑定区选择用户及上架套餐。绑定事务锁定用户和套餐,只停用相同网络及资源类型的其他当前项,写入审计和分类日志。其他分类不变。停用不会自动选择其他历史套餐;下架套餐不能下单。已有绑定记录的套餐不能直接修改网络或资源类型,应新建套餐版本后重新绑定。
“我的套餐”切换网络,分别显示能量、带宽卡片及未绑定引导。立即租赁预选所选卡片的网络和资源类型,可在弹窗切换;切换后重置资源数量、租期及报价。请求仅提交network/resource_type,不传套餐ID,先报价,再确认费用创建订单。资金按套餐网络冻结,两个网络余额独立。首页监控也分别显示所选网络的两类套餐状态。
## API 选择规则
POST /api/rental/v1/packages:network 必填,resource_type 可选;只返回本人当前绑定且已上架的套餐,不筛选资源类型时最多两项。不要直接选择返回数组的第一项。
quote 和 create 共用分类解析器:
1. network和resource_type均必填,分别为NILE/MAINNET与ENERGY/BANDWIDTH;服务端从应用归属的user_id解析当前有效绑定。
2. 请求禁止提交package_id,包括空字符串或NULL;响应中的内部套餐编号只用于查询与审计,不能作为下单入参。
3. 多候选、未绑定、绑定停用、套餐下架、网络或资源不匹配均明确拒绝,不回退到任意公开套餐。
4. user_id 来自应用归属,客户端提交不会改变授权。旧客户端必须同步升级为提交network/resource_type并移除package_id。
5. 原商户单号幂等重试保持原套餐和价格快照;绑定更换或增加其他分类不会重复冻结。重试仍必须提交网络和资源,且必须与原订单一致。
分类自动选择示例:
```json
{
"network": "NILE",
"resource_type": "ENERGY",
"receiver_address": "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf",
"merchant_order_no": "RENT-001"
}
```
实际集成应保留报价使用的network、resource_type、资源数量及租期,并将报价amount以expected_amount提交下单;服务端按当前分类绑定重新计价,价格变化则拒绝。订单内部仍保存package_id及不可变快照;原商户单号重试不会重新匹配新套餐。API调试台支持网络、资源类型筛选,并要求从套餐结果中明确选择。
## 部署
新库执行 sql/rent_init.sql。尚无绑定表的旧库先执行 sql/rent_user_package.sql。**已存在绑定表的数据库,备份并停服后执行 sql/rent_user_package_scope.sql,再部署新版后端及前端。** CREATE TABLE IF NOT EXISTS 无法升级旧表。
增量脚本从套餐回填网络、资源类型,先检查孤立引用和分类槽位冲突,再新增分类唯一键并移除 uk_user_default。保留所有历史绑定和订单;不恢复之前已停用的授权。脚本支持重跑,但MySQL DDL隐式提交,发生错误时须修复数据后继续,不能依赖事务回滚全部DDL。执行账户需要建表变更及存储过程权限。
sql/rent_user_package_single.sql 已改为按分类收敛,不再全局停用其他分类。一般升级不需执行;仅在人工核对异常 ACTIVE/NULL 数据后按需使用。
sql/rent_seed_three_packages.sql 仍创建三个NILE示例套餐。指定 @rental_user_id 时,可分别绑定基础65000能量和1500带宽;不同时绑定两个能量套餐,不覆盖已有同分类当前项、历史绑定或价格。示例价格仅用于演示,不自动授权现有用户。
管理接口不变:GET /rental/package/users、GET /rental/package/options、GET /rental/package/bindings/{userId}、POST /rental/package/bind,需要 rent:package:edit;GET /rental/package/bindings 查看本人。is_default 保留兼容,启用即当前分类项,停用清空槽位。
## 验证
隔离测试覆盖四分类共存、同分类替换、停用隔离、越权与不匹配拒绝、多候选拒绝、签名API套餐筛选及报价下单一致性、数据库唯一键、并发绑定串行化、原订单重试与首页网络隔离。使用H2真实事务及行锁,不连接生产数据库或TRON。部署前仍需在目标MySQL版本验证迁移,并做真实登录联调。
本次验证:JDK8 Rental*Test 共115项通过;8个相关前端文件ESLint、Vue模板及分类交互验证、staging完整构建通过。构建保留其他模块已有的3项API导出缺失及包体积警告,产物位于 usdt-ui/dist-rental-package-scope-preview。未执行实际数据库升级或生产部署。
取消套餐ID入参的后续验证:116项Rental*Test、6个相关文件ESLint、分类切换/报价重置/请求不含ID/调试台拒绝旧参数交互检查及最终staging构建通过,保留上述已有构建警告。本次接口调整无新增SQL;前后端及商户调用方应一起升级。
+35
View File
@@ -0,0 +1,35 @@
# 租赁三端实现验证记录
## 2026-11-02 时间口径修复
- JDK8、`-Duser.timezone=Asia/Shanghai` 全后端回归:system 215项、admin 29项,无失败/错误,4项既有测试跳过。
- 主从数据源绑定、时间点往返和URL归一化测试已通过。按用户要求,后续移除了迁移确认开关及对应测试;保留UTC、东八区、纽约时间点往返、响应ISO时间不变和连接配置归一化验证。
- 不处理历史数据,已移除时间迁移SQL及启动确认要求。部署说明见[时间修复与部署](../timezone-fix.md)。未连接生产数据库。
基础验证日期:2026-10-22;内置历史服务验证更新:2026-10-23。以当前工作区为准,不比较历史提交,不操作业务数据库,不执行真实链上广播。
## 已执行验证
| 范围 | 命令或方法 | 结果 |
| --- | --- | --- |
| Java后端回归 | JDK8,`mvn -o -pl ruoyi-admin -am test -q` | 119项(system 91 + admin 28),0失败、0错误,4项原有手动/外网测试跳过 |
| 新增租赁业务 | `RentalBusinessTest` | 23项,覆盖资金事务、并发、退款/结算、认证、任务恢复及可控Socket |
| 内置历史服务 | `RentalHistoryTest` | 29项,覆盖真实增量DDL、稳定确认头采样、参数缺口、连续区块、回执、幂等、租约、两类资源、基线重放、内置核验接入、运营权限和区块响应上限 |
| 云端打包 | JDK8,`mvn -o -pl ruoyi-admin -am package -DskipTests -q` | 成功;已核对target/lib中的ruoyi-system与构建产物哈希一致,包含历史服务类;部署需要同步入口JAR和lib |
| 本地Agent | Node24,`node --test test/agent.test.js` | 10项通过;`node --check src/index.js`通过 |
| Vue页面 | 新增API、租赁组件及原菜单包装页ESLint | 通过 |
| Vue生产构建 | `vue-cli-service build --mode production --dest D:/myprojects/usdt/.codex-rental-build` | 通过,仅既有Browserslist及体积提示;未覆盖原dist |
| SQL与文档 | `python docs/rental/check_schema.py` | 12项通过 |
后端完成回归后仅进行了变量声明拆分及格式整理,另对最终租赁代码重跑23项业务测试。调度采用主键轮转,避免无资源订单占满扫描窗口;资源恢复查询失败也推进重试时间,避免故障记录阻塞后续记录。
## 验证的实际边界
- H2事务与并发测试不等于真实MySQL隔离级别、锁等待和部署迁移验收。初始化及菜单SQL均未执行。
- 可控Socket测试不等于公网WSS、TLS代理、网络半开或真实供应商设备联调。
- 前端完成静态检查及生产构建,尚未完成真实浏览器TronLink及全链路人工验收。
- 尚未执行NILE或MAINNET真实委托、回收和USDT转账。
- 已实现云端内置历史采集和证明,使用固定一致性的确认RPC;未部署真实MySQL或固定TRON节点验证。未启用、缺历史参数或缺基线时仍进入人工核对、保留冻结资金,不自动确认收入;实际回收完成后才允许受保护的解冻操作。内置采集不能补造上线前或停机漏采参数,见 [详细边界](history-service.md)。
- 供应商私钥仅在本地Agent使用;广播默认关闭。退款为内部余额操作,外部结算付款由人工执行并核验原交易,不自动出金。
部署步骤及环境变量见 [implementation.md](implementation.md);Agent安装及本地限制见 [Agent README](../../../rent-agent/README.md)。启用前应在独立NILE环境完成上述外部联调。
+36
View File
@@ -0,0 +1,36 @@
# V2.2 设计验证记录
## 验证范围
本次验证针对初始化 SQL、逐表文档、唯一索引语义及精确金额算例。没有连接或修改项目现有数据库,没有进行真实链上交易。
## 检查方式
1. 使用 SQLGlot 26.33.0 的 MySQL 方言解析完整 rent_init.sql:16 条 CREATE TABLE,0 条不支持的回退命令。该依赖仅安装于临时工具目录,不加入项目依赖。
2. 运行标准库脚本 `python docs/rental/check_schema.py`:从实际 DDL 提取列名和唯一键,在 SQLite 内存库检查重复插入及 NULL 占位语义;同时核对 16 张表文档覆盖、列注释、索引字段引用、本地文档链接及无破坏性语句。
3. 使用 Decimal 核对供应商手续费返还、净额冲正与结算来源一致,以及商户退款中手续费不重复入账。
## 结果
SQLGlot 严格 MySQL 方言解析通过:16 条 CREATE TABLE,无回退命令。离线脚本 12 项检查全部通过:
- 16 表及逐表文档一一覆盖、字段注释、唯一索引字段、无破坏性语句。
- 本地 Markdown 链接存在。
- 同地址对同资源类型互斥及 NULL 释放,多接收者/不同类型可并存。
- 同钱包同类型的委托与回收共享执行互斥。
- 同订单任务尝试与有效占位去重。
- 退款请求去重,同订单多次部分退款回调可写入且业务键、序号防重复。
- 出款授权与付款凭据唯一,未付款 NULL 可并存。
- 结算来源唯一,已付来源不能再占用。
- 跨账户重复充值业务键冲突。
- 一任务一交易及同网络交易哈希去重。
- Decimal 金额例中供应商返还手续费与结算来源一致,商户退款不重复加手续费。
脚本实际总数为 12。首轮发现验证记录尚未创建,以及一个记账键长度示例断言不成立;均已修正并完整重跑通过。
## 未覆盖内容
- 当前机器 Docker Linux 引擎未启动,也未发现可直接使用的 MySQL/MariaDB 命令。因此没有声称 MySQL 5.7/8.0 真实建表、索引字节限制、事务隔离或死锁测试通过。
- SQLite 映射仅验证实际唯一键的等值冲突及 NULL 语义,未模拟 MySQL 字段类型、字符集、外键或业务状态机。
- 租赁应用服务和 Agent 尚未实现,无法验证真实并发记账、CAS、出款恢复、断线恢复、HMAC 或状态转换;验收要求见 business-review-v2.2.md 第 8 节。
- 未执行 NILE/MAINNET 委托或回收,非锁定委托条件、历史参数取证、资源使用债务及恢复判定仍需真实网络验证。
+75
View File
@@ -0,0 +1,75 @@
# 归集与代付资源租赁
## 启用与兼容
默认关闭:`USDT_RESOURCE_RENTAL_ENABLED:USDT_RESOURCE_RENTAL_ENABLED=false`。关闭时保留原转账通道、燃烧预算、审核和账务结算行为,不查询新增资源表。此功能仅用于归集、代付,普通钱包操作不自动购买资源。
部署前备份数据库,依次执行 `sql/chain_executor.sql`、`sql/resource_rental.sql`。均为增量建表,不删除旧数据。后端与执行器必须共享同一数据库;远程模式还需按 [执行器说明](chain-executor.md) 部署执行器。不要在生产数据库上运行测试脚本。
支付后端外部配置:
```yaml
usdt:
resource-rental:
enabled: true
provider: INTERNAL # INTERNAL 或 DUIYA,仅影响尚未授权的新准备记录
arrival-timeout-seconds: 300
rental:
master-key: ${RENT_MASTER_KEY} # 外部注入的Base64编码32字节随机密钥
```
也可使用已接入的环境变量 `USDT_RESOURCE_RENTAL_ENABLED`、`USDT_RESOURCE_RENTAL_PROVIDER`、`USDT_RESOURCE_ARRIVAL_TIMEOUT_SECONDS`。所有支付实例的密钥必须一致;不要随意更换,原订单查询仍需要解密原配置。执行器只核验资源和签名,不需要平台API密钥或租赁加密密钥。
## 保存平台配置
管理员可在 `USDTmanage/usdtConfig` 全局配置页的“资源租赁平台”页签管理连接、租赁策略与费用上限,查看当前部署启用状态和最近100条版本记录。修改保存为新版本;API Key和Secret均不回显,修改时留空沿用原凭据。新增平台/网络必须填写完整凭据。页面操作沿用 `system:usdtConfig:edit` 权限。
使用已登录管理员的 `system:usdtConfig:edit` 权限调用 `POST /system/chain-resources/config`。凭据为只写字段,后端加密入库;每次保存新增配置版本,原订单始终使用其 `config_id`,切换平台不会重购原单。不要把实际密钥写入文档、命令行或日志。
自有平台请求示例(占位符须在受控配置客户端中替换):
```json
{
"provider": "INTERNAL",
"network": "NILE",
"baseUrl": "https://rental.example.com",
"apiKey": "<API Key>",
"apiSecret": "<API Secret>",
"durationSeconds": 3600,
"energyStep": 30000,
"bandwidthStep": 100,
"maxOrderCost": 10,
"maxExecutionCost": 20
}
```
`baseUrl` 为HTTPS站点根地址,自有平台适配器自动拼接 `/api/rental/v1`。自有租赁账户需要启用应用及API凭据、绑定当前网络的能量/带宽默认套餐并准备可用余额。`energyStep`、`bandwidthStep`、`durationSeconds` 必须匹配对应默认套餐的数量和周期倍数;不传 `package_id`。费用单位为USDT。
兑呀使用 `provider=DUIYA`、`network=MAINNET`、`baseUrl=https://weidubot.cc/api/v2`,按需设置 `energyPeriod`(默认`1h`)、`bandwidthPeriod`(默认`1day`)。费用单位为TRX;能量最低30000、带宽最低100,按配置步长向上取整。使用资源订单 `buy_energy/buy_net`,不调用速充接口。公开文档未确认测试网支持,DUIYA的NILE请求会被拒绝。
每类资源检查 `maxOrderCost`,每个业务准备检查 `maxExecutionCost`;人工额外受页面确认的报价上限限制。归集各地址独立计费。这里没有每日总费用额度,部署时按业务量设置单笔上限和平台余额。兑呀创建接口未提供锁价字段,预估费用无法替代平台最终扣费,首次上线需小额核对实际计价。
## 操作流程
人工执行:在归集/代付页面选择“手动输入配置密码”,点击执行后先展示实时资源和报价。可选择租赁,或沿用原转账规则。确认租赁仅购买缺口;页面只读轮询,支付后端独立查询链上,必须能量、带宽均足额才显示密码输入。输入密码并确认广播后,签名前再次核验。资源已足额时不购买。密码不持久化、不交给资源Worker,关闭弹窗不会自动转账。
远程执行:提交业务后保持原执行中状态;支付后端资源Worker为远程排队指令自动准备资源。执行器资源未就绪时仍保持QUEUED,不解锁钱包,不签名;就绪后复检、构造并签名一次,持久化后广播。等待期间的状态和错误显示在“最近执行记录”中。原转账授权有效期仍为10分钟,资源等待不会无限延长授权。
链上查询失败不是资源为零,不会因此付费。租赁平台返回成功或交付成功均不能证明可用资源满足,只有支付系统读取指定网络的实时 `limit-used` 并重新估算本次操作,才会置为READY。估算失败拒绝购买,不使用页面的默认能量兜底值。
## 防重复与恢复
- 同一业务唯一准备记录;同一次准备每类资源唯一订单。本地CREATED→SUBMITTING的数据库CAS是实际付费调用屏障,浏览器、多个后端实例、进程重启均复用原单。
- 创建请求禁止HTTP自动重试和重定向。超时/响应丢失/进程中断保留SUBMIT_UNKNOWN,不回到CREATED。自有平台可按原商户单号只读核对;兑呀未文档化商户幂等号,结果未知必须人工核对平台账单,不能自动重下。
- 等待超时显示TIMEOUT,可点“继续检查原单”;此操作只延长到账检测,不新建租赁订单、不更换平台、不延长转账授权。关闭页面后服务仍继续检查,重新打开复用原记录。
- REVIEW阻止转账,即使地址后来资源足额也不会绕过未知/失败租赁订单;需运维核实原单。当前版本不提供自动补租第二轮或清除未知订单的按钮,避免重复扣费。已确定交付但资源仍不足时,可继续原单检测或由管理员从其他渠道补充资源,不自动再购买。
- 同网络同发送钱包独占准备,主钱包代付按地址串行。签名后占用不按超时回收,只有链上收据确认资源已消耗才释放。已明确链上失败的原交易可复用原租赁资源重新预检,不自动重租。
- 已租赁但尚未执行的准备保留地址占用,关闭弹窗不释放,也不撤销已付费订单。管理员应完成原操作或核对异常后处理;不要直接删除准备/订单/地址占用表记录。
业务审核、代付冻结与最终链上确认结算沿用原实现。租赁费用由平台账户支付,不混入商户USDT本金结算。一个归集地址失败不终止其他地址的后端准备,但人工批次需全部资源就绪才允许输入密码;可先取消尚未执行且无需继续的明细,再预检剩余明细。
## 验证范围
隔离H2测试使用真实增量SQL和可控链上/平台替身,覆盖并发唯一订单、延迟到账、两类资源分别到账、签名前回落、未知结果不重下、超时续查、原平台配置引用、费用上限和同地址互斥。既有链上执行与独立执行器启动测试继续运行。前端使用实际Vue/Element组件的模拟接口检查桌面1200px和窄屏390px,验证刷新不重复购买、到账前不展示密码、确认后才执行。
未进行真实钱包签名、真实平台扣费或生产数据库升级。上线需先配置自有平台NILE环境进行受控联调;DUIYA需在主网小额核对凭据、周期、扣费和代理到账。
+28
View File
@@ -0,0 +1,28 @@
# Telegram Webhook 部署
## 环境变量
```bash
export TELEGRAM_ENABLED=true
export TELEGRAM_BOT_TOKEN='BotFather签发的Token'
export TELEGRAM_AUDIT_CHAT_ID='审核群Chat ID'
export TELEGRAM_WEBHOOK_URL='https://pay.example.com/api/telegram/webhook'
export TELEGRAM_WEBHOOK_SECRET='使用字母数字下划线连字符组成的随机值'
export TELEGRAM_ALLOWED_USER_IDS='123456789,987654321'
```
`TELEGRAM_WEBHOOK_URL` 必须是公网可访问的 HTTPS 地址,并由反向代理转发到后端
`POST /api/telegram/webhook`。不要把 Bot Token 或 Webhook Secret 写入仓库、日志或前端配置。
## 注册与检查
1. 使用管理员账号进入“Telegram 审核记录”页面。
2. 点击“Webhook 设置”,页面会先查询 Telegram 当前状态。
3. 点击“按配置重新注册”后,后端使用环境变量调用 Telegram `setWebhook`。
4. 确认页面显示“已注册”,且“当前地址”和“配置地址”一致。
注册操作仅订阅 `callback_query`,并同时设置 `secret_token`。Telegram 回调时,系统会校验
`X-Telegram-Bot-Api-Secret-Token` 请求头。所有 Telegram HTTP 调用的连接和读取超时均为 60 秒。
部署后应创建一条测试归集审核,确认消息可以发送、授权用户可以审核、未授权用户被拒绝,且
`pending_update_count` 不持续增长。
+44
View File
@@ -0,0 +1,44 @@
# 数据库时间与服务器相差8小时的修复
## 根因与统一规则
旧租赁实现将DATETIME(3)按UTC写入,而支付Date、日志和Jackson使用JVM本地时区,因此东八区服务器查看租赁原始记录会相差8小时。
修复后,租赁DATETIME使用服务器/JVM本地时间;SQL CURRENT_TIMESTAMP和MySQL连接会话采用相同时区。协议签名、链上毫秒时间戳及HTTP带Z的ISO时间仍表示真实时间点。
按用户要求,本次只修复代码,不修改历史记录;已移除历史数据迁移脚本、迁移标记逻辑及启动确认开关,启动无需配置RENT_LOCAL_TIME_STORAGE_READY。旧记录保持原值,不会自动加8小时。
## 修复范围
- RentalValues统一本地时间写入及Timestamp/LocalDateTime读取。
- 快照、节点心跳、订单调度、回收、任务期限、链上证明及历史保留截止时间使用统一转换。
- 充值失效时间、提现交易时间与审核时间使用同一口径。
- 历史采集/清理租约和worker到期判断使用CURRENT_TIMESTAMP。
- 看板按本地自然日统计,timezone返回服务器时区;接口ISO时间保持真实时间点。
- MySQL主从连接统一connectionTimeZone=LOCAL及forceConnectionTimeZoneToSession=true,消除驱动固定GMT+8与JVM时区不一致的问题。Connector/J使用8.0.30。
- 七牛配置对象移除独立硬编码GMT+8的序列化设置,遵循JVM/Jackson时区。
- 初始化DDL、实体字段说明、套餐种子及绑定维护SQL同步更新。
UTC 02:00核账和UTC 03:15历史清理是明确安排的定时执行时间,保持不变。JWT、HMAC时间戳、链上epoch毫秒和签名载荷不变。
## 部署与核对
部署更新后的服务及依赖lib(包括Connector/J 8.0.30),保持JVM时区与服务器业务时区一致。东八区示例:
```bash
java -Duser.timezone=GMT+08:00 -jar ruoyi-admin.jar
```
使用Asia/Shanghai等命名时区时,MySQL需要加载对应时区表,驱动会设置同一会话时区。运行期间不要改变JVM时区。
检查启动日志“数据库时间配置”,再核对新订单、快照更新时间与服务器当前时间。数据库会话可查询:
```sql
SELECT NOW(3), UTC_TIMESTAMP(3), @@session.time_zone, @@global.time_zone, @@system_time_zone;
```
接口ISO字符串仍可带Z,表示UTC格式的同一真实时间点,不表示数据库仍有8小时偏移。
## 验证范围
已在东八区执行后端回归,以及UTC、东八区、纽约时区的时间点往返、响应序列化、JDBC URL归一化和主从配置绑定测试。未操作生产数据库或执行真实链上广播。
+42
View File
@@ -0,0 +1,42 @@
# Google Authenticator 动态码登录
保留原密码登录和 Google OAuth 登录,新增独立的“账号 + 六位动态码 + 图形验证码”登录方式。动态码登录不是强制双因素验证,不改变其他登录方式的认证规则。
## 部署
1. 在现有业务数据库执行增量脚本 `sql/totp_auth.sql`,不需要修改 `sys_user` 或 Google 绑定表。
2. 使用密码学安全随机源生成 32 字节并转为 Base64,通过环境变量 `TOTP_ENCRYPTION_KEY` 配置;不要提交到代码仓库。所有后端实例使用相同密钥,备份必须与数据库分开保管。留空时无法新增绑定。更换密钥前必须迁移已有密文。
3. 可选设置 `TOTP_ISSUER`,默认 `USDT PAY`。使用 HTTPS,服务器和手机开启自动时间同步。
4. 编译部署前后端。Redis 用于短期绑定和限流,必须可用。数据库凭据表采用 InnoDB。
PowerShell 生成密钥(在部署服务器交互环境执行,输出仅写入受控配置):
```powershell
$totpKeyBytes = New-Object byte[] 32
$totpRng = [Security.Cryptography.RandomNumberGenerator]::Create()
$totpRng.GetBytes($totpKeyBytes)
$env:TOTP_ENCRYPTION_KEY = [Convert]::ToBase64String($totpKeyBytes)
$totpRng.Dispose()
```
## 使用
- 先用密码或已绑定 Google 账号登录,打开“个人中心 → 账号安全 → Google Authenticator 动态码”。
- 输入本地密码生成二维码;用 Google Authenticator 扫码,或手动输入页面展示的设置密钥,再输入手机六位动态码确认绑定。二维码在浏览器本地生成。
- 临时绑定十分钟过期,未经验证不会启用。确认绑定所用码已消费,等手机刷新下一组码后再用于登录。
- 登录页切换“动态码登录”,输入本地用户名、六位动态码和图形验证码。前导零必须保留。
- 解绑需要本地密码及未使用过的动态码。遗失认证器时可用原密码或已绑定 Google 登录;需要重置绑定时由管理员核实身份后通过受控流程处理,系统不公开免验证重置接口。
## API
| 方法 / 路径 | 认证 / 请求 |
| --- | --- |
| `POST /auth/totp/login` | 匿名;`username, totpCode, code, uuid`,其中 code 是图形验证码;返回原有 `token` 字段 |
| `GET /auth/totp/binding` | 当前 JWT;返回 `data.enabled`、`data.bound`,不返回密钥 |
| `POST /auth/totp/setup` | 当前 JWT + `password`;返回 `data.secret`、`data.otpauthUrl`,禁止缓存或记录响应 |
| `POST /auth/totp/bind` | 当前 JWT + `password, totpCode` |
| `POST /auth/totp/unbind` | 当前 JWT + `password, totpCode` |
时间步为 30 秒,SHA-1,6 位,容忍前后各一个时间步。数据库 CAS 原子消费时间步,包含绑定确认在内的同一时间步不可重复成功,也不能倒退使用旧码。账号每五分钟最多十次动态码登录尝试,管理操作另计十次;连接来源每五分钟最多五十次登录尝试。反向代理部署下连接来源按代理地址计数,可另在代理层对真实来源限流,不信任任意客户端传入的转发头。
凭据使用 AES-256-GCM 加密,绑定用户 ID 为附加认证数据。密钥不加入用户实体、常规响应或 JWT。数据库、Redis 异常时拒绝认证。不要在网关、APM 或应用中开启登录请求体和绑定响应体采集。
+26
View File
@@ -0,0 +1,26 @@
# TRON HTTP 数据源配置
TronGrid 和 TronScan 使用独立 API Key,即使请求头名称相同也不能混用。
```sh
export TRON_GRID_API_KEY='你的TronGrid密钥'
export TRONSCAN_API_KEY='你的TronScan密钥'
```
重启后端生效。原有 `tron.chain-data.api-key` 仍仅代表 TronGrid,
新增 `tron.chain-data.tronscan-api-key` 代表 TronScan。
交易查询按现有端点列表顺序切换,TronGrid 使用
`/v1/accounts/{address}/transactions/trc20`,TronScan 使用
`/api/token_trc20/transfers`,映射为统一的地址、毫秒时间、交易哈希和原始最小单位金额。
TronScan 仅接受 `confirmed=true`、`contractRet=SUCCESS` 且合约匹配的记录。
单次 TronScan 查询最多50条,当前实现不提供历史全量分页,适用于现有近期待支付订单扫描。
自定义代理地址可使用 `tronscan|https://proxy.example` 或
`trongrid|https://proxy.example` 显式指定交易接口类型;未指定时按域名识别,其他域名默认为TronGrid。
账户端点列表仅配置兼容 `/api/accountv2` 的 TronScan 服务。
账户汇总使用 TronScan Key,Trident RPC 使用 TronGrid Key。
连接和读取超时各60秒,全部交易源失败时保留订单待支付状态,下一轮继续查询。
账户汇总全部失败时沿用现有零值降级;不代表链上真实资源为0。
未使用真实生产凭证进行端到端验证,需部署环境验证两平台权限及配额。
+21
View File
@@ -0,0 +1,21 @@
# 地址管理统计与商户只读详情
管理员和商户地址列表提供总地址、启用地址、USDT/TRX余额及可用能量、带宽汇总。统计使用数据库最新快照,不表示查询时刻的链上余额;用户可在钱包详情点击“刷新链上数据”更新对应快照。
## 管理端统计接口
- 管理员:`GET /system/address/statistics`,权限 `system:address:list`。
- 商户:`GET /system/address/user/statistics`,权限 `system:address:user-list`,服务端强制使用当前用户ID。
- 入参复用地址列表的筛选字段,包括 `token`、`status`、`appId`、`userId`、`walletUserName`。商户传入的 `userId` 不生效。
- 响应 `data`:`total`、`enabled`、`usdtBalance`、`trxBalance`、`energy`、`bandwidth`。余额和资源合计返回字符串以保留精度。
- 列表和统计共享 SQL 条件,排除软删除记录,并保持既有的已分配钱包范围(`wallet_user_name is not null`),不包含未分配地址池。
## 操作与权限
两个列表移除修改、删除按钮及对应页面处理方法;已有新增入口和管理员导出保留。此页面调整不移除其他内部模块使用的服务方法,也不删除历史记录。
商户详情继续展示余额、账户、质押和代理信息,仅保留链上快照刷新操作,不显示资源估算、转账、质押、取消质押、代理、取消代理和广播。
上述资金及资源操作接口和估算接口要求独立 `system:address:operate` 权限;普通商户 `system:address:user-query` 不再授权这些接口。管理员操作角色如需执行,必须已有该权限。链上查询和代理详情继续允许查看权限,并执行钱包归属校验。
无需数据库结构或菜单迁移脚本。部署需同步更新前后端。
+281
View File
@@ -0,0 +1,281 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi</artifactId>
<version>3.4.0</version>
<name>ruoyi</name>
<url>http://www.ruoyi.vip</url>
<description>susdt管理系统</description>
<properties>
<ruoyi.version>3.4.0</ruoyi.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
<druid.version>1.2.4</druid.version>
<bitwalker.version>1.21</bitwalker.version>
<swagger.version>2.9.2</swagger.version>
<kaptcha.version>2.3.2</kaptcha.version>
<pagehelper.boot.version>1.3.0</pagehelper.boot.version>
<fastjson.version>1.2.75</fastjson.version>
<oshi.version>5.6.0</oshi.version>
<jna.version>5.13.0</jna.version>
<commons.io.version>2.5</commons.io.version>
<commons.fileupload.version>1.3.3</commons.fileupload.version>
<commons.collections.version>3.2.2</commons.collections.version>
<poi.version>4.1.2</poi.version>
<velocity.version>1.7</velocity.version>
<jwt.version>0.9.1</jwt.version>
</properties>
<distributionManagement>
<repository>
<id>maven-releases</id>
<url>http://192.168.3.243:8081/repository/maven-releases/</url>
</repository>
<snapshotRepository>
<id>snapshots</id>
<url>http://192.168.3.243:8081/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>
<!-- 依赖声明 -->
<dependencyManagement>
<dependencies>
<!-- SpringBoot的依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.13.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--阿里数据库连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- 解析客户端操作系统、浏览器等 -->
<dependency>
<groupId>eu.bitwalker</groupId>
<artifactId>UserAgentUtils</artifactId>
<version>${bitwalker.version}</version>
</dependency>
<!-- pagehelper 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>${pagehelper.boot.version}</version>
<exclusions>
<exclusion>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-autoconfigure</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 获取系统信息 -->
<dependency>
<groupId>com.github.oshi</groupId>
<artifactId>oshi-core</artifactId>
<version>${oshi.version}</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>${jna.version}</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>${jna.version}</version>
</dependency>
<!-- swagger2-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${swagger.version}</version>
<exclusions>
<exclusion>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
</exclusion>
<exclusion>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- swagger2-UI-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>${swagger.version}</version>
</dependency>
<!--io常用工具类 -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>${commons.io.version}</version>
</dependency>
<!--文件上传工具类 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>${commons.fileupload.version}</version>
</dependency>
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>${poi.version}</version>
</dependency>
<!--velocity代码生成使用模板 -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>${velocity.version}</version>
<exclusions>
<exclusion>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- collections工具类 -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>${commons.collections.version}</version>
</dependency>
<!-- 阿里JSON解析器 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!--Token生成与解析-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>${jwt.version}</version>
</dependency>
<!--验证码 -->
<dependency>
<groupId>com.github.penggle</groupId>
<artifactId>kaptcha</artifactId>
<version>${kaptcha.version}</version>
</dependency>
<!-- 定时任务-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-quartz</artifactId>
<version>${ruoyi.version}</version>
</dependency>
<!-- 代码生成-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-generator</artifactId>
<version>${ruoyi.version}</version>
</dependency>
<!-- 核心模块-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-framework</artifactId>
<version>${ruoyi.version}</version>
</dependency>
<!-- 系统模块-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-system</artifactId>
<version>${ruoyi.version}</version>
</dependency>
<!-- 通用工具-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common</artifactId>
<version>${ruoyi.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<modules>
<module>ruoyi-admin</module>
<module>ruoyi-system</module>
<module>usdt-chain-executor</module>
</modules>
<packaging>pom</packaging>
<dependencies>
</dependencies>
<build>
<defaultGoal>install</defaultGoal>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>public</id>
<name>aliyun nexus</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<releases>
<enabled>true</enabled>
</releases>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>public</id>
<name>aliyun nexus</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</project>
+288
View File
@@ -0,0 +1,288 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>ruoyi</artifactId>
<groupId>com.ruoyi</groupId>
<version>3.4.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<packaging>jar</packaging>
<artifactId>ruoyi-admin</artifactId>
<description>
web服务入口
</description>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.25.5</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- 启动入口直接使用系统模块的诊断类,显式声明以保证多模块构建先编译当前源码。 -->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-system</artifactId>
</dependency>
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>19970182</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-javacv</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-djl</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-ec</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-plugin</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.belerweb</groupId>
<artifactId>pinyin4j</artifactId>
<version>2.5.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.madgag.spongycastle/prov -->
<dependency>
<groupId>com.madgag.spongycastle</groupId>
<artifactId>prov</artifactId>
<version>1.58.0.0</version>
</dependency>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.25.5</version>
</dependency>
<dependency>
<groupId>com.hankcs</groupId>
<artifactId>hanlp</artifactId>
<version>portable-1.8.1</version>
</dependency>
<!-- swagger2-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
</dependency>
<!--防止进入swagger页面报类型转换错误,排除2.9.2中的引用,手动增加1.5.21版本-->
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
<version>1.5.21</version>
</dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-models</artifactId>
<version>1.5.21</version>
</dependency>
<!-- swagger2-UI-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
</dependency>
<!-- Mysql驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<!-- LOCAL及强制会话时区需要8.0.23+,与Druid时间归一化一起部署。 -->
<version>8.0.30</version>
</dependency>
<!-- 核心模块-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-framework</artifactId>
</dependency>
<!--
Google OpenID Connect运行时依赖必须由最终启动模块显式携带。
本项目使用外置lib目录启动,不能只依赖ruoyi-framework的传递依赖,
否则仅更新主程序或使用旧模块POM打包时会缺少JsonFactory等类。
-->
<dependency>
<groupId>com.google.api-client</groupId>
<artifactId>google-api-client</artifactId>
<version>1.34.1</version>
</dependency>
<dependency>
<groupId>com.google.http-client</groupId>
<artifactId>google-http-client</artifactId>
<version>1.41.8</version>
</dependency>
<dependency>
<groupId>com.google.http-client</groupId>
<artifactId>google-http-client-gson</artifactId>
<version>1.41.8</version>
</dependency>
<!-- 定时任务-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-quartz</artifactId>
</dependency>
<!-- 代码生成-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-generator</artifactId>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-custom</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-exam</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-gis</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-thymeleaf</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>4.1.2</version>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>luqj-common</artifactId>
<version>3.4.0</version>
</dependency>
<!-- mybatis plus 代码生成器 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.4.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-autoconfigure</artifactId>
<version>1.3.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- <plugin>-->
<!-- <groupId>org.springframework.boot</groupId>-->
<!-- <artifactId>spring-boot-maven-plugin</artifactId>-->
<!-- <version>2.1.1.RELEASE</version>-->
<!-- <configuration>-->
<!-- <fork>true</fork> &lt;!&ndash; 如果没有该配置,devtools不会生效 &ndash;&gt;-->
<!-- </configuration>-->
<!-- <executions>-->
<!-- <execution>-->
<!-- <goals>-->
<!-- <goal>repackage</goal>-->
<!-- </goals>-->
<!-- </execution>-->
<!-- </executions>-->
<!-- </plugin>-->
<!-- <plugin> -->
<!-- <groupId>org.apache.maven.plugins</groupId> -->
<!-- <artifactId>maven-war-plugin</artifactId> -->
<!-- <version>3.1.0</version> -->
<!-- <configuration>-->
<!-- <failOnMissingWebXml>false</failOnMissingWebXml>-->
<!-- <warName>${project.artifactId}</warName>-->
<!-- </configuration> -->
<!-- </plugin>-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.6</version>
<configuration>
<archive>
<manifest>
<mainClass>com.ruoyi.RuoYiApplication</mainClass> //指定Springboot程序启动类
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix> //指定依赖的jar包相对于本程序jar的位置
</manifest>
<manifestEntries>
<Class-Path>./</Class-Path>
</manifestEntries>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>target/lib/</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<!-- <plugin>-->
<!-- <groupId>org.apache.maven.plugins</groupId>-->
<!-- <artifactId>maven-assembly-plugin</artifactId>-->
<!-- <version>3.0.0</version>-->
<!-- <configuration>-->
<!-- &lt;!&ndash; not append assembly id in release file name &ndash;&gt;-->
<!-- <appendAssemblyId>false</appendAssemblyId>-->
<!-- <descriptors>-->
<!-- <descriptor>src/main/assembly/release.xml</descriptor>-->
<!-- </descriptors>-->
<!-- </configuration>-->
<!-- <executions>-->
<!-- <execution>-->
<!-- <id>make-assembly</id>-->
<!-- <phase>package</phase>-->
<!-- <goals>-->
<!-- <goal>single</goal>-->
<!-- </goals>-->
<!-- </execution>-->
<!-- </executions>-->
<!-- </plugin>-->
</plugins>
<finalName>${project.artifactId}</finalName>
</build>
</project>
+54
View File
@@ -0,0 +1,54 @@
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
<id>dist</id>
<formats>
<format>tar.gz</format>
</formats>
<includeBaseDirectory>true</includeBaseDirectory>
<fileSets>
<fileSet>
<directory>src/main/bin</directory>
<outputDirectory>./</outputDirectory>
<directoryMode>0777</directoryMode>
<includes>
<include>**/*</include>
</includes>
<fileMode>0777</fileMode>
<lineEnding>unix</lineEnding>
</fileSet>
<fileSet>
<directory>target/classes</directory>
<outputDirectory>./</outputDirectory>
<includes>
<include>*.properties</include>
<include>*.yml</include>
</includes>
<excludes>
<exclude>**/*.class</exclude>
<exclude>*prod.yml</exclude>
</excludes>
</fileSet>
<fileSet>
<directory>target</directory>
<outputDirectory>./</outputDirectory>
<includes>
<include>*.jar</include>
</includes>
</fileSet>
<fileSet>
<directory>target/lib</directory>
<outputDirectory>lib</outputDirectory>
<includes>
<include>*.jar</include>
</includes>
</fileSet>
<fileSet>
<directory>mahout-spark-lib</directory>
<outputDirectory>mahout-spark-lib</outputDirectory>
<includes>
<include>*</include>
</includes>
</fileSet>
</fileSets>
</assembly>
+81
View File
@@ -0,0 +1,81 @@
#!/bin/bash
#这里可替换为你自己的执行程序,其他代码无需更改
APP_NAME=ruoyi-admin.jar
DIR=$(dirname $0)
#DIR=../
echo $DIR
#使用说明,用来提示输入参数
usage() {
echo "Usage: sh deploy.sh [start|stop|restart|status]"
exit 1
}
#检查程序是否在运行
is_exist(){
pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' `
#如果不存在返回1,存在返回0
if [ -z "${pid}" ]; then
return 1
else
return 0
fi
}
#启动方法
start(){
is_exist
if [ $? -eq "0" ]; then
echo "${APP_NAME} is already running. pid=${pid} ."
else
echo "正在启动程序:${APP_NAME}"
#nohup java -jar $DIR/$APP_NAME > /dev/null 2>&1 &
nohup java -Xms512m -Xmx1024m -jar $DIR/$APP_NAME >> lu-admin.out &
echo "程序启动完毕"
fi
}
#停止方法
stop(){
is_exist
if [ $? -eq "0" ]; then
kill -9 $pid
echo "${APP_NAME} 已经停止"
else
echo "${APP_NAME} is not running"
fi
}
#输出运行状态
status(){
is_exist
if [ $? -eq "0" ]; then
echo "${APP_NAME} is running. Pid is ${pid}"
else
echo "${APP_NAME} is NOT running."
fi
}
#重启
restart(){
stop
start
}
#根据输入参数,选择执行对应方法,不输入则执行使用说明
case "$1" in
"start")
start
;;
"stop")
stop
;;
"status")
status
;;
"restart")
restart
;;
*)
usage
;;
esac
@@ -0,0 +1,17 @@
package com.ruoyi;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import java.util.Base64;
public class BCryptMain {
public static void main(String[] args) {
BCryptPasswordEncoder encoder =
new BCryptPasswordEncoder();
System.out.println(
encoder.encode("123456")
);
System.out.println(new String(Base64.getEncoder().encode("lu7213:123456".getBytes())));
}
}
@@ -0,0 +1,439 @@
/*
* Copyright (c) 2011-2020, baomidou (jobob@qq.com).
* <p>
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
* <p>
* https://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.ruoyi;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.DialectFactory;
import com.baomidou.mybatisplus.extension.plugins.pagination.DialectModel;
import com.baomidou.mybatisplus.extension.plugins.pagination.dialects.IDialect;
import com.baomidou.mybatisplus.extension.toolkit.JdbcUtils;
import com.baomidou.mybatisplus.extension.toolkit.PropertyMapper;
import com.baomidou.mybatisplus.extension.toolkit.SqlParserUtils;
import lombok.Data;
import lombok.NoArgsConstructor;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Alias;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Function;
import net.sf.jsqlparser.expression.LongValue;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.*;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import java.sql.SQLException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* 分页拦截器
* <p>
* 默认对 left join 进行优化,虽然能优化count,但是加上分页的话如果1对多本身结果条数就是不正确的
*
* @author hubin
* @since 3.4.0
*/
@Data
@NoArgsConstructor
@SuppressWarnings({"rawtypes"})
public class PaginationInnerInterceptor implements InnerInterceptor {
protected static final List<SelectItem> COUNT_SELECT_ITEM = Collections.singletonList(defaultCountSelectItem());
protected static final Map<String, MappedStatement> countMsCache = new ConcurrentHashMap<>();
protected final Log logger = LogFactory.getLog(this.getClass());
/**
* 获取jsqlparser中count的SelectItem
*/
private static SelectItem defaultCountSelectItem() {
Function function = new Function();
ExpressionList expressionList = new ExpressionList(Collections.singletonList(new LongValue(1)));
function.setName("COUNT");
function.setParameters(expressionList);
return new SelectExpressionItem(function);
}
/**
* 溢出总页数后是否进行处理
*/
protected boolean overflow;
/**
* 单页分页条数限制
*/
protected Long maxLimit;
/**
* 数据库类型
* <p>
* 查看 {@link #findIDialect(Executor)} 逻辑
*/
private DbType dbType;
/**
* 方言实现类
* <p>
* 查看 {@link #findIDialect(Executor)} 逻辑
*/
private IDialect dialect;
public PaginationInnerInterceptor(DbType dbType) {
this.dbType = dbType;
}
public PaginationInnerInterceptor(IDialect dialect) {
this.dialect = dialect;
}
/**
* 这里进行count,如果count为0这返回false(就是不再执行sql了)
*/
@Override
public boolean willDoQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
IPage<?> page = ParameterUtils.findPage(parameter).orElse(null);
if (page == null || page.getSize() < 0 || !page.isSearchCount()) {
return true;
}
BoundSql countSql;
MappedStatement countMs = buildCountMappedStatement(ms, page.countId());
if (countMs != null) {
countSql = countMs.getBoundSql(parameter);
} else {
countMs = buildAutoCountMappedStatement(ms);
String countSqlStr = autoCountSql(page.optimizeCountSql(), boundSql.getSql());
PluginUtils.MPBoundSql mpBoundSql = PluginUtils.mpBoundSql(boundSql);
countSql = new BoundSql(countMs.getConfiguration(), countSqlStr, mpBoundSql.parameterMappings(), parameter);
PluginUtils.setAdditionalParameter(countSql, mpBoundSql.additionalParameters());
}
CacheKey cacheKey = executor.createCacheKey(countMs, parameter, rowBounds, countSql);
Object result = executor.query(countMs, parameter, rowBounds, resultHandler, cacheKey, countSql).get(0);
page.setTotal(result == null ? 0L : Long.parseLong(result.toString()));
return continuePage(page);
}
@Override
public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
IPage<?> page = ParameterUtils.findPage(parameter).orElse(null);
if (null == page) {
return;
}
// 处理 orderBy 拼接
boolean addOrdered = false;
String buildSql = boundSql.getSql();
List<OrderItem> orders = page.orders();
if (!CollectionUtils.isEmpty(orders)) {
addOrdered = true;
buildSql = this.concatOrderBy(buildSql, orders);
}
// size 小于 0 不构造分页sql
if (page.getSize() < 0) {
if (addOrdered) {
PluginUtils.mpBoundSql(boundSql).sql(buildSql);
}
return;
}
handlerLimit(page);
IDialect dialect = findIDialect(executor);
final Configuration configuration = ms.getConfiguration();
DialectModel model = dialect.buildPaginationSql(buildSql, page.offset(), page.getSize());
PluginUtils.MPBoundSql mpBoundSql = PluginUtils.mpBoundSql(boundSql);
List<ParameterMapping> mappings = mpBoundSql.parameterMappings();
Map<String, Object> additionalParameter = mpBoundSql.additionalParameters();
model.consumers(mappings, configuration, additionalParameter);
mpBoundSql.sql(model.getDialectSql());
mpBoundSql.parameterMappings(mappings);
}
/**
* 获取分页方言类的逻辑
*
* @param executor Executor
* @return 分页方言类
*/
protected IDialect findIDialect(Executor executor) {
if (dialect != null) {
return dialect;
}
if (dbType != null) {
dialect = DialectFactory.getDialect(dbType);
return dialect;
}
return DialectFactory.getDialect(JdbcUtils.getDbType(executor));
}
/**
* 获取指定的 id 的 MappedStatement
*
* @param ms MappedStatement
* @param countId id
* @return MappedStatement
*/
protected MappedStatement buildCountMappedStatement(MappedStatement ms, String countId) {
if (StringUtils.isNotBlank(countId)) {
final String id = ms.getId();
if (!countId.contains(StringPool.DOT)) {
countId = id.substring(0, id.lastIndexOf(StringPool.DOT) + 1) + countId;
}
final Configuration configuration = ms.getConfiguration();
try {
return CollectionUtils.computeIfAbsent(countMsCache, countId, key -> configuration.getMappedStatement(key, false));
} catch (Exception e) {
logger.warn(String.format("can not find this countId: [\"%s\"]", countId));
}
}
return null;
}
/**
* 构建 mp 自用自动的 MappedStatement
*
* @param ms MappedStatement
* @return MappedStatement
*/
protected MappedStatement buildAutoCountMappedStatement(MappedStatement ms) {
final String countId = ms.getId() + "_mpCount";
final Configuration configuration = ms.getConfiguration();
return CollectionUtils.computeIfAbsent(countMsCache, countId, key -> {
MappedStatement.Builder builder = new MappedStatement.Builder(configuration, key, ms.getSqlSource(), ms.getSqlCommandType());
builder.resource(ms.getResource());
builder.fetchSize(ms.getFetchSize());
builder.statementType(ms.getStatementType());
builder.timeout(ms.getTimeout());
builder.parameterMap(ms.getParameterMap());
builder.resultMaps(Collections.singletonList(new ResultMap.Builder(configuration, Constants.MYBATIS_PLUS, Long.class, Collections.emptyList()).build()));
builder.resultSetType(ms.getResultSetType());
builder.cache(ms.getCache());
builder.flushCacheRequired(ms.isFlushCacheRequired());
builder.useCache(ms.isUseCache());
return builder.build();
});
}
/**
* 获取自动优化的 countSql
*
* @param optimizeCountSql 是否进行优化
* @param sql sql
* @return countSql
*/
protected String autoCountSql(boolean optimizeCountSql, String sql) {
if (!optimizeCountSql) {
return lowLevelCountSql(sql);
}
try {
Select select = (Select) CCJSqlParserUtil.parse(sql);
PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
Distinct distinct = plainSelect.getDistinct();
GroupByElement groupBy = plainSelect.getGroupBy();
List<OrderByElement> orderBy = plainSelect.getOrderByElements();
if (CollectionUtils.isNotEmpty(orderBy)) {
boolean canClean = true;
if (groupBy != null) {
// 包含groupBy 不去除orderBy
canClean = false;
}
if (canClean) {
for (OrderByElement order : orderBy) {
// order by 里带参数,不去除order by
Expression expression = order.getExpression();
if (!(expression instanceof Column) && expression.toString().contains(StringPool.QUESTION_MARK)) {
canClean = false;
break;
}
}
}
if (canClean) {
plainSelect.setOrderByElements(null);
}
}
//#95 Github, selectItems contains #{} ${}, which will be translated to ?, and it may be in a function: power(#{myInt},2)
for (SelectItem item : plainSelect.getSelectItems()) {
if (item.toString().contains(StringPool.QUESTION_MARK)) {
return lowLevelCountSql(select.toString());
}
}
// 包含 distinct、groupBy不优化
if (distinct != null || null != groupBy) {
return lowLevelCountSql(select.toString());
}
// 包含 join 连表,进行判断是否移除 join 连表
List<Join> joins = plainSelect.getJoins();
if (CollectionUtils.isNotEmpty(joins)) {
boolean canRemoveJoin = true;
String whereS = Optional.ofNullable(plainSelect.getWhere()).map(Expression::toString).orElse(StringPool.EMPTY);
for (Join join : joins) {
if (!join.isLeft()) {
canRemoveJoin = false;
break;
}
Table table = (Table) join.getRightItem();
String str = Optional.ofNullable(table.getAlias()).map(Alias::getName).orElse(table.getName()) + StringPool.DOT;
String onExpressionS = join.getOnExpression().toString();
/* 如果 join 里包含 ?(代表有入参) 或者 where 条件里包含使用 join 的表的字段作条件,就不移除 join */
if (onExpressionS.contains(StringPool.QUESTION_MARK) || whereS.contains(str)) {
canRemoveJoin = false;
break;
}
}
if (canRemoveJoin) {
plainSelect.setJoins(null);
}
}
// 优化 SQL
plainSelect.setSelectItems(COUNT_SELECT_ITEM);
return select.toString();
} catch (Throwable e) {
// 无法优化使用原 SQL
logger.warn("optimize this sql to a count sql has exception, sql:\"" + sql + "\", exception:\n" + e.getCause());
return lowLevelCountSql(sql);
}
}
/**
* 无法进行count优化时,降级使用此方法
*
* @param originalSql 原始sql
* @return countSql
*/
protected String lowLevelCountSql(String originalSql) {
return SqlParserUtils.getOriginalCountSql(originalSql);
}
/**
* 查询SQL拼接Order By
*
* @param originalSql 需要拼接的SQL
* @return ignore
*/
protected String concatOrderBy(String originalSql, List<OrderItem> orderList) {
try {
Select select = (Select) CCJSqlParserUtil.parse(originalSql);
SelectBody selectBody = select.getSelectBody();
if (selectBody instanceof PlainSelect) {
PlainSelect plainSelect = (PlainSelect) selectBody;
List<OrderByElement> orderByElements = plainSelect.getOrderByElements();
List<OrderByElement> orderByElementsReturn = addOrderByElements(orderList, orderByElements);
plainSelect.setOrderByElements(orderByElementsReturn);
return select.toString();
} else if (selectBody instanceof SetOperationList) {
SetOperationList setOperationList = (SetOperationList) selectBody;
List<OrderByElement> orderByElements = setOperationList.getOrderByElements();
List<OrderByElement> orderByElementsReturn = addOrderByElements(orderList, orderByElements);
setOperationList.setOrderByElements(orderByElementsReturn);
return select.toString();
} else if (selectBody instanceof WithItem) {
// todo: don't known how to resole
return originalSql;
} else {
return originalSql;
}
} catch (JSQLParserException e) {
logger.warn("failed to concat orderBy from IPage, exception:\n" + e.getCause());
return originalSql;
}
}
protected List<OrderByElement> addOrderByElements(List<OrderItem> orderList, List<OrderByElement> orderByElements) {
orderByElements = CollectionUtils.isEmpty(orderByElements) ? new ArrayList<>(orderList.size()) : orderByElements;
List<OrderByElement> orderByElementList = orderList.stream()
.filter(item -> StringUtils.isNotBlank(item.getColumn()))
.map(item -> {
OrderByElement element = new OrderByElement();
element.setExpression(new Column(item.getColumn()));
element.setAsc(item.isAsc());
element.setAscDescPresent(true);
return element;
}).collect(Collectors.toList());
orderByElements.addAll(orderByElementList);
return orderByElements;
}
/**
* count 查询之后,是否继续执行分页
*
* @param page 分页对象
* @return 是否
*/
protected boolean continuePage(IPage<?> page) {
if (page.getTotal() <= 0) {
return false;
}
if (page.getCurrent() > page.getPages()) {
if (overflow) {
//溢出总页数处理
handlerOverflow(page);
} else {
// 超过最大范围,未设置溢出逻辑中断 list 执行
return false;
}
}
return true;
}
/**
* 处理超出分页条数限制,默认归为限制数
*
* @param page IPage
*/
protected void handlerLimit(IPage<?> page) {
final long size = page.getSize();
Long pageMaxLimit = page.maxLimit();
Long limit = pageMaxLimit != null ? pageMaxLimit : maxLimit;
if (limit != null && limit > 0 && size > limit) {
page.setSize(limit);
}
}
/**
* 处理页数溢出,默认设置为第一页
*
* @param page IPage
*/
protected void handlerOverflow(IPage<?> page) {
page.setCurrent(1);
}
@Override
public void setProperties(Properties properties) {
PropertyMapper.newInstance(properties)
.whenNotBlack("overflow", Boolean::parseBoolean, this::setOverflow)
.whenNotBlack("dbType", DbType::getDbType, this::setDbType)
.whenNotBlack("dialect", ClassUtils::newInstance, this::setDialect)
.whenNotBlack("maxLimit", Long::parseLong, this::setMaxLimit);
}
}
@@ -0,0 +1,74 @@
package com.ruoyi;
import com.baomidou.mybatisplus.annotation.DbType;
import com.ruoyi.framework.config.MybatisPlusInterceptor;
import com.ruoyi.system.diagnostics.NetworkRequestTrace;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.Bean;
/**
* 启动程序
*
* @author ruoyi
*/
@SpringBootApplication(scanBasePackages = {
"com.ruoyi", "com.luqj","org.code.modules.plugins",}, exclude = {DataSourceAutoConfiguration.class})
@MapperScan({
"com.luqj.*.mapper",
"com.ruoyi.*.mapper"
})
public class RuoYiApplication {
public static void main(String[] args) {// System.setProperty("spring.devtools.restart.enabled", "false");
NetworkRequestTrace.installIfEnabled();
SpringApplication.run(RuoYiApplication.class, args);
}
/**
* 分页插件
*/
@Bean
public MybatisPlusInterceptor paginationInterceptor() {
// // 设置sql的limit为无限制,默认是500
// // 创建SQL解析器集合
// List<ISqlParser> sqlParserList = new ArrayList<>();
// //动态表明
// // 动态表名SQL解析器
// DynamicTableNameParser dynamicTableNameParser = new DynamicTableNameParser();
// Map<String, ITableNameHandler> tableNameHandlerMap = new HashMap<>();
// // Map的key就是需要替换的原始表名
// tableNameHandlerMap.put("t_a_dc_check_xxx1", new ITableNameHandler() {
// @Override
// public String dynamicTableName(MetaObject metaObject, String sql, String tableName) {
// // 自定义表名规则,或者从配置文件、request上下文中读取
//
// // 假设这里的用户表根据年份来进行分表操作
// Date date = new Date();
// //DateTimeFormatter dateTimeFormatter = new DateTimeFormatter(LocalDateTime.now());
// String year = String.format("_%tY%tm", date, date);
// // 返回最后需要操作的表名,table_name_YYYYMM月表
// return "t_a_dc_check_xxx1" + year;
// }
// });
// tableNameHandlerMap.put("t_a_dc_check_xxx2", new ITableNameHandler() {
// @Override
// public String dynamicTableName(MetaObject metaObject, String sql, String tableName) {
// // 自定义表名规则,或者从配置文件、request上下文中读取
// // 假设这里的用户表根据年份来进行分表操作
// Date date = new Date();
// //DateTimeFormatter dateTimeFormatter = new DateTimeFormatter(LocalDateTime.now());
// String year = String.format("_%tY%tm", date, date);
// // 返回最后需要操作的表名,sys_user_2019
// return "t_a_dc_check_xxx2" + year;
// }
// });
//
// dynamicTableNameParser.setTableNameHandlerMap(tableNameHandlerMap);
// sqlParserList.add(dynamicTableNameParser);
// 设置sql的limit为无限制,默认是500
MybatisPlusInterceptor paginationInterceptor = new MybatisPlusInterceptor();
paginationInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
return paginationInterceptor;
}
}
@@ -0,0 +1,18 @@
package com.ruoyi;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
/**
* web容器中进行部署
*
* @author ruoyi
*/
public class RuoYiServletInitializer extends SpringBootServletInitializer
{
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application)
{
return application.sources(RuoYiApplication.class);
}
}
@@ -0,0 +1,32 @@
package com.ruoyi.init;
import java.lang.annotation.Annotation;
public class AnnotationFinder {
public static <A extends Annotation> A findAnnotation(Class<?> clazz, Class<A> annotationType) {
// 先在类上查找
A annotation = clazz.getAnnotation(annotationType);
if (annotation != null) {
return annotation;
}
// 然后在方法上查找
for (java.lang.reflect.Method method : clazz.getMethods()) {
annotation = method.getAnnotation(annotationType);
if (annotation != null) {
return annotation;
}
}
// 最后在字段上查找
for (java.lang.reflect.Field field : clazz.getFields()) {
annotation = field.getAnnotation(annotationType);
if (annotation != null) {
return annotation;
}
}
return null;
}
}
@@ -0,0 +1,173 @@
package com.ruoyi.init;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.annotation.Excel;
import io.swagger.annotations.ApiModelProperty;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.ClassUtils;
import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.util.*;
//@Component
public class AutoBuildTable {
private final String BASE_PACKAGE = "com.luqj";
private final String RESOURCE_PATTERN = "/**/*.class";
private String toPinyin(String chinese) {
HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
StringBuilder sb = new StringBuilder();
char[] chars = chinese.toCharArray();
for (char c : chars) {
if (Character.isWhitespace(c)) {
continue;
}
if (c >= '\u4e00' && c <= '\u9fa5') {
try {
String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(c, format);
sb.append(pinyinArray[0]);
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
}
} else {
sb.append(c);
}
}
return sb.toString();
}
@PostConstruct
public void init() throws Exception {
// com.license.LicenseBootstrap.init();
Map<String, Class> handlerMap = new HashMap<String, Class>();
//spring工具类,可以获取指定路径下的全部类
ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
ClassUtils.convertClassNameToResourcePath(BASE_PACKAGE) + RESOURCE_PATTERN;
Resource[] resources = resourcePatternResolver.getResources(pattern);
//MetadataReader 的工厂类
MetadataReaderFactory readerfactory = new CachingMetadataReaderFactory(resourcePatternResolver);
for (Resource resource : resources) {
//用于读取类信息
MetadataReader reader = readerfactory.getMetadataReader(resource);
//扫描到的class
String classname = reader.getClassMetadata().getClassName();
if (classname == null) {
System.out.println(resource.getFilename());
continue;
}
try {
Class<?> clazz = Class.forName(classname);
//判断是否有指定主解
TableName anno = clazz.getAnnotation(TableName.class);
if (anno != null) {
String name = anno.value();
//将注解中的类型值作为key,对应的类作为 value
if (!handlerMap.containsKey(name)) {
handlerMap.put(name, clazz);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
Iterator<Map.Entry<String, Class>> iterator = handlerMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Class> item = iterator.next();
// if(item.getKey().equals("com_qiniu_config")){
// System.out.println("ddd");
// }
Field[] fields = item.getValue().getDeclaredFields();
System.out.println("DROP TABLE IF EXISTS `" + item.getKey() + "`;");
System.out.println("CREATE TABLE `" + item.getKey() + "` (");
for (Field field : fields) {
String desc = "";
Excel excel = field.getAnnotation(Excel.class);
if (excel != null) {
desc = excel.name();
} else {
ApiModelProperty apiModelProperty = field.getAnnotation(ApiModelProperty.class);
if (null != apiModelProperty) {
desc = apiModelProperty.value();
}
}
String columnName = field.getName();
if ("serialVersionUID".equals(columnName)) {
continue;
}
if (field.getType().getName().contains("List")) {
continue;
}
columnName = camelToUnderscore(columnName);
if (columnName.equals("id")) {
if (field.getType().getName().contains("Long")) {
System.out.println("`" + columnName + "` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '" + desc + "',");
}else if (field.getType().getName().contains("String")) {
System.out.println("`" + columnName + "` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '" + desc + "',");
}else{
throw new RuntimeException("id type is error");
}
} else {
if (field.getType().getName().contains("Date")) {
System.out.println("`" + columnName + "` datetime NULL DEFAULT NULL COMMENT '" + desc + "',");
} else if (field.getType().getName().contains("String")) {
System.out.println("`" + columnName + "` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '" + desc + "',");
} else if (field.getType().getName().contains("Integer")) {
System.out.println("`"+columnName+"` int(11) DEFAULT NULL COMMENT '"+desc+"',");
} else if (field.getType().getName().contains("Long")) {
System.out.println("`" + columnName + "` bigint(20) NULL DEFAULT NULL COMMENT '" + desc + "',");
} else if (field.getType().getName().contains("BigDecimal")) {
System.out.println("`" + columnName + "` decimal(10,2) NULL DEFAULT NULL COMMENT '" + desc + "',");
} else {
throw new RuntimeException(field.getType().getName() + " is not deal");
}
}
}
System.out.println("PRIMARY KEY (`id`) USING BTREE");
System.out.println(") ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;");
}
System.out.println(handlerMap.size());
}
/**
* 将驼峰命名转换为下划线命名
*
* @param camelCaseStr 驼峰命名的字符串
* @return 转换后的下划线命名的字符串
*/
private String camelToUnderscore(String camelCaseStr) {
if (camelCaseStr == null || camelCaseStr.isEmpty()) {
return camelCaseStr;
}
StringBuilder result = new StringBuilder(camelCaseStr.length() * 2);
int i = 0;
char[] chars = camelCaseStr.toCharArray();
for (char c : chars) {
if (i > 0 && Character.isUpperCase(c)) {
result.append('_');
}
result.append(Character.toLowerCase(c));
i++;
}
return result.toString();
}
}
@@ -0,0 +1,41 @@
package com.ruoyi.task;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.system.domain.DmPlayerentPlus;
import com.ruoyi.system.service.IDmPlayerentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.List;
@Component("dmPlayerentOnlineStatusTask")
@Slf4j
public class DmPlayerentOnlineStatusTask {
@Autowired
private IDmPlayerentService dmPlayerentService;
@Scheduled(cron = "0/5 * * * * ?")
public void execute() {
// com.license.LicenseBootstrap.init();
LambdaQueryWrapper<DmPlayerentPlus> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DmPlayerentPlus::getOnlineStatus, "1");
List<DmPlayerentPlus> list = dmPlayerentService.list(queryWrapper);
for (DmPlayerentPlus playerent : list) {
Date updateTime = playerent.getUpdateTime();
if (updateTime != null) {
long diff = new Date().getTime() - updateTime.getTime();
if (diff > 600000) {
playerent.setOnlineStatus("0");
dmPlayerentService.updateById(playerent);
log.info("Update playerent online status to 0, id: {}", playerent.getId());
}
}
}
queryWrapper = new LambdaQueryWrapper<>();
int count = dmPlayerentService.count(queryWrapper);
System.setProperty("globalCount", count+"");
}
}
@@ -0,0 +1,35 @@
package com.ruoyi.task;
import com.ruoyi.system.service.WalletLedgerPostingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.List;
/** 定期结算已检测链上交易的订单,并补齐已支付订单缺失的流水。 */
@Component
public class PaymentLedgerReconciliationTask {
private static final Logger log = LoggerFactory.getLogger(PaymentLedgerReconciliationTask.class);
private static final int BATCH_SIZE = 100;
private final WalletLedgerPostingService ledgerPostingService;
public PaymentLedgerReconciliationTask(WalletLedgerPostingService ledgerPostingService) {
this.ledgerPostingService = ledgerPostingService;
}
@org.springframework.scheduling.annotation.Scheduled(fixedDelay = 30000L)
public void reconcile() {
List<Long> orderIds = ledgerPostingService.findOrderIdsRequiringSettlement(BATCH_SIZE);
for (Long orderId : orderIds) {
try {
if (ledgerPostingService.settleDetectedOrRepairPaidOrder(orderId)) {
log.info("支付订单账务补偿完成,订单ID={}", orderId);
}
} catch (Exception ex) {
log.error("支付订单账务补偿失败,订单ID={},原因={}", orderId, ex.getMessage());
}
}
}
}
@@ -0,0 +1,31 @@
package com.ruoyi.task;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.system.domain.UsdtOrdersPlus;
import com.ruoyi.system.service.IUsdtOrdersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
/** 支付订单生命周期任务:先处理过期订单,链上入账由独立扫描器补充。 */
@Component
public class PaymentOrderExpireTask {
@Autowired private IUsdtOrdersService orders;
@Scheduled(fixedDelay = 10000L)
public void expireOrders() {
LambdaQueryWrapper<UsdtOrdersPlus> query = new LambdaQueryWrapper<UsdtOrdersPlus>()
.eq(UsdtOrdersPlus::getStatus, 1)
.and(wrapper -> wrapper.isNull(UsdtOrdersPlus::getBlockTransactionId)
.or().eq(UsdtOrdersPlus::getBlockTransactionId, ""))
.isNotNull(UsdtOrdersPlus::getCreatedAt)
.lt(UsdtOrdersPlus::getCreatedAt, new Date(System.currentTimeMillis() - 10 * 60 * 1000L));
for (UsdtOrdersPlus order : orders.list(query)) {
order.setStatus(3L);
order.setUpdatedAt(new Date());
orders.updateById(order);
}
}
}
@@ -0,0 +1,22 @@
package com.ruoyi.task;
import com.ruoyi.system.service.PayoutProcessingService;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
* 定时确认已广播代付交易,链上成功后执行最终结算。
*/
@Component
public class PayoutConfirmationTask {
private final PayoutProcessingService service;
public PayoutConfirmationTask(PayoutProcessingService service) {
this.service = service;
}
@Scheduled(fixedDelay = 30000L)
public void confirm() {
service.confirmPending();
}
}
@@ -0,0 +1,106 @@
package com.ruoyi.task;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.system.domain.UsdtOrdersPlus;
import com.ruoyi.system.service.ITronService;
import com.ruoyi.system.service.IUsdtOrdersService;
import com.ruoyi.system.service.TronServiceProvider;
import com.ruoyi.system.service.TronChainDataClient;
import com.ruoyi.system.service.WalletLedgerPostingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Date;
/**
* 轮询已确认 TRC20 转账,按地址、六位金额和唯一交易哈希入账。
*/
@Component
public class TronPaymentTask {
private static final Logger log = LoggerFactory.getLogger(TronPaymentTask.class);
private static final long ORDER_TTL_MILLIS = 10L * 60L * 1000L;
/** 仅放宽订单开始时间,兼容应用服务器与 TRON 节点之间的轻微时钟偏差。 */
private static final long CLOCK_SKEW_MILLIS = 5L * 1000L;
@Autowired
private IUsdtOrdersService orders;
@Autowired
private TronServiceProvider tronServiceProvider;
@Autowired
private WalletLedgerPostingService ledgerPostingService;
@Autowired
private TronChainDataClient chainDataClient;
@Scheduled(fixedDelay = 10000L)
public void scan() {
ITronService tron = null;
try {
tron = tronServiceProvider.getCurrentService();
} catch (RuntimeException e) {
log.warn("无法读取 TRON 全局网络配置,仅跳过未保存网络的历史订单扫描:{}", e.getMessage());
// 新订单自带网络,不因旧全局配置缺失阻断新支付订单。
}
for (UsdtOrdersPlus order : orders.list(new LambdaQueryWrapper<UsdtOrdersPlus>()
.eq(UsdtOrdersPlus::getStatus, 1)
.and(wrapper -> wrapper.isNull(UsdtOrdersPlus::getBlockTransactionId)
.or().eq(UsdtOrdersPlus::getBlockTransactionId, "")))) {
if (order.getToken() == null || order.getActualAmount() == null) continue;
try {
ITronService orderTron = order.getPaymentNetwork() == null ? tron
: tronServiceProvider.getServiceForNetwork(order.getPaymentNetwork());
if (orderTron == null) continue;
JSONArray data = chainDataClient.queryConfirmedTrc20Transactions(
orderTron, order.getToken(), 200);
for (int i = 0; i < data.size(); i++) {
JSONObject tx = data.getJSONObject(i);
if (!order.getToken().equals(tx.getString("to"))) continue;
long transactionTime = tx.getLongValue("block_timestamp");
if (!isTransactionInPaymentWindow(order.getCreatedAt(), transactionTime)) continue;
BigDecimal value = new BigDecimal(tx.getString("value")).movePointLeft(6).setScale(6, RoundingMode.DOWN);
if (value.compareTo(order.getActualAmount().setScale(6, RoundingMode.DOWN)) != 0) continue;
String hash = tx.getString("transaction_id");
if (hash == null || hash.trim().isEmpty()) continue;
if (!ledgerPostingService.recordDetectedPayment(order.getId(), hash)) {
log.warn("记录链上支付交易失败,订单ID={}", order.getId());
break;
}
try {
if (ledgerPostingService.settlePaidOrder(order.getId(), hash)) {
break;
}
} catch (RuntimeException settlementException) {
log.error("支付订单账务结算失败,订单ID={},原因={}",
order.getId(), settlementException.getMessage());
break;
}
}
} catch (Exception e) {
// 单笔订单查询失败不能中断其他订单,日志中禁止输出凭证和钱包私钥。
log.error(e.getMessage(), e);
log.warn("查询 TRON 支付交易失败,订单ID={},网络={}", order.getId(), order.getPaymentNetwork());
}
}
}
/**
* 链上交易必须发生在订单有效期内,防止同地址、同金额的历史转账命中新订单。
* 截止时间不增加容差,避免订单过期后的付款被自动确认。
*/
static boolean isTransactionInPaymentWindow(Date orderCreatedAt, long transactionTime) {
if (orderCreatedAt == null || transactionTime <= 0L) {
return false;
}
long createdAt = orderCreatedAt.getTime();
long validFrom = createdAt - CLOCK_SKEW_MILLIS;
long validUntil = createdAt + ORDER_TTL_MILLIS;
return transactionTime >= validFrom && transactionTime <= validUntil;
}
}
@@ -0,0 +1,75 @@
package com.ruoyi.task;
import com.ruoyi.system.domain.UsdtAggregationTaskItemPlus;
import com.ruoyi.system.domain.UsdtAggregationTaskPlus;
import com.ruoyi.system.domain.WalletAddressPlus;
import com.ruoyi.system.service.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* 后台逐地址执行归集任务;每个明细独立失败并继续后续地址。
*/
public class UsdtAggregationExecutorTask {
private static final Logger log = LoggerFactory.getLogger(UsdtAggregationExecutorTask.class);
@Autowired
private IUsdtAggregationTaskService taskService;
@Autowired
private IUsdtAggregationTaskItemService itemService;
@Autowired
private IWalletAddressService walletService;
@Autowired
private TronServiceProvider tronServiceProvider;
public void executePending() {
ITronService tronService;
try {
tronService = tronServiceProvider.getCurrentService();
} catch (RuntimeException e) {
log.warn("无法读取 TRON 全局网络配置,跳过本轮归集任务:{}", e.getMessage());
return;
}
List<UsdtAggregationTaskPlus> tasks = taskService.getListByStatusAndLtExeTime(1, new java.util.Date(System.currentTimeMillis() + 1));
for (UsdtAggregationTaskPlus task : tasks) executeTask(task, tronService);
}
private void executeTask(UsdtAggregationTaskPlus task, ITronService tronService) {
List<UsdtAggregationTaskItemPlus> items = itemService.getListByStatusAndParentId(0, task.getId());
boolean failed = false;
for (UsdtAggregationTaskItemPlus item : items) {
WalletAddressPlus wallet = walletService.getByTokenAndAppId(item.getTokenAddress(), item.getAppId());
String tx = null;
Exception last = null;
for (int attempt = 0; attempt < 4 && tx == null; attempt++) {
org.tron.trident.core.ApiWrapper api = null;
try {
api = tronService.buildApiWrapper();
tx = tronService.usdtTrans(api, wallet.getToken(), item.getDistTokenAddress(), item.getOpeAmount().toPlainString());
} catch (Exception ex) {
last = ex;
} finally {
if (api != null) api.close();
}
}
if (tx == null || tx.trim().isEmpty()) {
fail(item, "重试耗尽:" + (last == null ? "交易失败" : last.getMessage()));
failed = true;
} else {
item.setStatus(1L);
item.setRemark("交易哈希:" + tx);
itemService.updateById(item);
}
}
task.setStatus(failed ? 3 : 2);
taskService.updateById(task);
}
private void fail(UsdtAggregationTaskItemPlus item, String reason) {
item.setStatus(2L);
item.setRemark(reason);
itemService.updateById(item);
}
}
@@ -0,0 +1,64 @@
package com.ruoyi.task;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.UsdtConfigPlus;
import com.ruoyi.system.mapper.UsdtConfigMapper;
import com.ruoyi.system.service.ITronService;
import com.ruoyi.system.service.TronServiceProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.tron.trident.core.ApiWrapper;
import java.math.BigDecimal;
/**
* 定时刷新全局配置中主钱包的链上余额缓存。
*
* <p>任务只读取公开地址,不解密助记词或私钥;单次查询使用同一个 TRON 客户端,
* 并通过专用 SQL 只更新余额字段,避免覆盖并发修改的其他全局配置。</p>
*/
@Component
public class UsdtConfigBalanceRefreshTask {
private static final Logger log = LoggerFactory.getLogger(UsdtConfigBalanceRefreshTask.class);
@Autowired
private UsdtConfigMapper usdtConfigMapper;
@Autowired
private TronServiceProvider tronServiceProvider;
/** 默认每 30 秒刷新一次,完成上一轮后再计算间隔,防止慢查询堆积。 */
@Scheduled(fixedDelayString = "${payment.usdt-config-balance.refresh-delay-ms:15000}")
public void refresh() {
UsdtConfigPlus config = usdtConfigMapper.selectOne(new LambdaQueryWrapper<UsdtConfigPlus>()
.select(UsdtConfigPlus::getId, UsdtConfigPlus::getTokenAddress)
.orderByAsc(UsdtConfigPlus::getId)
.last("limit 1"));
if (config == null || StringUtils.isBlank(config.getTokenAddress())) {
return;
}
ApiWrapper api = null;
try {
ITronService tronService = tronServiceProvider.getCurrentService();
api = tronService.buildApiWrapper();
BigDecimal usdtBalance = tronService.getUsdtBalance(api, config.getTokenAddress());
BigDecimal trxBalance = tronService.getTRxBalance(api, config.getTokenAddress());
int updated = usdtConfigMapper.updateMainWalletBalances(
config.getId(), usdtBalance, trxBalance);
if (updated != 1) {
log.warn("主钱包余额刷新未更新到全局配置,配置ID={}", config.getId());
}
} catch (Exception e) {
// 地址属于公开信息,但仍不在错误日志中输出,以保持任务日志简洁并避免带出节点响应细节。
log.warn("主钱包余额刷新失败,配置ID={},原因={}", config.getId(), e.getMessage());
} finally {
if (api != null) {
api.close();
}
}
}
}
@@ -0,0 +1,19 @@
package com.ruoyi.task;
import com.ruoyi.system.service.WalletSnapshotRefreshService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/** 定时投递需要刷新的钱包,实际队列和消费逻辑位于 ruoyi-system。 */
@Component
public class WalletSnapshotRefreshTask {
@Autowired
private WalletSnapshotRefreshService walletSnapshotRefreshService;
/** 每轮按更新时间投递五个钱包。 */
@Scheduled(fixedDelayString = "${payment.wallet-snapshot.producer-delay-ms:10000}")
public void produce() {
walletSnapshotRefreshService.enqueueScheduledBatch();
}
}
@@ -0,0 +1,86 @@
package com.ruoyi.web.controller.common;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import com.google.code.kaptcha.Producer;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.sign.Base64;
import com.ruoyi.common.utils.uuid.IdUtils;
/**
* 验证码操作处理
*
* @author ruoyi
*/
@RestController
public class CaptchaController
{
@Resource(name = "captchaProducer")
private Producer captchaProducer;
@Resource(name = "captchaProducerMath")
private Producer captchaProducerMath;
@Autowired
private RedisCache redisCache;
// 验证码类型
@Value("${ruoyi.captchaType}")
private String captchaType;
/**
* 生成验证码
*/
@GetMapping("/captchaImage")
public AjaxResult getCode(HttpServletResponse response) throws IOException
{
// 保存验证码信息
String uuid = IdUtils.simpleUUID();
String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
String capStr = null, code = null;
BufferedImage image = null;
// 生成验证码
if ("math".equals(captchaType))
{
String capText = captchaProducerMath.createText();
capStr = capText.substring(0, capText.lastIndexOf("@"));
code = capText.substring(capText.lastIndexOf("@") + 1);
image = captchaProducerMath.createImage(capStr);
}
else if ("char".equals(captchaType))
{
capStr = code = captchaProducer.createText();
image = captchaProducer.createImage(capStr);
}
redisCache.setCacheObject(verifyKey, code, Constants.CAPTCHA_EXPIRATION, TimeUnit.MINUTES);
// 转换流信息写出
FastByteArrayOutputStream os = new FastByteArrayOutputStream();
try
{
ImageIO.write(image, "jpg", os);
}
catch (IOException e)
{
return AjaxResult.error(e.getMessage());
}
AjaxResult ajax = AjaxResult.success();
ajax.put("uuid", uuid);
ajax.put("img", Base64.encode(os.toByteArray()));
return ajax;
}
}
@@ -0,0 +1,119 @@
package com.ruoyi.web.controller.common;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.framework.config.ServerConfig;
/**
* 通用请求处理
*
* @author ruoyi
*/
@RestController
public class CommonController
{
private static final Logger log = LoggerFactory.getLogger(CommonController.class);
@Autowired
private ServerConfig serverConfig;
/**
* 通用下载请求
*
* @param fileName 文件名称
* @param delete 是否删除
*/
@GetMapping("common/download")
public void fileDownload(String fileName, Boolean delete, HttpServletResponse response, HttpServletRequest request)
{
try
{
if (!FileUtils.checkAllowDownload(fileName))
{
throw new Exception(StringUtils.format("文件名称({})非法,不允许下载。 ", fileName));
}
String realFileName = System.currentTimeMillis() + fileName.substring(fileName.indexOf("_") + 1);
String filePath = RuoYiConfig.getDownloadPath() + fileName;
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
FileUtils.setAttachmentResponseHeader(response, realFileName);
FileUtils.writeBytes(filePath, response.getOutputStream());
if (delete)
{
FileUtils.deleteFile(filePath);
}
}
catch (Exception e)
{
log.error("下载文件失败", e);
}
}
/**
* 通用上传请求
*/
@PostMapping("/common/upload")
public AjaxResult uploadFile(MultipartFile file, @RequestParam(value = "userId",required = false) Long userId) throws Exception
{
try
{
// 上传文件路径
String filePath = RuoYiConfig.getUploadPath();
// 上传并返回新文件名称
String fileName = FileUploadUtils.upload(filePath, file);
String url = serverConfig.getUrl() + fileName;
AjaxResult ajax = AjaxResult.success();
ajax.put("fileName", fileName);
ajax.put("url", url);
return ajax;
}
catch (Exception e)
{
return AjaxResult.error(e.getMessage());
}
}
/**
* 本地资源通用下载
*/
@GetMapping("/common/download/resource")
public void resourceDownload(String resource, HttpServletRequest request, HttpServletResponse response)
throws Exception
{
try
{
if (!FileUtils.checkAllowDownload(resource))
{
throw new Exception(StringUtils.format("资源文件({})非法,不允许下载。 ", resource));
}
// 本地资源路径
String localPath = RuoYiConfig.getProfile();
// 数据库资源地址
String downloadPath = localPath + StringUtils.substringAfter(resource, Constants.RESOURCE_PREFIX);
// 下载名称
String downloadName = StringUtils.substringAfterLast(downloadPath, "/");
response.setContentType(MediaType.APPLICATION_OCTET_STREAM_VALUE);
FileUtils.setAttachmentResponseHeader(response, downloadName);
FileUtils.writeBytes(downloadPath, response.getOutputStream());
}
catch (Exception e)
{
log.error("下载文件失败", e);
}
}
}
@@ -0,0 +1,53 @@
package com.ruoyi.web.controller.monitor;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.StringUtils;
/**
* 缓存监控
*
* @author ruoyi
*/
@RestController
@RequestMapping("/monitor/cache")
public class CacheController
{
@Autowired
private RedisTemplate<String, String> redisTemplate;
@PreAuthorize("@ss.hasPermi('monitor:cache:list')")
@GetMapping()
public AjaxResult getInfo() throws Exception
{
Properties info = (Properties) redisTemplate.execute((RedisCallback<Object>) connection -> connection.info());
Properties commandStats = (Properties) redisTemplate.execute((RedisCallback<Object>) connection -> connection.info("commandstats"));
Object dbSize = redisTemplate.execute((RedisCallback<Object>) connection -> connection.dbSize());
Map<String, Object> result = new HashMap<>(3);
result.put("info", info);
result.put("dbSize", dbSize);
List<Map<String, String>> pieList = new ArrayList<>();
commandStats.stringPropertyNames().forEach(key -> {
Map<String, String> data = new HashMap<>(2);
String property = commandStats.getProperty(key);
data.put("name", StringUtils.removeStart(key, "cmdstat_"));
data.put("value", StringUtils.substringBetween(property, "calls=", ",usec"));
pieList.add(data);
});
result.put("commandStats", pieList);
return AjaxResult.success(result);
}
}
@@ -0,0 +1,27 @@
package com.ruoyi.web.controller.monitor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.framework.web.domain.Server;
/**
* 服务器监控
*
* @author ruoyi
*/
@RestController
@RequestMapping("/monitor/server")
public class ServerController
{
@PreAuthorize("@ss.hasPermi('monitor:server:list')")
@GetMapping()
public AjaxResult getInfo() throws Exception
{
Server server = new Server();
server.copyTo();
return AjaxResult.success(server);
}
}
@@ -0,0 +1,67 @@
package com.ruoyi.web.controller.monitor;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.SysLogininfor;
import com.ruoyi.system.service.ISysLogininforService;
/**
* 系统访问记录
*
* @author ruoyi
*/
@RestController
@RequestMapping("/monitor/logininfor")
public class SysLogininforController extends BaseController
{
@Autowired
private ISysLogininforService logininforService;
@PreAuthorize("@ss.hasPermi('monitor:logininfor:list')")
@GetMapping("/list")
public TableDataInfo list(SysLogininfor logininfor)
{
startPage();
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
return getDataTable(list);
}
@Log(title = "登录日志", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('monitor:logininfor:export')")
@GetMapping("/export")
public AjaxResult export(SysLogininfor logininfor)
{
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
ExcelUtil<SysLogininfor> util = new ExcelUtil<SysLogininfor>(SysLogininfor.class);
return util.exportExcel(list, "登录日志");
}
@PreAuthorize("@ss.hasPermi('monitor:logininfor:remove')")
@Log(title = "登录日志", businessType = BusinessType.DELETE)
@DeleteMapping("/{infoIds}")
public AjaxResult remove(@PathVariable Long[] infoIds)
{
return toAjax(logininforService.deleteLogininforByIds(infoIds));
}
@PreAuthorize("@ss.hasPermi('monitor:logininfor:remove')")
@Log(title = "登录日志", businessType = BusinessType.CLEAN)
@DeleteMapping("/clean")
public AjaxResult clean()
{
logininforService.cleanLogininfor();
return AjaxResult.success();
}
}
@@ -0,0 +1,66 @@
package com.ruoyi.web.controller.monitor;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.SysOperLog;
import com.ruoyi.system.service.ISysOperLogService;
/**
* 操作日志记录
*
* @author ruoyi
*/
@RestController
@RequestMapping("/monitor/operlog")
public class SysOperlogController extends BaseController
{
@Autowired
private ISysOperLogService operLogService;
@PreAuthorize("@ss.hasPermi('monitor:operlog:list')")
@GetMapping("/list")
public TableDataInfo list(SysOperLog operLog)
{
startPage();
List<SysOperLog> list = operLogService.selectOperLogList(operLog);
return getDataTable(list);
}
@Log(title = "操作日志", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('monitor:operlog:export')")
@GetMapping("/export")
public AjaxResult export(SysOperLog operLog)
{
List<SysOperLog> list = operLogService.selectOperLogList(operLog);
ExcelUtil<SysOperLog> util = new ExcelUtil<SysOperLog>(SysOperLog.class);
return util.exportExcel(list, "操作日志");
}
@PreAuthorize("@ss.hasPermi('monitor:operlog:remove')")
@DeleteMapping("/{operIds}")
public AjaxResult remove(@PathVariable Long[] operIds)
{
return toAjax(operLogService.deleteOperLogByIds(operIds));
}
@Log(title = "操作日志", businessType = BusinessType.CLEAN)
@PreAuthorize("@ss.hasPermi('monitor:operlog:remove')")
@DeleteMapping("/clean")
public AjaxResult clean()
{
operLogService.cleanOperLog();
return AjaxResult.success();
}
}
@@ -0,0 +1,92 @@
package com.ruoyi.web.controller.monitor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.SysUserOnline;
import com.ruoyi.system.service.ISysUserOnlineService;
/**
* 在线用户监控
*
* @author ruoyi
*/
@RestController
@RequestMapping("/monitor/online")
public class SysUserOnlineController extends BaseController
{
@Autowired
private ISysUserOnlineService userOnlineService;
@Autowired
private RedisCache redisCache;
@PreAuthorize("@ss.hasPermi('monitor:online:list')")
@GetMapping("/list")
public TableDataInfo list(String ipaddr, String userName)
{
Collection<String> keys = redisCache.keys(Constants.LOGIN_TOKEN_KEY + "*");
List<SysUserOnline> userOnlineList = new ArrayList<SysUserOnline>();
for (String key : keys)
{
LoginUser user = redisCache.getCacheObject(key);
if (StringUtils.isNotEmpty(ipaddr) && StringUtils.isNotEmpty(userName))
{
if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername()))
{
userOnlineList.add(userOnlineService.selectOnlineByInfo(ipaddr, userName, user));
}
}
else if (StringUtils.isNotEmpty(ipaddr))
{
if (StringUtils.equals(ipaddr, user.getIpaddr()))
{
userOnlineList.add(userOnlineService.selectOnlineByIpaddr(ipaddr, user));
}
}
else if (StringUtils.isNotEmpty(userName) && StringUtils.isNotNull(user.getUser()))
{
if (StringUtils.equals(userName, user.getUsername()))
{
userOnlineList.add(userOnlineService.selectOnlineByUserName(userName, user));
}
}
else
{
userOnlineList.add(userOnlineService.loginUserToUserOnline(user));
}
}
Collections.reverse(userOnlineList);
userOnlineList.removeAll(Collections.singleton(null));
return getDataTable(userOnlineList);
}
/**
* 强退用户
*/
@PreAuthorize("@ss.hasPermi('monitor:online:forceLogout')")
@Log(title = "在线用户", businessType = BusinessType.FORCE)
@DeleteMapping("/{tokenId}")
public AjaxResult forceLogout(@PathVariable String tokenId)
{
redisCache.deleteObject(Constants.LOGIN_TOKEN_KEY + tokenId);
return AjaxResult.success();
}
}
@@ -0,0 +1,34 @@
package com.ruoyi.web.controller.openapi;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* http://127.0.0.1:2020/oauth/token
* Basic Auth lu7213/123456
* x-www-form-urlencoded
* grant_type:client_credentials
* scope:openapi
*/
@RestController
@RequestMapping("/openapi")
public class OpenApiController {
@GetMapping("/test1")
public String test1(){
return "oauth2 ok";
}
@GetMapping("/test2")
public String test2(Authentication authentication) {
Object jwt = authentication.getPrincipal();
//
// String clientId = jwt.getClaimAsString("client_id");
return "ddd";
}
}
@@ -0,0 +1,86 @@
package com.ruoyi.web.controller.system;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.web.service.GoogleOauthService;
import com.ruoyi.system.domain.SysUserGoogleOauth;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.view.RedirectView;
import java.util.HashMap;
import java.util.Map;
/** Google OpenID Connect登录与当前本地账号绑定接口。 */
@RestController
@RequestMapping("/auth/google")
public class GoogleOauthController {
private final GoogleOauthService googleOauthService;
public GoogleOauthController(GoogleOauthService googleOauthService) {
this.googleOauthService = googleOauthService;
}
/** 匿名登录授权入口,只返回Google官方授权地址。 */
@GetMapping("/login-url")
public AjaxResult loginUrl() {
AjaxResult result = AjaxResult.success();
result.put("enabled", googleOauthService.isEnabled());
if (googleOauthService.isEnabled()) {
result.put("authorizationUrl", googleOauthService.buildAuthorizationUrl("LOGIN", null));
}
return result;
}
/** 已登录用户发起绑定,绑定目标用户ID从当前JWT读取。 */
@GetMapping("/bind-url")
public AjaxResult bindUrl() {
// 显式使用消息和数据两个参数,避免匹配 success(String) 重载将授权地址写入 msg。
// 登录页和个人中心均从 data 读取此地址,并跳转至 Google 官方授权页面。
return AjaxResult.success("操作成功",
googleOauthService.buildAuthorizationUrl("BIND", SecurityUtils.getUserId()));
}
/** Google控制台登记的固定回调地址。 */
@GetMapping("/callback")
public RedirectView callback(@RequestParam(value = "code", required = false) String code,
@RequestParam(value = "state", required = false) String state,
@RequestParam(value = "error", required = false) String error) {
return new RedirectView(googleOauthService.handleCallback(code, state, error));
}
/** 前端使用60秒一次性票据换取原有RuoYi系统JWT。 */
@PostMapping("/exchange")
public AjaxResult exchange(@RequestBody Map<String, String> request) {
AjaxResult result = AjaxResult.success();
result.put(Constants.TOKEN, googleOauthService.exchangeTicket(request.get("ticket")));
return result;
}
@GetMapping("/binding")
public AjaxResult binding() {
SysUserGoogleOauth binding = googleOauthService.getBinding(SecurityUtils.getUserId());
Map<String, Object> view = new HashMap<>();
view.put("enabled", googleOauthService.isEnabled());
view.put("bound", binding != null);
if (binding != null) {
view.put("email", binding.getEmail());
view.put("displayName", binding.getDisplayName());
view.put("avatarUrl", binding.getAvatarUrl());
view.put("createdAt", binding.getCreatedAt());
}
return AjaxResult.success(view);
}
@DeleteMapping("/binding")
public AjaxResult unbind() {
googleOauthService.unbind(SecurityUtils.getUserId());
return AjaxResult.success("Google账号已解绑");
}
}
@@ -0,0 +1,173 @@
package com.ruoyi.web.controller.system;
import com.alibaba.fastjson.JSONObject;
import com.luqj.util.HttpHelper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.redis.RedisUtil;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ip.IpUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.SysConfig;
import com.ruoyi.system.service.ISysConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
/**
* 参数配置 信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/config")
public class SysConfigController extends BaseController {
@Autowired
private ISysConfigService configService;
@Autowired
private RedisUtil redisUtil;
/**
* 获取参数配置列表
*/
@PreAuthorize("@ss.hasPermi('system:config:list')")
@GetMapping("/list")
public TableDataInfo list(SysConfig config) {
startPage();
List<SysConfig> list = configService.selectConfigList(config);
return getDataTable(list);
}
@Log(title = "参数管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:config:export')")
@GetMapping("/export")
public AjaxResult export(SysConfig config) {
List<SysConfig> list = configService.selectConfigList(config);
ExcelUtil<SysConfig> util = new ExcelUtil<SysConfig>(SysConfig.class);
return util.exportExcel(list, "参数数据");
}
/**
* 根据参数编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:config:query')")
@GetMapping(value = "/{configId}")
public AjaxResult getInfo(@PathVariable Long configId) {
return AjaxResult.success(configService.selectConfigById(configId));
}
@GetMapping(value = "/setVerifyStatus")
public AjaxResult setVerifyStatus(HttpServletRequest request,@RequestParam String status) {
redisUtil.set("smartKey",status);
return AjaxResult.success("");
}
/**
* 审核状态
*
* @return
*/
@GetMapping(value = "/getVerifyStatus")
public AjaxResult getVerifyStatus(HttpServletRequest request) {
String ip = IpUtils.getIpAddr(request);
logger.info(ip);
if(!redisUtil.hasKey("verify:ip",ip)) {
HttpHelper httpHelper = new HttpHelper();
HashMap<String, Object> headers = new HashMap<>();
headers.put("Content-Type", "application/json");
HashMap<String, Object> map = new HashMap<>();
map.put("ak", "icwGY86GNcKLhatud8ia7RSrGwkWPf8b");
map.put("ip", ip);
map.put("coor", "bd09ll");
try {
String result = httpHelper.getlHttpResult("http://api.map.baidu.com/location/ip"
, "get", headers, map);
JSONObject jsonObject = JSONObject.parseObject(new String(result.getBytes(),"UTF-8"));
if(jsonObject.getInteger("status") ==0){
if(!jsonObject.getJSONObject("content").getString("address").contains("福建省")){
redisUtil.set("verify:ip",ip,"1");
}else{
redisUtil.set("verify:ip",ip,"0");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}else{
String status = redisUtil.get("verify:ip",ip);
if("1".equals(status)){
return AjaxResult.success("1"); //开启
}
}
if (redisUtil.hasKey("smartKey")) {
return AjaxResult.success(redisUtil.get("smartKey"));
}
return AjaxResult.success("1"); //开启
}
/**
* 根据参数键名查询参数值
*/
@GetMapping(value = "/configKey/{configKey}")
public AjaxResult getConfigKey(@PathVariable String configKey) {
return AjaxResult.success(configService.selectConfigByKey(configKey));
}
/**
* 新增参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:add')")
@Log(title = "参数管理", businessType = BusinessType.INSERT)
@PostMapping
@RepeatSubmit
public AjaxResult add(@Validated @RequestBody SysConfig config) {
if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) {
return AjaxResult.error("新增参数'" + config.getConfigName() + "'失败,参数键名已存在");
}
config.setCreateBy(SecurityUtils.getUsername());
return toAjax(configService.insertConfig(config));
}
/**
* 修改参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:edit')")
@Log(title = "参数管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysConfig config) {
if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) {
return AjaxResult.error("修改参数'" + config.getConfigName() + "'失败,参数键名已存在");
}
config.setUpdateBy(SecurityUtils.getUsername());
return toAjax(configService.updateConfig(config));
}
/**
* 删除参数配置
*/
@PreAuthorize("@ss.hasPermi('system:config:remove')")
@Log(title = "参数管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{configIds}")
public AjaxResult remove(@PathVariable Long[] configIds) {
return toAjax(configService.deleteConfigByIds(configIds));
}
/**
* 清空缓存
*/
@PreAuthorize("@ss.hasPermi('system:config:remove')")
@Log(title = "参数管理", businessType = BusinessType.CLEAN)
@DeleteMapping("/clearCache")
public AjaxResult clearCache() {
configService.clearCache();
return AjaxResult.success();
}
}
@@ -0,0 +1,163 @@
package com.ruoyi.web.controller.system;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.service.ISysDeptService;
/**
* 部门信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dept")
public class SysDeptController extends BaseController
{
@Autowired
private ISysDeptService deptService;
/**
* 获取部门列表
*/
@PreAuthorize("@ss.hasPermi('system:dept:list')")
@GetMapping("/list")
public AjaxResult list(SysDept dept)
{
List<SysDept> depts = deptService.selectDeptList(dept);
return AjaxResult.success(depts);
}
/**
* 查询部门列表(排除节点)
*/
@PreAuthorize("@ss.hasPermi('system:dept:list')")
@GetMapping("/list/exclude/{deptId}")
public AjaxResult excludeChild(@PathVariable(value = "deptId", required = false) Long deptId)
{
List<SysDept> depts = deptService.selectDeptList(new SysDept());
Iterator<SysDept> it = depts.iterator();
while (it.hasNext())
{
SysDept d = (SysDept) it.next();
if (d.getDeptId().intValue() == deptId
|| ArrayUtils.contains(StringUtils.split(d.getAncestors(), ","), deptId + ""))
{
it.remove();
}
}
return AjaxResult.success(depts);
}
/**
* 根据部门编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:dept:query')")
@GetMapping(value = "/{deptId}")
public AjaxResult getInfo(@PathVariable Long deptId)
{
return AjaxResult.success(deptService.selectDeptById(deptId));
}
/**
* 获取部门下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysDept dept)
{
List<SysDept> depts = deptService.selectDeptList(dept);
return AjaxResult.success(deptService.buildDeptTreeSelect(depts));
}
/**
* 加载对应角色部门列表树
*/
@GetMapping(value = "/roleDeptTreeselect/{roleId}")
public AjaxResult roleDeptTreeselect(@PathVariable("roleId") Long roleId)
{
List<SysDept> depts = deptService.selectDeptList(new SysDept());
AjaxResult ajax = AjaxResult.success();
ajax.put("checkedKeys", deptService.selectDeptListByRoleId(roleId));
ajax.put("depts", deptService.buildDeptTreeSelect(depts));
return ajax;
}
/**
* 新增部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:add')")
@Log(title = "部门管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDept dept)
{
if (UserConstants.NOT_UNIQUE.equals(deptService.checkDeptNameUnique(dept)))
{
return AjaxResult.error("新增部门'" + dept.getDeptName() + "'失败,部门名称已存在");
}
dept.setCreateBy(SecurityUtils.getUsername());
return toAjax(deptService.insertDept(dept));
}
/**
* 修改部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:edit')")
@Log(title = "部门管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDept dept)
{
if (UserConstants.NOT_UNIQUE.equals(deptService.checkDeptNameUnique(dept)))
{
return AjaxResult.error("修改部门'" + dept.getDeptName() + "'失败,部门名称已存在");
}
else if (dept.getParentId().equals(dept.getDeptId()))
{
return AjaxResult.error("修改部门'" + dept.getDeptName() + "'失败,上级部门不能是自己");
}
else if (StringUtils.equals(UserConstants.DEPT_DISABLE, dept.getStatus())
&& deptService.selectNormalChildrenDeptById(dept.getDeptId()) > 0)
{
return AjaxResult.error("该部门包含未停用的子部门!");
}
dept.setUpdateBy(SecurityUtils.getUsername());
return toAjax(deptService.updateDept(dept));
}
/**
* 删除部门
*/
@PreAuthorize("@ss.hasPermi('system:dept:remove')")
@Log(title = "部门管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{deptId}")
public AjaxResult remove(@PathVariable Long deptId)
{
if (deptService.hasChildByDeptId(deptId))
{
return AjaxResult.error("存在下级部门,不允许删除");
}
if (deptService.checkDeptExistUser(deptId))
{
return AjaxResult.error("部门存在用户,不允许删除");
}
return toAjax(deptService.deleteDeptById(deptId));
}
}
@@ -0,0 +1,120 @@
package com.ruoyi.web.controller.system;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.system.service.ISysDictTypeService;
/**
* 数据字典信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dict/data")
public class SysDictDataController extends BaseController
{
@Autowired
private ISysDictDataService dictDataService;
@Autowired
private ISysDictTypeService dictTypeService;
@PreAuthorize("@ss.hasPermi('system:dict:list')")
@GetMapping("/list")
public TableDataInfo list(SysDictData dictData)
{
startPage();
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
return getDataTable(list);
}
@Log(title = "字典数据", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:dict:export')")
@GetMapping("/export")
public AjaxResult export(SysDictData dictData)
{
List<SysDictData> list = dictDataService.selectDictDataList(dictData);
ExcelUtil<SysDictData> util = new ExcelUtil<SysDictData>(SysDictData.class);
return util.exportExcel(list, "字典数据");
}
/**
* 查询字典数据详细
*/
@PreAuthorize("@ss.hasPermi('system:dict:query')")
@GetMapping(value = "/{dictCode}")
public AjaxResult getInfo(@PathVariable Long dictCode)
{
return AjaxResult.success(dictDataService.selectDictDataById(dictCode));
}
/**
* 根据字典类型查询字典数据信息
*/
@GetMapping(value = "/type/{dictType}")
public AjaxResult dictType(@PathVariable String dictType)
{
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
if (StringUtils.isNull(data))
{
data = new ArrayList<SysDictData>();
}
return AjaxResult.success(data);
}
/**
* 新增字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:add')")
@Log(title = "字典数据", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDictData dict)
{
dict.setCreateBy(SecurityUtils.getUsername());
return toAjax(dictDataService.insertDictData(dict));
}
/**
* 修改保存字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:edit')")
@Log(title = "字典数据", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDictData dict)
{
dict.setUpdateBy(SecurityUtils.getUsername());
return toAjax(dictDataService.updateDictData(dict));
}
/**
* 删除字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.DELETE)
@DeleteMapping("/{dictCodes}")
public AjaxResult remove(@PathVariable Long[] dictCodes)
{
return toAjax(dictDataService.deleteDictDataByIds(dictCodes));
}
}
@@ -0,0 +1,132 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDictType;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.service.ISysDictTypeService;
/**
* 数据字典信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/dict/type")
public class SysDictTypeController extends BaseController
{
@Autowired
private ISysDictTypeService dictTypeService;
@PreAuthorize("@ss.hasPermi('system:dict:list')")
@GetMapping("/list")
public TableDataInfo list(SysDictType dictType)
{
startPage();
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
return getDataTable(list);
}
@Log(title = "字典类型", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:dict:export')")
@GetMapping("/export")
public AjaxResult export(SysDictType dictType)
{
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
ExcelUtil<SysDictType> util = new ExcelUtil<SysDictType>(SysDictType.class);
return util.exportExcel(list, "字典类型");
}
/**
* 查询字典类型详细
*/
@PreAuthorize("@ss.hasPermi('system:dict:query')")
@GetMapping(value = "/{dictId}")
public AjaxResult getInfo(@PathVariable Long dictId)
{
return AjaxResult.success(dictTypeService.selectDictTypeById(dictId));
}
/**
* 新增字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:add')")
@Log(title = "字典类型", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysDictType dict)
{
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict)))
{
return AjaxResult.error("新增字典'" + dict.getDictName() + "'失败,字典类型已存在");
}
dict.setCreateBy(SecurityUtils.getUsername());
return toAjax(dictTypeService.insertDictType(dict));
}
/**
* 修改字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:edit')")
@Log(title = "字典类型", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysDictType dict)
{
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict)))
{
return AjaxResult.error("修改字典'" + dict.getDictName() + "'失败,字典类型已存在");
}
dict.setUpdateBy(SecurityUtils.getUsername());
return toAjax(dictTypeService.updateDictType(dict));
}
/**
* 删除字典类型
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.DELETE)
@DeleteMapping("/{dictIds}")
public AjaxResult remove(@PathVariable Long[] dictIds)
{
return toAjax(dictTypeService.deleteDictTypeByIds(dictIds));
}
/**
* 清空缓存
*/
@PreAuthorize("@ss.hasPermi('system:dict:remove')")
@Log(title = "字典类型", businessType = BusinessType.CLEAN)
@DeleteMapping("/clearCache")
public AjaxResult clearCache()
{
dictTypeService.clearCache();
return AjaxResult.success();
}
/**
* 获取字典选择框列表
*/
@GetMapping("/optionselect")
public AjaxResult optionselect()
{
List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
return AjaxResult.success(dictTypes);
}
}
@@ -0,0 +1,103 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysMenu;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginBody;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.framework.web.service.SysLoginService;
import com.ruoyi.framework.web.service.SysPermissionService;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.service.ISysMenuService;
/**
* 登录验证
*
* @author ruoyi
*/
@RestController
public class SysLoginController
{
@Autowired
private SysLoginService loginService;
@Autowired
private ISysMenuService menuService;
@Autowired
private SysPermissionService permissionService;
@Autowired
private TokenService tokenService;
/**
* 登录方法
*
* @param loginBody 登录信息
* @return 结果
*/
@PostMapping("/login")
public AjaxResult login(@RequestBody LoginBody loginBody)
{
AjaxResult ajax = AjaxResult.success();
// 生成令牌
String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
loginBody.getUuid(),true);
ajax.put(Constants.TOKEN, token);
return ajax;
}
@PostMapping("/simple-login")
public AjaxResult simpleLogin(@RequestBody LoginBody loginBody)
{
AjaxResult ajax = AjaxResult.success();
// 生成令牌
String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), null,
loginBody.getUuid(),false);
ajax.put(Constants.TOKEN, token);
return ajax;
}
/**
* 获取用户信息
*
* @return 用户信息
*/
@GetMapping("getInfo")
public AjaxResult getInfo()
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
SysUser user = loginUser.getUser();
// 角色集合
Set<String> roles = permissionService.getRolePermission(user);
// 权限集合
Set<String> permissions = permissionService.getMenuPermission(user);
AjaxResult ajax = AjaxResult.success();
ajax.put("user", user);
ajax.put("roles", roles);
ajax.put("permissions", permissions);
return ajax;
}
/**
* 获取路由信息
*
* @return 路由信息
*/
@GetMapping("getRouters")
public AjaxResult getRouters()
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
// 用户信息
SysUser user = loginUser.getUser();
List<SysMenu> menus = menuService.selectMenuTreeByUserId(user.getUserId());
return AjaxResult.success(menuService.buildMenus(menus));
}
}
@@ -0,0 +1,157 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysMenu;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.service.ISysMenuService;
/**
* 菜单信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/menu")
public class SysMenuController extends BaseController
{
@Autowired
private ISysMenuService menuService;
@Autowired
private TokenService tokenService;
/**
* 获取菜单列表
*/
@PreAuthorize("@ss.hasPermi('system:menu:list')")
@GetMapping("/list")
public AjaxResult list(SysMenu menu)
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
Long userId = loginUser.getUser().getUserId();
List<SysMenu> menus = menuService.selectMenuList(menu, userId);
return AjaxResult.success(menus);
}
/**
* 根据菜单编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:menu:query')")
@GetMapping(value = "/{menuId}")
public AjaxResult getInfo(@PathVariable Long menuId)
{
return AjaxResult.success(menuService.selectMenuById(menuId));
}
/**
* 获取菜单下拉树列表
*/
@GetMapping("/treeselect")
public AjaxResult treeselect(SysMenu menu)
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
Long userId = loginUser.getUser().getUserId();
List<SysMenu> menus = menuService.selectMenuList(menu, userId);
return AjaxResult.success(menuService.buildMenuTreeSelect(menus));
}
/**
* 加载对应角色菜单列表树
*/
@GetMapping(value = "/roleMenuTreeselect/{roleId}")
public AjaxResult roleMenuTreeselect(@PathVariable("roleId") Long roleId)
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
List<SysMenu> menus = menuService.selectMenuList(loginUser.getUser().getUserId());
AjaxResult ajax = AjaxResult.success();
ajax.put("checkedKeys", menuService.selectMenuListByRoleId(roleId));
ajax.put("menus", menuService.buildMenuTreeSelect(menus));
return ajax;
}
/**
* 新增菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:add')")
@Log(title = "菜单管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysMenu menu)
{
if (UserConstants.NOT_UNIQUE.equals(menuService.checkMenuNameUnique(menu)))
{
return AjaxResult.error("新增菜单'" + menu.getMenuName() + "'失败,菜单名称已存在");
}
else if (UserConstants.YES_FRAME.equals(menu.getIsFrame())
&& !StringUtils.startsWithAny(menu.getPath(), Constants.HTTP, Constants.HTTPS))
{
return AjaxResult.error("新增菜单'" + menu.getMenuName() + "'失败,地址必须以http(s)://开头");
}
menu.setCreateBy(SecurityUtils.getUsername());
return toAjax(menuService.insertMenu(menu));
}
/**
* 修改菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:edit')")
@Log(title = "菜单管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysMenu menu)
{
if (UserConstants.NOT_UNIQUE.equals(menuService.checkMenuNameUnique(menu)))
{
return AjaxResult.error("修改菜单'" + menu.getMenuName() + "'失败,菜单名称已存在");
}
else if (UserConstants.YES_FRAME.equals(menu.getIsFrame())
&& !StringUtils.startsWithAny(menu.getPath(), Constants.HTTP, Constants.HTTPS))
{
return AjaxResult.error("修改菜单'" + menu.getMenuName() + "'失败,地址必须以http(s)://开头");
}
else if (menu.getMenuId().equals(menu.getParentId()))
{
return AjaxResult.error("修改菜单'" + menu.getMenuName() + "'失败,上级菜单不能选择自己");
}
menu.setUpdateBy(SecurityUtils.getUsername());
return toAjax(menuService.updateMenu(menu));
}
/**
* 删除菜单
*/
@PreAuthorize("@ss.hasPermi('system:menu:remove')")
@Log(title = "菜单管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{menuId}")
public AjaxResult remove(@PathVariable("menuId") Long menuId)
{
if (menuService.hasChildByMenuId(menuId))
{
return AjaxResult.error("存在子菜单,不允许删除");
}
if (menuService.checkMenuExistRole(menuId))
{
return AjaxResult.error("菜单已分配,不允许删除");
}
return toAjax(menuService.deleteMenuById(menuId));
}
}
@@ -0,0 +1,92 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.domain.SysNotice;
import com.ruoyi.system.service.ISysNoticeService;
/**
* 公告 信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/notice")
public class SysNoticeController extends BaseController
{
@Autowired
private ISysNoticeService noticeService;
/**
* 获取通知公告列表
*/
@PreAuthorize("@ss.hasPermi('system:notice:list')")
@GetMapping("/list")
public TableDataInfo list(SysNotice notice)
{
startPage();
List<SysNotice> list = noticeService.selectNoticeList(notice);
return getDataTable(list);
}
/**
* 根据通知公告编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:notice:query')")
@GetMapping(value = "/{noticeId}")
public AjaxResult getInfo(@PathVariable Long noticeId)
{
return AjaxResult.success(noticeService.selectNoticeById(noticeId));
}
/**
* 新增通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:add')")
@Log(title = "通知公告", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysNotice notice)
{
notice.setCreateBy(SecurityUtils.getUsername());
return toAjax(noticeService.insertNotice(notice));
}
/**
* 修改通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:edit')")
@Log(title = "通知公告", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysNotice notice)
{
notice.setUpdateBy(SecurityUtils.getUsername());
return toAjax(noticeService.updateNotice(notice));
}
/**
* 删除通知公告
*/
@PreAuthorize("@ss.hasPermi('system:notice:remove')")
@Log(title = "通知公告", businessType = BusinessType.DELETE)
@DeleteMapping("/{noticeIds}")
public AjaxResult remove(@PathVariable Long[] noticeIds)
{
return toAjax(noticeService.deleteNoticeByIds(noticeIds));
}
}
@@ -0,0 +1,130 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.SysPost;
import com.ruoyi.system.service.ISysPostService;
/**
* 岗位信息操作处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/post")
public class SysPostController extends BaseController
{
@Autowired
private ISysPostService postService;
/**
* 获取岗位列表
*/
@PreAuthorize("@ss.hasPermi('system:post:list')")
@GetMapping("/list")
public TableDataInfo list(SysPost post)
{
startPage();
List<SysPost> list = postService.selectPostList(post);
return getDataTable(list);
}
@Log(title = "岗位管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:post:export')")
@GetMapping("/export")
public AjaxResult export(SysPost post)
{
List<SysPost> list = postService.selectPostList(post);
ExcelUtil<SysPost> util = new ExcelUtil<SysPost>(SysPost.class);
return util.exportExcel(list, "岗位数据");
}
/**
* 根据岗位编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:post:query')")
@GetMapping(value = "/{postId}")
public AjaxResult getInfo(@PathVariable Long postId)
{
return AjaxResult.success(postService.selectPostById(postId));
}
/**
* 新增岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:add')")
@Log(title = "岗位管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysPost post)
{
if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post)))
{
return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败,岗位名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post)))
{
return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败,岗位编码已存在");
}
post.setCreateBy(SecurityUtils.getUsername());
return toAjax(postService.insertPost(post));
}
/**
* 修改岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:edit')")
@Log(title = "岗位管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysPost post)
{
if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post)))
{
return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败,岗位名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post)))
{
return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败,岗位编码已存在");
}
post.setUpdateBy(SecurityUtils.getUsername());
return toAjax(postService.updatePost(post));
}
/**
* 删除岗位
*/
@PreAuthorize("@ss.hasPermi('system:post:remove')")
@Log(title = "岗位管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{postIds}")
public AjaxResult remove(@PathVariable Long[] postIds)
{
return toAjax(postService.deletePostByIds(postIds));
}
/**
* 获取岗位选择框列表
*/
@GetMapping("/optionselect")
public AjaxResult optionselect()
{
List<SysPost> posts = postService.selectPostAll();
return AjaxResult.success(posts);
}
}
@@ -0,0 +1,143 @@
package com.ruoyi.web.controller.system;
import java.io.IOException;
import com.ruoyi.framework.config.ServerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.service.ISysUserService;
/**
* 个人信息 业务处理
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/user/profile")
public class SysProfileController extends BaseController
{
@Autowired
private ISysUserService userService;
@Autowired
private ServerConfig serverConfig;
@Autowired
private TokenService tokenService;
/**
* 个人信息
*/
@GetMapping
public AjaxResult profile()
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
SysUser user = loginUser.getUser();
AjaxResult ajax = AjaxResult.success(user);
ajax.put("roleGroup", userService.selectUserRoleGroup(loginUser.getUsername()));
ajax.put("postGroup", userService.selectUserPostGroup(loginUser.getUsername()));
return ajax;
}
/**
* 修改用户
*/
@Log(title = "个人信息", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult updateProfile(@RequestBody SysUser user)
{
if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败,手机号码已存在");
}
if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败,邮箱账号已存在");
}
if (userService.updateUserProfile(user) > 0)
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
// 更新缓存用户信息
loginUser.getUser().setNickName(user.getNickName());
loginUser.getUser().setPhonenumber(user.getPhonenumber());
loginUser.getUser().setEmail(user.getEmail());
loginUser.getUser().setSex(user.getSex());
tokenService.setLoginUser(loginUser);
return AjaxResult.success();
}
return AjaxResult.error("修改个人信息异常,请联系管理员");
}
/**
* 重置密码
*/
@Log(title = "个人信息", businessType = BusinessType.UPDATE)
@PutMapping("/updatePwd")
public AjaxResult updatePwd(String oldPassword, String newPassword)
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
String userName = loginUser.getUsername();
String password = loginUser.getPassword();
if (!SecurityUtils.matchesPassword(oldPassword, password))
{
return AjaxResult.error("修改密码失败,旧密码错误");
}
if (SecurityUtils.matchesPassword(newPassword, password))
{
return AjaxResult.error("新密码不能与旧密码相同");
}
if (userService.resetUserPwd(userName, SecurityUtils.encryptPassword(newPassword)) > 0)
{
// 更新缓存用户密码
loginUser.getUser().setPassword(SecurityUtils.encryptPassword(newPassword));
tokenService.setLoginUser(loginUser);
return AjaxResult.success();
}
return AjaxResult.error("修改密码异常,请联系管理员");
}
/**
* 头像上传
*/
@Log(title = "用户头像", businessType = BusinessType.UPDATE)
@PostMapping("/avatar")
public AjaxResult avatar(@RequestParam("avatarfile") MultipartFile file) throws IOException
{
if (!file.isEmpty())
{
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
String avatar = FileUploadUtils.upload(RuoYiConfig.getAvatarPath(), file);
avatar = serverConfig.getUrl()+avatar;
if (userService.updateUserAvatar(loginUser.getUsername(), avatar))
{
AjaxResult ajax = AjaxResult.success();
ajax.put("imgUrl", avatar);
// 更新缓存用户头像
loginUser.getUser().setAvatar(avatar);
tokenService.setLoginUser(loginUser);
return ajax;
}
}
return AjaxResult.error("上传图片异常,请联系管理员");
}
}
@@ -0,0 +1,182 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.service.SysPermissionService;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.service.ISysRoleService;
import com.ruoyi.system.service.ISysUserService;
/**
* 角色信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/role")
public class SysRoleController extends BaseController
{
@Autowired
private ISysRoleService roleService;
@Autowired
private TokenService tokenService;
@Autowired
private SysPermissionService permissionService;
@Autowired
private ISysUserService userService;
@PreAuthorize("@ss.hasPermi('system:role:list')")
@GetMapping("/list")
public TableDataInfo list(SysRole role)
{
startPage();
List<SysRole> list = roleService.selectRoleList(role);
return getDataTable(list);
}
@Log(title = "角色管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:role:export')")
@GetMapping("/export")
public AjaxResult export(SysRole role)
{
List<SysRole> list = roleService.selectRoleList(role);
ExcelUtil<SysRole> util = new ExcelUtil<SysRole>(SysRole.class);
return util.exportExcel(list, "角色数据");
}
/**
* 根据角色编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:role:query')")
@GetMapping(value = "/{roleId}")
public AjaxResult getInfo(@PathVariable Long roleId)
{
return AjaxResult.success(roleService.selectRoleById(roleId));
}
/**
* 新增角色
*/
@PreAuthorize("@ss.hasPermi('system:role:add')")
@Log(title = "角色管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysRole role)
{
if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role)))
{
return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败,角色名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role)))
{
return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败,角色权限已存在");
}
role.setCreateBy(SecurityUtils.getUsername());
return toAjax(roleService.insertRole(role));
}
/**
* 修改保存角色
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysRole role)
{
roleService.checkRoleAllowed(role);
if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role)))
{
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败,角色名称已存在");
}
else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role)))
{
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败,角色权限已存在");
}
role.setUpdateBy(SecurityUtils.getUsername());
if (roleService.updateRole(role) > 0)
{
// 更新缓存用户权限
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
if (StringUtils.isNotNull(loginUser.getUser()) && !loginUser.getUser().isAdmin())
{
loginUser.setPermissions(permissionService.getMenuPermission(loginUser.getUser()));
loginUser.setUser(userService.selectUserByUserName(loginUser.getUser().getUserName()));
tokenService.setLoginUser(loginUser);
}
return AjaxResult.success();
}
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败,请联系管理员");
}
/**
* 修改保存数据权限
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping("/dataScope")
public AjaxResult dataScope(@RequestBody SysRole role)
{
roleService.checkRoleAllowed(role);
return toAjax(roleService.authDataScope(role));
}
/**
* 状态修改
*/
@PreAuthorize("@ss.hasPermi('system:role:edit')")
@Log(title = "角色管理", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public AjaxResult changeStatus(@RequestBody SysRole role)
{
roleService.checkRoleAllowed(role);
role.setUpdateBy(SecurityUtils.getUsername());
return toAjax(roleService.updateRoleStatus(role));
}
/**
* 删除角色
*/
@PreAuthorize("@ss.hasPermi('system:role:remove')")
@Log(title = "角色管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{roleIds}")
public AjaxResult remove(@PathVariable Long[] roleIds)
{
return toAjax(roleService.deleteRoleByIds(roleIds));
}
/**
* 获取角色选择框列表
*/
@PreAuthorize("@ss.hasPermi('system:role:query')")
@GetMapping("/optionselect")
public AjaxResult optionselect()
{
return AjaxResult.success(roleService.selectRoleAll());
}
}
@@ -0,0 +1,351 @@
package com.ruoyi.web.controller.system;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.exception.CustomException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.dto.EncryptedRequest;
import com.ruoyi.system.security.RsaKeyUtil;
import com.ruoyi.system.security.SecureClient;
import com.ruoyi.system.service.PaymentSignatureService;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.*;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestClientResponseException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.security.PublicKey;
import java.security.Signature;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
/**
* 公开支付演示入口;加密凭据仅从服务端环境变量读取。
*/
@RestController
@RequestMapping("/system/demoUsdt")
public class SysUsdtDemoController {
private static final Logger log = LoggerFactory.getLogger(SysUsdtDemoController.class);
private static final String DEFAULT_API_URL =
"http://192.168.3.103:2020/api/v1/order/create-transaction";
private static final String DEFAULT_QUERY_API_URL =
"http://192.168.3.103:2020/api/v1/order/query";
private static final String DEFAULT_PAYOUT_API_URL =
"http://192.168.3.103:2020/api/v1/payout/create";
private static final String DEFAULT_PAYOUT_QUERY_API_URL =
"http://192.168.3.103:2020/api/v1/payout/query";
private final RestTemplate restTemplate;
public SysUsdtDemoController() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(60000);
factory.setReadTimeout(60000);
this.restTemplate = new RestTemplate(factory);
}
@ApiOperation(value = "notify")
@ResponseBody
@PostMapping("/notify")
public ResponseEntity<String> notify(
@RequestHeader(value = "X-Payment-Api-Key", required = false) String apiKey,
@RequestHeader(value = "X-Payment-Rsa-Signature", required = false) String signature,
@RequestBody(required = false) String body) {
try {
JSONObject payload = parseCallbackPayload(body);
if (!verifyCallback(payload, apiKey, signature)) {
log.warn("支付演示异步回调验签失败");
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
}
// 不记录完整回调正文、签名或API Key,避免业务数据和凭据进入日志。
log.info("支付演示异步回调验签成功,orderId={}", payload.getString("order_id"));
return ResponseEntity.ok("ok");
} catch (Exception exception) {
log.warn("支付演示异步回调格式或配置校验失败,异常类型={}",
exception.getClass().getSimpleName());
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
}
}
@GetMapping("/redirect")
@ResponseBody
public ResponseEntity<String> redirect(
@RequestParam(value = "order_id", required = false) String orderId,
@RequestParam(value = "trade_id", required = false) String tradeId,
@RequestParam(value = "status", required = false) Integer status,
@RequestParam(value = "transaction_id", required = false) String transactionId,
@RequestParam(value = "api_key", required = false) String apiKey,
@RequestParam(value = "signature", required = false) String signature) {
Map<String, Object> values = callbackValues(orderId, tradeId, status, transactionId);
if (!hasRequiredCallbackFields(values) || !verifyCallback(values, apiKey, signature)) {
log.warn("支付演示同步跳转验签失败");
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
}
log.info("支付演示同步跳转验签成功,orderId={}", orderId);
return ResponseEntity.ok("redirect SUCCESS");
}
/**
* 使用 RSA-AES-HMAC 协议创建支付订单。
*/
@PostMapping("/pay")
public AjaxResult pay(@RequestParam("amount") String amount,
@RequestParam(value = "walletUserName", required = false) String walletUserName,
@RequestParam(value = "redirectUrl", required = false) String redirectUrl,
@RequestParam(value = "notifyUrl", required = false) String notifyUrl) {
BigDecimal paymentAmount = parseAmount(amount);
String apiUrl = optionalEnv("PAYMENT_API_URL", DEFAULT_API_URL);
try {
String contextPath = ServletUriComponentsBuilder.fromCurrentContextPath()
.build().toUriString();
Map<String, Object> params = new HashMap<String, Object>();
params.put("order_id", "demo-" + System.currentTimeMillis() + '-'
+ UUID.randomUUID().toString().substring(0, 8));
params.put("walletUserName", normalizeWalletUserName(walletUserName));
params.put("amount", paymentAmount.toPlainString());
params.put("notify_url", normalizeCallbackUrl(notifyUrl, optionalEnv("PAYMENT_NOTIFY_URL",
contextPath + "/system/demoUsdt/notify"), "异步回调地址", true));
params.put("redirect_url", normalizeCallbackUrl(redirectUrl, optionalEnv("PAYMENT_REDIRECT_URL",
contextPath + "/system/demoUsdt/redirect"), "跳转地址", true));
return AjaxResult.success(sendEncryptedRequest(apiUrl, params, "创建支付订单失败"));
} catch (RestClientResponseException ex) {
log.warn("支付演示请求失败,HTTP状态={}", ex.getRawStatusCode());
throw new CustomException("支付服务暂时不可用,请稍后重试");
} catch (CustomException ex) {
throw ex;
} catch (Exception ex) {
log.warn("支付演示创建订单失败,异常类型={}", ex.getClass().getSimpleName());
throw new CustomException("创建支付订单失败,请检查服务端支付配置");
}
}
/**
* 查询支付状态;API 凭据和加密过程不会暴露给浏览器。
*/
@PostMapping("/order-status")
public AjaxResult orderStatus(@RequestParam("orderId") String orderId) {
String normalized = orderId == null ? "" : orderId.trim();
if (normalized.isEmpty() || normalized.length() > 32
|| !normalized.matches("[A-Za-z0-9_-]+")) {
throw new CustomException("订单号格式不正确");
}
Map<String, Object> params = new HashMap<String, Object>();
params.put("order_id", normalized);
String queryUrl = optionalEnv("PAYMENT_QUERY_API_URL", DEFAULT_QUERY_API_URL);
try {
return AjaxResult.success(sendEncryptedRequest(queryUrl, params, "查询支付订单失败"));
} catch (RestClientResponseException ex) {
log.warn("支付状态查询失败,HTTP状态={}", ex.getRawStatusCode());
throw new CustomException("支付状态查询暂时不可用");
} catch (CustomException ex) {
throw ex;
} catch (Exception ex) {
log.warn("支付状态查询失败,异常类型={}", ex.getClass().getSimpleName());
throw new CustomException("支付状态查询暂时不可用");
}
}
/**
* RSA-AES-HMAC代付创建客户端示例,不依赖浏览器上下文。
*/
@PostMapping("/payout")
public AjaxResult payout(@RequestParam String orderId, @RequestParam String currency,
@RequestParam String amount, @RequestParam String toAddress,
@RequestParam String notifyUrl, @RequestParam(required = false) String redirectUrl) {
Map<String, Object> p = new HashMap<String, Object>();
p.put("order_id", orderId);
p.put("currency", currency);
p.put("amount", amount);
p.put("to_address", toAddress);
p.put("notify_url", notifyUrl);
p.put("redirect_url", redirectUrl);
try {
return AjaxResult.success(sendEncryptedRequest(optionalEnv("PAYOUT_API_URL", DEFAULT_PAYOUT_API_URL), p, "创建代付订单失败"));
} catch (Exception e) {
throw e instanceof CustomException ? (CustomException) e : new CustomException("创建代付订单失败");
}
}
/**
* 代付查询示例;完成后响应中的redirect_url由商户前端自行跳转。
*/
@PostMapping("/payout-status")
public AjaxResult payoutStatus(@RequestParam String orderId) {
Map<String, Object> p = new HashMap<String, Object>();
p.put("order_id", orderId);
try {
return AjaxResult.success(sendEncryptedRequest(optionalEnv("PAYOUT_QUERY_API_URL", DEFAULT_PAYOUT_QUERY_API_URL), p, "查询代付订单失败"));
} catch (Exception e) {
throw e instanceof CustomException ? (CustomException) e : new CustomException("查询代付订单失败");
}
}
@PostMapping("/payout-notify")
@ResponseBody
public ResponseEntity<String> payoutNotify(@RequestHeader(value = "X-Payment-Api-Key", required = false) String apiKey,
@RequestHeader(value = "X-Payment-Rsa-Signature", required = false) String signature, @RequestBody(required = false) String body) {
try {
JSONObject p = JSON.parseObject(body);
if (p == null || !"3".equals(p.getString("status")) || !verifyCallback(p, apiKey, signature))
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
return ResponseEntity.ok("ok");
} catch (Exception e) {
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
}
}
@GetMapping("/payout-redirect")
@ResponseBody
public ResponseEntity<String> payoutRedirect(@RequestParam Map<String, String> parameters) {
String signature = parameters.remove("signature");
parameters.remove("api_key");
if (!"3".equals(parameters.get("status")) || !verifyCallback(parameters, null, signature))
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("invalid signature");
return ResponseEntity.ok("payout redirect SUCCESS");
}
private Object sendEncryptedRequest(String apiUrl, Map<String, Object> params,
String failureMessage) throws Exception {
String apiKey = requiredEnvWithAlias("PAYMENT_API_KEY", "PAYMENT_API_KEK");
String apiSecret = requiredEnv("PAYMENT_API_SECRET");
PublicKey publicKey = RsaKeyUtil.loadPublicKey(
requiredEnv("PAYMENT_RSA_PUBLIC_KEY").replace("\\n", "\n"));
EncryptedRequest encrypted = SecureClient.encrypt(apiKey, apiSecret, publicKey, params);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.setAccept(java.util.Collections.singletonList(MediaType.APPLICATION_JSON));
ResponseEntity<String> response = restTemplate.exchange(apiUrl, HttpMethod.POST,
new HttpEntity<EncryptedRequest>(encrypted, headers), String.class);
JSONObject result = JSON.parseObject(response.getBody());
if (result == null || result.getIntValue("code") != 200 || result.get("data") == null) {
throw new CustomException(result == null || StringUtils.isBlank(result.getString("msg"))
? failureMessage : result.getString("msg"));
}
return result.get("data");
}
private BigDecimal parseAmount(String amount) {
try {
BigDecimal value = new BigDecimal(amount);
if (value.compareTo(BigDecimal.ZERO) <= 0 || value.scale() > 2) {
throw new NumberFormatException();
}
return value;
} catch (Exception ex) {
throw new CustomException("支付金额必须大于0且最多保留2位小数");
}
}
/**
* 将异步通知JSON规范化为签名字段,拒绝嵌套值和缺失的核心订单字段。
*/
private JSONObject parseCallbackPayload(String body) {
if (StringUtils.isBlank(body)) {
throw new CustomException("回调正文为空");
}
JSONObject payload = JSON.parseObject(body);
if (payload == null || !hasRequiredCallbackFields(payload)) {
throw new CustomException("回调参数不完整");
}
for (Object value : payload.values()) {
if (value instanceof Map || value instanceof Iterable) {
throw new CustomException("回调参数格式错误");
}
}
return payload;
}
private Map<String, Object> callbackValues(String orderId, String tradeId,
Integer status, String transactionId) {
Map<String, Object> values = new HashMap<String, Object>();
values.put("order_id", orderId);
values.put("trade_id", tradeId);
values.put("status", status);
values.put("transaction_id", transactionId);
return values;
}
private boolean hasRequiredCallbackFields(Map<String, ?> values) {
Object orderId = values.get("order_id");
Object tradeId = values.get("trade_id");
Object status = values.get("status");
return orderId != null && StringUtils.isNotBlank(String.valueOf(orderId))
&& tradeId != null && StringUtils.isNotBlank(String.valueOf(tradeId))
&& status != null && "2".equals(String.valueOf(status));
}
/**
* 回调采用 RSA 单验签。创建请求加密与回调验签必须使用同一应用公钥,
* API Key仅用于标识本次回调,不参与认证,避免密钥轮换后拒绝合法回调。
*/
private boolean verifyCallback(Map<String, ?> values, String apiKey, String signature) {
if (StringUtils.isBlank(signature)) return false;
try {
PublicKey publicKey = RsaKeyUtil.loadPublicKey(
requiredEnv("PAYMENT_RSA_PUBLIC_KEY").replace("\\n", "\n"));
Signature verifier = Signature.getInstance("SHA256withRSA");
verifier.initVerify(publicKey);
verifier.update(PaymentSignatureService.canonicalText(values).getBytes(StandardCharsets.UTF_8));
return verifier.verify(Base64.getDecoder().decode(signature));
} catch (Exception ex) {
return false;
}
}
private String normalizeWalletUserName(String value) {
if (StringUtils.isBlank(value)) {
return "demo-user-" + UUID.randomUUID().toString().replace("-", "");
}
String normalized = value.trim();
if (normalized.length() > 128 || !normalized.matches("[A-Za-z0-9_.@-]+")) {
throw new CustomException("支付用户标识格式不正确");
}
return normalized;
}
private String normalizeCallbackUrl(String value, String defaultValue, String label,
boolean allowHttp) {
if (StringUtils.isBlank(value)) return defaultValue;
String normalized = value.trim();
if (normalized.length() > 512 || !((allowHttp && normalized.startsWith("http://"))
|| normalized.startsWith("https://")
|| normalized.startsWith("http://localhost")
|| normalized.startsWith("http://127.0.0.1"))) {
throw new CustomException(label + "必须使用HTTPS");
}
return normalized;
}
protected String requiredEnv(String name) {
String value = System.getenv(name);
if (StringUtils.isBlank(value)) {
throw new CustomException("服务端缺少环境变量 " + name);
}
return value.trim();
}
protected String requiredEnvWithAlias(String name, String alias) {
String value = System.getenv(name);
if (StringUtils.isBlank(value)) {
value = System.getenv(alias);
}
if (StringUtils.isBlank(value)) {
throw new CustomException("服务端缺少环境变量 " + name);
}
return value.trim();
}
private String optionalEnv(String name, String defaultValue) {
String value = System.getenv(name);
return StringUtils.isBlank(value) ? defaultValue : value.trim();
}
}
@@ -0,0 +1,291 @@
package com.ruoyi.web.controller.system;
import java.util.List;
import java.util.stream.Collectors;
import com.ruoyi.common.select.Ids;
import com.ruoyi.common.select.SelectItem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.service.ISysPostService;
import com.ruoyi.system.service.ISysRoleService;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.web.controller.system.dto.UsdtUserRegisterRequest;
/**
* 用户信息
*
* @author ruoyi
*/
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController
{
private static final Long USDT_PORTAL_DEPT_ID = 103L;
private static final String USDT_ROLE_KEY = "usdt";
private static final String WEB_CREATE_BY = "web";
@Autowired
private ISysUserService userService;
@Autowired
private ISysRoleService roleService;
@Autowired
private ISysPostService postService;
@Autowired
private TokenService tokenService;
/**
* USDT用户门户公开注册。
* 部门、性别、状态、角色和创建来源全部由服务端固定,客户端不能覆盖。
*/
@PostMapping("/usdt/register")
public AjaxResult registerUsdtUser(@Validated @RequestBody UsdtUserRegisterRequest request)
{
String userName = request.getUserName().trim();
String email = request.getEmail().trim();
String nickName = request.getNickName().trim();
if (StringUtils.isEmpty(nickName))
{
return AjaxResult.error("昵称不能为空");
}
if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(userName)))
{
return AjaxResult.error("注册失败,用户名已存在");
}
SysUser user = new SysUser();
user.setUserName(userName);
user.setEmail(email);
if (UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.error("注册失败,邮箱已存在");
}
SysRole usdtRole = roleService.selectRoleByRoleKey(USDT_ROLE_KEY);
if (StringUtils.isNull(usdtRole) || UserConstants.ROLE_DISABLE.equals(usdtRole.getStatus())
|| !UserConstants.NORMAL.equals(usdtRole.getDelFlag()))
{
return AjaxResult.error("USDT用户角色未配置或已停用,请联系管理员");
}
user.setNickName(nickName);
user.setDeptId(USDT_PORTAL_DEPT_ID);
user.setSex("0");
user.setStatus(UserConstants.NORMAL);
user.setDelFlag(UserConstants.NORMAL);
user.setCreateBy(WEB_CREATE_BY);
user.setRoleIds(new Long[] { usdtRole.getRoleId() });
user.setPostIds(new Long[0]);
user.setPassword(SecurityUtils.encryptPassword(request.getPassword()));
return toAjax(userService.insertUser(user));
}
/**
* 获取用户列表
*/
@PreAuthorize("@ss.hasPermi('system:user:list')")
@GetMapping("/list")
public TableDataInfo list(SysUser user)
{
startPage();
List<SysUser> list = userService.selectUserList(user);
return getDataTable(list);
}
@PreAuthorize("@ss.hasPermi('system:user:getByIds')")
@PostMapping("/getByIds")
public AjaxResult getByIds(@RequestBody Ids ids)
{
List<SysUser> list = userService.selectListUserByIds(ids.getLongIds());
return AjaxResult.success(list);
}
@PreAuthorize("@ss.hasPermi('system:user:user-getByIds')")
@PostMapping("/user/getByIds")
public AjaxResult UserGetByIds(@RequestBody Ids ids)
{
List<SysUser> list = userService.userSelectListUserByIds(ids.getLongIds());
return AjaxResult.success(list);
}
@PreAuthorize("@ss.hasPermi('system:user:select')")
@GetMapping("/select")
public AjaxResult select(String keyword)
{
List<SelectItem> list = userService.select(keyword);
return AjaxResult.success(list);
}
@PreAuthorize("@ss.hasPermi('system:user:user-select')")
@GetMapping("/user/select")
public AjaxResult userSelect(String keyword)
{
List<SelectItem> list = userService.userSelect(keyword);
return AjaxResult.success(list);
}
@Log(title = "用户管理", businessType = BusinessType.EXPORT)
@PreAuthorize("@ss.hasPermi('system:user:export')")
@GetMapping("/export")
public AjaxResult export(SysUser user)
{
List<SysUser> list = userService.selectUserList(user);
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
return util.exportExcel(list, "用户数据");
}
@Log(title = "用户管理", businessType = BusinessType.IMPORT)
@PreAuthorize("@ss.hasPermi('system:user:import')")
@PostMapping("/importData")
public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception
{
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
List<SysUser> userList = util.importExcel(file.getInputStream());
LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
String operName = loginUser.getUsername();
String message = userService.importUser(userList, updateSupport, operName);
return AjaxResult.success(message);
}
@GetMapping("/importTemplate")
public AjaxResult importTemplate()
{
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
return util.importTemplateExcel("用户数据");
}
/**
* 根据用户编号获取详细信息
*/
@PreAuthorize("@ss.hasPermi('system:user:query')")
@GetMapping(value = { "/", "/{userId}" })
public AjaxResult getInfo(@PathVariable(value = "userId", required = false) Long userId)
{
AjaxResult ajax = AjaxResult.success();
List<SysRole> roles = roleService.selectRoleAll();
ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
ajax.put("posts", postService.selectPostAll());
if (StringUtils.isNotNull(userId))
{
ajax.put(AjaxResult.DATA_TAG, userService.selectUserById(userId));
ajax.put("postIds", postService.selectPostListByUserId(userId));
ajax.put("roleIds", roleService.selectRoleListByUserId(userId));
}
return ajax;
}
@PreAuthorize("@ss.hasPermi('system:user:user-query')")
@GetMapping(value = { "/user/info" })
public AjaxResult userGetInfo()
{
return AjaxResult.success(userService.selectUserById(SecurityUtils.getUserId()));
}
/**
* 新增用户
*/
@PreAuthorize("@ss.hasPermi('system:user:add')")
@Log(title = "用户管理", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@Validated @RequestBody SysUser user)
{
if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(user.getUserName())))
{
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败,登录账号已存在");
}
else if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败,手机号码已存在");
}
else if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败,邮箱账号已存在");
}
user.setCreateBy(SecurityUtils.getUsername());
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
return toAjax(userService.insertUser(user));
}
/**
* 修改用户
*/
@PreAuthorize("@ss.hasPermi('system:user:edit')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@Validated @RequestBody SysUser user)
{
userService.checkUserAllowed(user);
if (StringUtils.isNotEmpty(user.getPhonenumber())
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败,手机号码已存在");
}
else if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user)))
{
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败,邮箱账号已存在");
}
user.setUpdateBy(SecurityUtils.getUsername());
return toAjax(userService.updateUser(user));
}
/**
* 删除用户
*/
@PreAuthorize("@ss.hasPermi('system:user:remove')")
@Log(title = "用户管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{userIds}")
public AjaxResult remove(@PathVariable Long[] userIds)
{
return toAjax(userService.deleteUserByIds(userIds));
}
/**
* 重置密码
*/
@PreAuthorize("@ss.hasPermi('system:user:resetPwd')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping("/resetPwd")
public AjaxResult resetPwd(@RequestBody SysUser user)
{
userService.checkUserAllowed(user);
user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
user.setUpdateBy(SecurityUtils.getUsername());
return toAjax(userService.resetPwd(user));
}
/**
* 状态修改
*/
@PreAuthorize("@ss.hasPermi('system:user:edit')")
@Log(title = "用户管理", businessType = BusinessType.UPDATE)
@PutMapping("/changeStatus")
public AjaxResult changeStatus(@RequestBody SysUser user)
{
userService.checkUserAllowed(user);
user.setUpdateBy(SecurityUtils.getUsername());
return toAjax(userService.updateUserStatus(user));
}
}
@@ -0,0 +1,130 @@
package com.ruoyi.web.controller.system;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.service.IWxService;
import com.ruoyi.system.domain.ReqCommonDTO;
import com.ruoyi.system.domain.SysWxUser;
import com.ruoyi.system.service.ISysWxUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 微信用户Controller
*
* @author luqj
* @date 2021-10-28
*/
@RestController
@RequestMapping("/system/wxUser")
public class SysWxUserController extends BaseController
{
@Autowired
private ISysWxUserService sysWxUserService;
@Autowired
private IWxService wxService;
/**
* 查询微信用户列表
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:list')")
@GetMapping("/list")
public TableDataInfo list(SysWxUser sysWxUser)
{
startPage();
List<SysWxUser> list = sysWxUserService.selectSysWxUserList(sysWxUser);
return getDataTable(list);
}
/**
* 导出微信用户列表
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:export')")
@Log(title = "微信用户", businessType = BusinessType.EXPORT)
@GetMapping("/export")
public AjaxResult export(SysWxUser sysWxUser)
{
List<SysWxUser> list = sysWxUserService.selectSysWxUserList(sysWxUser);
ExcelUtil<SysWxUser> util = new ExcelUtil<SysWxUser>(SysWxUser.class);
return util.exportExcel(list, "wxUser");
}
/**
* 获取微信用户详细信息
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:query')")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") String id)
{
return AjaxResult.success(sysWxUserService.selectSysWxUserById(id));
}
/**
* 新增微信用户
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:add')")
@Log(title = "微信用户", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody SysWxUser sysWxUser)
{
return toAjax(sysWxUserService.insertSysWxUser(sysWxUser));
}
/**
* 修改微信用户
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:edit')")
@Log(title = "微信用户", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody SysWxUser sysWxUser)
{
return toAjax(sysWxUserService.updateSysWxUser(sysWxUser));
}
@PostMapping("/updateAvatar")
@ResponseBody
public AjaxResult updateAvatar(@RequestBody ReqCommonDTO data) {
try {
Boolean result = wxService.updatAvatar(data.getUrl());
if (!result) {
return AjaxResult.error("操作失败");
} else {
return AjaxResult.success("更新成功", result);
}
} catch (Exception ex) {
return AjaxResult.error(ex.getMessage());
}
}
@PostMapping("/updateNickName")
@ResponseBody
@RepeatSubmit
public AjaxResult updateNickName(@RequestBody ReqCommonDTO data) {
try {
Boolean result = wxService.updateNickName(data.getName());
if (!result) {
return AjaxResult.error("操作失败");
} else {
return AjaxResult.success("更新成功", result);
}
} catch (Exception ex) {
return AjaxResult.error(ex.getMessage());
}
}
/**
* 删除微信用户
*/
@PreAuthorize("@ss.hasPermi('system:wxUser:remove')")
@Log(title = "微信用户", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable String[] ids)
{
return toAjax(sysWxUserService.deleteSysWxUserByIds(ids));
}
}
@@ -0,0 +1,67 @@
package com.ruoyi.web.controller.system;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.model.LoginBody;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.web.service.TotpAuthService;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/** Authenticator 六位动态码;只有 login 匿名开放,管理接口使用当前 JWT 用户 ID。 */
@RestController
@RequestMapping("/auth/totp")
public class TotpAuthController {
private final TotpAuthService service;
public TotpAuthController(TotpAuthService service) {
this.service = service;
}
@GetMapping("/binding")
public AjaxResult status(HttpServletResponse response) {
response.setHeader("Cache-Control", "no-store");
return AjaxResult.success(service.status(SecurityUtils.getUserId()));
}
@PostMapping("/setup")
public AjaxResult setup(@RequestBody TotpRequest request, HttpServletResponse response) {
response.setHeader("Cache-Control", "no-store");
return AjaxResult.success(service.setup(SecurityUtils.getUserId(), request.getPassword()));
}
@PostMapping("/bind")
public AjaxResult bind(@RequestBody TotpRequest request) {
service.bind(SecurityUtils.getUserId(), request.getPassword(), request.getTotpCode());
return AjaxResult.success("Authenticator 已绑定,下一个动态码刷新后可用于登录");
}
@PostMapping("/unbind")
public AjaxResult unbind(@RequestBody TotpRequest request) {
service.unbind(SecurityUtils.getUserId(), request.getPassword(), request.getTotpCode());
return AjaxResult.success("Authenticator 已解绑");
}
@PostMapping("/login")
public AjaxResult login(@RequestBody TotpRequest request, HttpServletRequest servletRequest,
HttpServletResponse response) {
response.setHeader("Cache-Control", "no-store");
AjaxResult result = AjaxResult.success();
result.put(Constants.TOKEN, service.login(request.getUsername(), request.getTotpCode(),
request.getCode(), request.getUuid(), servletRequest.getRemoteAddr()));
return result;
}
/** 禁止生成包含密码、动态码的 toString;动态码与图形验证码分开传输。 */
public static class TotpRequest extends LoginBody {
private String totpCode;
public String getTotpCode() { return totpCode; }
public void setTotpCode(String totpCode) { this.totpCode = totpCode; }
}
}
@@ -0,0 +1,60 @@
package com.ruoyi.web.controller.system;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.framework.web.service.IWxService;
import com.ruoyi.system.domain.ReqUserDTO;
import com.ruoyi.web.controller.tool.WXPublicUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
/**
* 【请填写功能名称】Controller
*
* @author dd
* @date 2021-05-02
*/
@Controller
@RequestMapping("/system/wx")
public class WxController extends BaseController {
@Autowired
private IWxService wxService;
@GetMapping("/get-open-id")
@ResponseBody
public AjaxResult getOpenId(@RequestParam(value = "code") String code,
@RequestParam(value = "iv") String iv,
@RequestParam(value = "signature") String signature,
@RequestParam(value = "encryptedData") String encryptedData) {
try {
ReqUserDTO result = wxService.getOpenId(code, encryptedData, iv, signature);
if (null == result) {
return AjaxResult.error("获取失败");
} else {
return AjaxResult.success("获取成功", result);
}
} catch (Exception ex) {
return AjaxResult.error(ex.getMessage());
}
}
@GetMapping("/wxMessage")
@ResponseBody
public String wxMessage(HttpServletRequest request) throws Exception {
String msgSignature = request.getParameter("signature");
String msgTimestamp = request.getParameter("timestamp");
String msgNonce = request.getParameter("nonce");
String echostr = request.getParameter("echostr");
if (WXPublicUtils.verifyUrl(msgSignature, msgTimestamp, msgNonce)) {
return echostr;
}
return null;
}
}
@@ -0,0 +1,57 @@
package com.ruoyi.web.controller.system.dto;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
/** USDT用户门户公开注册请求,只接收用户必须填写的字段。 */
public class UsdtUserRegisterRequest {
@NotBlank(message = "用户名不能为空")
@Size(min = 2, max = 30, message = "用户名长度必须在2到30个字符之间")
private String userName;
@NotBlank(message = "密码不能为空")
@Size(min = 6, max = 100, message = "密码长度必须在6到100个字符之间")
private String password;
@NotBlank(message = "邮箱不能为空")
@Email(message = "邮箱格式不正确")
@Size(max = 50, message = "邮箱长度不能超过50个字符")
private String email;
@NotBlank(message = "昵称不能为空")
@Size(max = 30, message = "昵称长度不能超过30个字符")
private String nickName;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
}
@@ -0,0 +1,24 @@
package com.ruoyi.web.controller.tool;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ruoyi.common.core.controller.BaseController;
/**
* swagger 接口
*
* @author ruoyi
*/
@Controller
@RequestMapping("/tool/swagger")
public class SwaggerController extends BaseController
{
@PreAuthorize("@ss.hasPermi('tool:swagger:view')")
@GetMapping()
public String index()
{
return redirect("/swagger-ui.html");
}
}
@@ -0,0 +1,175 @@
package com.ruoyi.web.controller.tool;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.StringUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
/**
* swagger 用户测试方法
*
* @author ruoyi
*/
@Api("用户信息管理")
@RestController
@RequestMapping("/test/user")
public class TestController extends BaseController
{
private final static Map<Integer, UserEntity> users = new LinkedHashMap<Integer, UserEntity>();
{
users.put(1, new UserEntity(1, "admin", "admin123", "15888888888"));
users.put(2, new UserEntity(2, "ry", "admin123", "15666666666"));
}
@ApiOperation("获取用户列表")
@GetMapping("/list")
public AjaxResult userList()
{
List<UserEntity> userList = new ArrayList<UserEntity>(users.values());
return AjaxResult.success(userList);
}
@ApiOperation("获取用户详细")
@ApiImplicitParam(name = "userId", value = "用户ID", required = true, dataType = "int", paramType = "path")
@GetMapping("/{userId}")
public AjaxResult getUser(@PathVariable Integer userId)
{
if (!users.isEmpty() && users.containsKey(userId))
{
return AjaxResult.success(users.get(userId));
}
else
{
return AjaxResult.error("用户不存在");
}
}
@ApiOperation("新增用户")
@ApiImplicitParam(name = "userEntity", value = "新增用户信息", dataType = "UserEntity")
@PostMapping("/save")
public AjaxResult save(UserEntity user)
{
if (StringUtils.isNull(user) || StringUtils.isNull(user.getUserId()))
{
return AjaxResult.error("用户ID不能为空");
}
return AjaxResult.success(users.put(user.getUserId(), user));
}
@ApiOperation("更新用户")
@ApiImplicitParam(name = "userEntity", value = "新增用户信息", dataType = "UserEntity")
@PutMapping("/update")
public AjaxResult update(UserEntity user)
{
if (StringUtils.isNull(user) || StringUtils.isNull(user.getUserId()))
{
return AjaxResult.error("用户ID不能为空");
}
if (users.isEmpty() || !users.containsKey(user.getUserId()))
{
return AjaxResult.error("用户不存在");
}
users.remove(user.getUserId());
return AjaxResult.success(users.put(user.getUserId(), user));
}
@ApiOperation("删除用户信息")
@ApiImplicitParam(name = "userId", value = "用户ID", required = true, dataType = "int", paramType = "path")
@DeleteMapping("/{userId}")
public AjaxResult delete(@PathVariable Integer userId)
{
if (!users.isEmpty() && users.containsKey(userId))
{
users.remove(userId);
return AjaxResult.success();
}
else
{
return AjaxResult.error("用户不存在");
}
}
}
@ApiModel("用户实体")
class UserEntity
{
@ApiModelProperty("用户ID")
private Integer userId;
@ApiModelProperty("用户名称")
private String username;
@ApiModelProperty("用户密码")
private String password;
@ApiModelProperty("用户手机")
private String mobile;
public UserEntity()
{
}
public UserEntity(Integer userId, String username, String password, String mobile)
{
this.userId = userId;
this.username = username;
this.password = password;
this.mobile = mobile;
}
public Integer getUserId()
{
return userId;
}
public void setUserId(Integer userId)
{
this.userId = userId;
}
public String getUsername()
{
return username;
}
public void setUsername(String username)
{
this.username = username;
}
public String getPassword()
{
return password;
}
public void setPassword(String password)
{
this.password = password;
}
public String getMobile()
{
return mobile;
}
public void setMobile(String mobile)
{
this.mobile = mobile;
}
}
@@ -0,0 +1,53 @@
package com.ruoyi.web.controller.tool;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.security.MessageDigest;
import java.util.Arrays;
public class WXPublicUtils {
private static final Logger logger = LoggerFactory.getLogger(WXPublicUtils.class);
public static boolean verifyUrl(String msgSignature, String timeStamp, String nonce)
throws Exception {
String signature = getSHA1("luqingjie", timeStamp, nonce);
if (!signature.equals(msgSignature)) {
throw new Exception("token验证失败");
}
return true;
}
public static String getSHA1(String token, String timestamp, String nonce) throws Exception {
try {
String[] array = new String[]{token, timestamp, nonce};
StringBuffer sb = new StringBuffer();
// 字符串排序
Arrays.sort(array);
for (int i = 0; i < 3; i++) {
sb.append(array[i]);
}
String str = sb.toString();
// SHA1签名生成
MessageDigest md = MessageDigest.getInstance("SHA-1");
md.update(str.getBytes());
byte[] digest = md.digest();
StringBuffer hexstr = new StringBuffer();
String shaHex = "";
for (int i = 0; i < digest.length; i++) {
shaHex = Integer.toHexString(digest[i] & 0xFF);
if (shaHex.length() < 2) {
hexstr.append(0);
}
hexstr.append(shaHex);
}
return hexstr.toString();
} catch (Exception e) {
e.printStackTrace();
throw new Exception("token验证失败");
}
}
}
@@ -0,0 +1,125 @@
package com.ruoyi.web.core.config;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.ruoyi.common.config.RuoYiConfig;
import io.swagger.annotations.ApiOperation;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey;
import springfox.documentation.service.AuthorizationScope;
import springfox.documentation.service.Contact;
import springfox.documentation.service.SecurityReference;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* Swagger2的接口配置
*
* @author ruoyi
*/
@Configuration
@EnableSwagger2
public class SwaggerConfig
{
/** 系统基础配置 */
@Autowired
private RuoYiConfig ruoyiConfig;
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
/** 设置请求的统一前缀 */
@Value("${swagger.pathMapping}")
private String pathMapping;
/**
* 创建API
*/
@Bean
public Docket createRestApi()
{
return new Docket(DocumentationType.SWAGGER_2)
// 是否启用Swagger
.enable(enabled)
// 用来创建该API的基本信息,展示在文档的页面中(自定义展示的信息)
.apiInfo(apiInfo())
// 设置哪些接口暴露给Swagger展示
.select()
// 扫描所有有注解的api,用这种方式更灵活
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 扫描指定包中的swagger注解
// .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger"))
// 扫描所有 .apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build()
/* 设置安全模式,swagger可以设置访问token */
.securitySchemes(securitySchemes())
.securityContexts(securityContexts())
.pathMapping(pathMapping);
}
/**
* 安全模式,这里指定token通过Authorization头请求头传递
*/
private List<ApiKey> securitySchemes()
{
List<ApiKey> apiKeyList = new ArrayList<ApiKey>();
apiKeyList.add(new ApiKey("Authorization", "Authorization", "header"));
return apiKeyList;
}
/**
* 安全上下文
*/
private List<SecurityContext> securityContexts()
{
List<SecurityContext> securityContexts = new ArrayList<>();
securityContexts.add(
SecurityContext.builder()
.securityReferences(defaultAuth())
.forPaths(PathSelectors.regex("^(?!auth).*$"))
.build());
return securityContexts;
}
/**
* 默认的安全上引用
*/
private List<SecurityReference> defaultAuth()
{
AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
authorizationScopes[0] = authorizationScope;
List<SecurityReference> securityReferences = new ArrayList<>();
securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
return securityReferences;
}
/**
* 添加摘要信息
*/
private ApiInfo apiInfo()
{
// 用ApiInfoBuilder进行定制
return new ApiInfoBuilder()
// 设置标题
.title("标题:susdt管理系统_接口文档")
// 描述
.description("描述:用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...")
// 作者信息
.contact(new Contact(ruoyiConfig.getName(), null, null))
// 版本
.version("版本号:" + ruoyiConfig.getVersion())
.build();
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
restart.include.json=/com.alibaba.fastjson.*.jar
Binary file not shown.
@@ -0,0 +1,25 @@
-----BEGIN CERTIFICATE-----
MIIEJDCCAwygAwIBAgIUPOlL81ZXtd49ZjJfyeenJV2JISUwDQYJKoZIhvcNAQEL
BQAwXjELMAkGA1UEBhMCQ04xEzARBgNVBAoTClRlbnBheS5jb20xHTAbBgNVBAsT
FFRlbnBheS5jb20gQ0EgQ2VudGVyMRswGQYDVQQDExJUZW5wYXkuY29tIFJvb3Qg
Q0EwHhcNMjQwNTI0MDcxNDExWhcNMjkwNTIzMDcxNDExWjB+MRMwEQYDVQQDDAox
Njc3NzgxNTYwMRswGQYDVQQKDBLlvq7kv6HllYbmiLfns7vnu58xKjAoBgNVBAsM
IeWOpumXqOaNt+Wuiem4v+enkeaKgOaciemZkOWFrOWPuDELMAkGA1UEBhMCQ04x
ETAPBgNVBAcMCFNoZW5aaGVuMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEAxCnhILGAXh60Vcg3ES/ElIklZoZFGwBCm5GwZoHBg6bHDzA9bXJJN6NXlMAO
Zt1fibeu95wZc4IT1vzDBT+TtImIwh2xa8pKuyypJ9yEtt1qVVA3jGrDF0ZtC5Fu
vG8MKnbFI1ERNG7NZAC9mBem/PurBmi0yQpCqcwmQ3JTy2vrS8tH2uiCYMsOgPu/
4khxozGxFxEl6qkYpq4drINtu0CRXYkvEVNyuUNxBqhDwJlJRWxCUWgpKi4YO3WM
9AaAiZXiEswKNLsMtDC1Yv4B2TA8iKn/j3h0pRZ9ZWBpbVYorWnjnM0aQYuql9BE
vZEoxr+P9trkw84ybj5fAd1D/wIDAQABo4G5MIG2MAkGA1UdEwQCMAAwCwYDVR0P
BAQDAgP4MIGbBgNVHR8EgZMwgZAwgY2ggYqggYeGgYRodHRwOi8vZXZjYS5pdHJ1
cy5jb20uY24vcHVibGljL2l0cnVzY3JsP0NBPTFCRDQyMjBFNTBEQkMwNEIwNkFE
Mzk3NTQ5ODQ2QzAxQzNFOEVCRDImc2c9SEFDQzQ3MUI2NTQyMkUxMkIyN0E5RDMz
QTg3QUQxQ0RGNTkyNkUxNDAzNzEwDQYJKoZIhvcNAQELBQADggEBADwVeYfsHB1T
ZspK7mymq8wh/hz0SLizAZJhPChYlimLgVViruYC+r7pQ85imMhIP83Zwpugwq7r
RhX5KGuMpUmchqUYcSRc4ojJeQMG323OUmV++ex6eMH+IgBVj6dSFfYLahNkXZod
uAxDfplh0SQWSMDP+k8eHZsjpBqlEHFaK3x7Rb/IVaGHQlyn2TH+taNwe6MfD/Ps
za5WTkaUNCv13Ohkiy6oq+ZVJTB+PWyULH6bN8PkjXjetAJgghQSa+ST2NGLjghs
KqJqZhTtk7Y59ypAXsnVQzm0Lz0wc+HqXbMRj9IBs4rHgJdDTizD9hiItSnJ3Sq9
36/Lbhlc84E=
-----END CERTIFICATE-----
Loaded 100 of 726 files, more files were not shown because too many files have changed in this diff. Show more