Merge pull request 'v1.0.56' (#68 ) from dev into master

Reviewed-on: #68
v1.0.56
2026-09-25 15:43:52 +00:00 · 2026-09-25 23:43:25 +08:00 · 2026-09-25 22:07:42 +08:00 · 2026-09-25 22:07:31 +08:00 · 2026-09-23 15:17:56 +00:00 · 2026-09-23 23:15:19 +08:00
258 changed files with 11635 additions and 2504 deletions
@@ -4,6 +4,7 @@
 /target
 /temp
 /AGENTS.md
 /.workbuddy
 multilingualField/
 !.mvn/wrapper/maven-wrapper.jar
@@ -1,163 +0,0 @@
 # HTTP 调试与文档规范
 本目录下的 `.http` 文件同时承担接口调试和接口文档职责，也要保证 AIAgent 能稳定读取
 ## 目录分工
 ### `.http`
 `.http` 只描述接口级信息：
 1. 接口中文名
 2. 权限要求
 3. 前置条件
 4. 请求参数对应的对象说明
 5. 返回参数对应的对象说明
 `.http` 不重复展开对象字段明细，复杂字段、嵌套结构、枚举值统一写到 `./object` 下
 ### `./object`
 `./object` 只描述对象级信息：
 1. 字段名
 2. 字段类型
 3. 字段说明
 4. 枚举值及含义
 所有模块都可能复用的通用对象必须写在 `./object/common.md`
 按业务领域拆分对象说明文件，例如：
 1. `./object/common.md`
 2. `./object/user.md`
 3. `./object/role.md`
 4. `./object/permission.md`
 不要把同一个对象的字段说明散落到多个文件里
 ## 全局约定
 ### 返回包装
 除使用 `IgnoreGlobalReturn` 跳过全局包装的方法外，接口默认都会经过
 [GlobalReturnHandler](E:/IDEAProject/timi-spring/src/main/java/com/imyeyu/spring/util/GlobalReturnHandler.java)
 统一包装返回
 因此 `.http` 里的 `返回参数` 默认只描述业务 `data` 对象，不再重复赘述全局包装结构
 全局返回包装、通用成功码、错误信息、常见分页壳子等内容统一维护在 `./object/common.md`
 如果接口使用
 [IgnoreGlobalReturn](E:/IDEAProject/timi-spring/src/main/java/com/imyeyu/spring/annotation/IgnoreGlobalReturn.java)
 跳过全局包装，必须在对应接口的 `前置条件` 或补充说明里明确写出“该接口不走全局返回包装”
 ### 文档真实性
 1. 文档只记录服务端真实行为
 2. 不写猜测
 3. 不写“看代码”
 4. 接口改了就同步更新 `.http` 和 `./object`
 ### 变量复用
 能复用的变量统一放在文件顶部，例如 `@user_token`、`@userId`
 ## `.http` 模板
 每个接口块固定使用下面格式，不要擅自增删字段名：
 ```http
 ### <接口中文名>
 ### 权限：
 ### 前置条件：
 ### 请求参数：
 ### 返回参数：
 POST {{baseUrl}}/path
 Content-Type: application/json
 Token: {{user_token}}
 {}
 ```
 ## `.http` 填写要求
 ### 接口中文名
 直接写接口用途，别写成控制器方法名
 ### 权限
 1. 优先直接翻译控制器上的真实注解
 2. 同时存在角色和权限时一起写，例如 `需要 ADMIN 角色 + USER_UPDATE 权限`
 3. 只有 Token 要求时写 `需要有效 Token`
 4. 无需登录时直接写 `无需登录`
 ### 前置条件
 这里只写接口调用前必须知道的约束，例如：
 1. 需要先登录并回填 `user_token`
 2. 需要先创建用户再传入 `userId`
 3. 重复调用可能因为唯一约束失败
 4. 接口当前实现为空
 5. 该接口不走全局返回包装
 没有额外限制时写 `无`
 ### 请求参数
 只写请求对象名和对象说明文件，不在 `.http` 内展开字段
 推荐格式：
 1. `无`
 2. `UserCreateRequest，详见 ./object/user.md`
 3. `Page<UserQuery>，详见 ./object/common.md 和 ./object/user.md`
 ### 返回参数
 只写业务返回对象名和对象说明文件，不在 `.http` 内展开字段
 推荐格式：
 1. `无`
 2. `User，详见 ./object/user.md`
 3. `PageResult<User>，详见 ./object/common.md 和 ./object/user.md`
 4. `二进制数据流，该接口不走全局返回包装`
 ## `./object` 编写要求
 对象说明统一使用 Markdown 表格，推荐结构如下
 ```md
 ## User
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | name | String | 登录名，系统内唯一 |
 ## RoleCode
 | 枚举 | 说明 |
 |---|---|
 | SYSTEM | 系统 |
 | ADMIN | 管理员 |
 ```
 ### 对象说明规则
 1. 一个对象一个标题，标题名必须和 `.http` 里引用的对象名一致
 2. 字段说明只写真实存在且调用方需要关心的内容
 3. 枚举单独列出，不要把枚举值混进普通字段表
 4. 嵌套对象、列表元素对象也要有独立标题
 5. 通用壳子对象统一写在 `./object/common.md`
 ## 维护要求
 1. 一个控制器通常对应一个 `.http` 文件
 2. 新增接口时，同步补齐对应 `.http`
 3. 新增或修改对象字段时，同步更新对应 `./object/*.md`
 4. 注释语言统一用中文
 5. 示例请求优先保证可调试，其次才是看起来完整
@@ -1,200 +0,0 @@
 ### AttachmentController 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@attachmentId =
@attachmentBizType = TEMP_FILE
@attachmentBizId = demo-biz-id
@attachmentAttachType = SOURCE
@attachmentName = demo.png
@attachmentFilePath = E:/Temp/demo.png
@attachmentTempFileId =
 ### 查询附件详情
 ### 前置条件：`id` 必须传有效附件 ID
 ### 请求参数：URL 参数 `id` 为附件 ID
 ### 返回参数：Attachment，详见 ./object/common.md
 POST {{baseUrl}}/attach/detail?id={{attachmentId}}
 Token: {{user_token}}
 ### 创建附件
 ### 前置条件：回填 `attachmentFilePath` 为本地文件绝对路径
 ### 请求参数：multipart/form-data
 ### 返回参数：Attachment，详见 ./object/common.md
 POST {{baseUrl}}/attach/create
 Content-Type: multipart/form-data; boundary=AttachmentCreateBoundary
 Token: {{user_token}}
 --AttachmentCreateBoundary
 Content-Disposition: form-data; name="bizType"
 {{attachmentBizType}}
 --AttachmentCreateBoundary
 Content-Disposition: form-data; name="bizId"
 {{attachmentBizId}}
 --AttachmentCreateBoundary
 Content-Disposition: form-data; name="attachType"
 {{attachmentAttachType}}
 --AttachmentCreateBoundary
 Content-Disposition: form-data; name="name"
 {{attachmentName}}
 --AttachmentCreateBoundary
 Content-Disposition: form-data; name="file"; filename="demo.png"
 Content-Type: application/octet-stream
 < {{attachmentFilePath}}
 --AttachmentCreateBoundary--
 ### 更新附件元数据
 ### 前置条件：`id` 必须传有效附件 ID
 ### 请求参数：multipart/form-data
 ### 返回参数：无
 POST {{baseUrl}}/attach/update
 Content-Type: multipart/form-data; boundary=AttachmentUpdateMetaBoundary
 Token: {{user_token}}
 --AttachmentUpdateMetaBoundary
 Content-Disposition: form-data; name="id"
 {{attachmentId}}
 --AttachmentUpdateMetaBoundary
 Content-Disposition: form-data; name="name"
 {{attachmentName}}-updated
 --AttachmentUpdateMetaBoundary
 Content-Disposition: form-data; name="attachType"
 {{attachmentAttachType}}
 --AttachmentUpdateMetaBoundary--
 ### 更新附件文件
 ### 前置条件：`id` 必须传有效附件 ID，`attachmentFilePath` 必须传本地文件绝对路径
 ### 请求参数：multipart/form-data
 ### 返回参数：无
 POST {{baseUrl}}/attach/update
 Content-Type: multipart/form-data; boundary=AttachmentUpdateFileBoundary
 Token: {{user_token}}
 --AttachmentUpdateFileBoundary
 Content-Disposition: form-data; name="id"
 {{attachmentId}}
 --AttachmentUpdateFileBoundary
 Content-Disposition: form-data; name="name"
 {{attachmentName}}-file-updated
 --AttachmentUpdateFileBoundary
 Content-Disposition: form-data; name="file"; filename="demo.png"
 Content-Type: application/octet-stream
 < {{attachmentFilePath}}
 --AttachmentUpdateFileBoundary--
 ### 删除附件
 ### 前置条件：`id` 必须传有效附件 ID
 ### 请求参数：URL 参数 `id` 为附件 ID
 ### 返回参数：无
 POST {{baseUrl}}/attach/delete?id={{attachmentId}}
 Token: {{user_token}}
 ### 按业务查询单个附件
 ### 前置条件：`bizType` 和 `bizId` 必须传有效值
 ### 请求参数：URL 参数 `bizType`、`bizId`
 ### 返回参数：Attachment，详见 ./object/common.md
 GET {{baseUrl}}/attach/detail/byBiz?bizType={{attachmentBizType}}&bizId={{attachmentBizId}}
 Token: {{user_token}}
 ### 按业务和附件类型查询单个附件
 ### 前置条件：`bizType`、`bizId`、`attachType` 必须传有效值
 ### 请求参数：URL 参数 `bizType`、`bizId`、`attachType`
 ### 返回参数：Attachment，详见 ./object/common.md
 GET {{baseUrl}}/attach/detail/byAttachType?bizType={{attachmentBizType}}&bizId={{attachmentBizId}}&attachType={{attachmentAttachType}}
 Token: {{user_token}}
 ### 按业务查询附件列表
 ### 前置条件：`bizType` 和 `bizId` 必须传有效值
 ### 请求参数：URL 参数 `bizType`、`bizId`，可重复传 `attachTypeList`
 ### 返回参数：Attachment[]
 GET {{baseUrl}}/attach/list/byBiz?bizType={{attachmentBizType}}&bizId={{attachmentBizId}}&attachTypeList={{attachmentAttachType}}
 Token: {{user_token}}
 ### 按业务统计附件数量
 ### 前置条件：`bizType` 和 `bizId` 必须传有效值
 ### 请求参数：URL 参数 `bizType`、`bizId`，可重复传 `attachTypeList`
 ### 返回参数：number
 GET {{baseUrl}}/attach/count/byBiz?bizType={{attachmentBizType}}&bizId={{attachmentBizId}}&attachTypeList={{attachmentAttachType}}
 Token: {{user_token}}
 ### 按业务分页查询附件
 ### 前置条件：`bizType` 和 `bizId` 必须传有效值
 ### 请求参数：URL 参数 `bizType`、`bizId`，可重复传 `attachTypeList`，请求体为 Page
 ### 返回参数：PageResult<Attachment>
 POST {{baseUrl}}/attach/page/byBiz?bizType={{attachmentBizType}}&bizId={{attachmentBizId}}&attachTypeList={{attachmentAttachType}}
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 10
 }
 ### 按业务差分更新附件
 ### 前置条件：新增项需要传有效 `tempFileId`
 ### 请求参数：BizUpdateReq
 ### 返回参数：无
 POST {{baseUrl}}/attach/update/byBiz
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"bizType": "{{attachmentBizType}}",
 	"bizId": "{{attachmentBizId}}",
 	"items": [
 		{
 			"id": "{{attachmentId}}",
 			"attachType": "{{attachmentAttachType}}",
 			"name": "{{attachmentName}}-biz-updated"
 		},
 		{
 			"tempFileId": "{{attachmentTempFileId}}",
 			"attachType": "{{attachmentAttachType}}",
 			"name": "{{attachmentName}}-from-temp"
 		}
 	]
 }
 ### 按业务删除全部附件
 ### 前置条件：`bizType` 和 `bizId` 必须传有效值
 ### 请求参数：BizDeleteReq
 ### 返回参数：无
 POST {{baseUrl}}/attach/delete/byBiz
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"bizType": "{{attachmentBizType}}",
 	"bizId": "{{attachmentBizId}}"
 }
 ### 读取附件原图
 ### 前置条件：`attachmentId` 必须传有效附件 ID
 ### 请求参数：路径参数 `id`
 ### 返回参数：附件二进制流
 GET {{baseUrl}}/attach/read/{{attachmentId}}
 Token: {{user_token}}
 ### 读取附件缩略图
 ### 前置条件：`attachmentId` 必须传有效图片或视频附件 ID
 ### 请求参数：路径参数 `id`，URL 参数 `thumbWidth`、`thumbHeight`
 ### 返回参数：附件二进制流
 GET {{baseUrl}}/attach/read/{{attachmentId}}?thumbWidth=200&thumbHeight=200
 Token: {{user_token}}
 ### 下载附件
 ### 前置条件：`attachmentId` 必须传有效附件 ID
 ### 请求参数：路径参数 `id`
 ### 返回参数：附件二进制流
 GET {{baseUrl}}/attach/download/{{attachmentId}}
 Token: {{user_token}}
@@ -1,66 +0,0 @@
 ### MultilingualController 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@multilingualId =
@multilingualZhCN = 测试简体中文
@multilingualZhTW = 測試繁體中文
@multilingualEnUS = Test English
@multilingualRuRU = Тест
@multilingualJaJP = テスト
@multilingualDeDE = Test Deutsch
@multilingualKoKR = 테스트
 ### 查询多语言详情
 ### 权限：需要 ADMIN 角色 +  MULTILINGUAL_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效多语言 ID
 ### 请求参数：无请求体，URL 参数：`id` 为多语言 ID
 ### 返回参数：Multilingual，详见 ./object/common.md
 POST {{baseUrl}}/system/multilingual/detail?id={{multilingualId}}
 Token: {{user_token}}
 ### 创建多语言
 ### 权限：需要 ADMIN 角色 +  MULTILINGUAL_CREATE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Multilingual，详见 ./object/common.md
 ### 返回参数：Multilingual，详见 ./object/common.md
 POST {{baseUrl}}/system/multilingual/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"zhCN": "{{multilingualZhCN}}",
 	"zhTW": "{{multilingualZhTW}}",
 	"enUS": "{{multilingualEnUS}}",
 	"ruRU": "{{multilingualRuRU}}",
 	"jaJP": "{{multilingualJaJP}}",
 	"deDE": "{{multilingualDeDE}}",
 	"koKR": "{{multilingualKoKR}}"
 }
 ### 更新多语言
 ### 权限：需要 ADMIN 角色 +  MULTILINGUAL_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`，`id` 必须存在
 ### 请求参数：Multilingual，详见 ./object/common.md
 ### 返回参数：无
 POST {{baseUrl}}/system/multilingual/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{multilingualId}}",
 	"zhCN": "{{multilingualZhCN}}-已更新",
 	"zhTW": "{{multilingualZhTW}}-已更新",
 	"enUS": "{{multilingualEnUS}}-updated",
 	"ruRU": "{{multilingualRuRU}}-updated",
 	"jaJP": "{{multilingualJaJP}}-updated",
 	"deDE": "{{multilingualDeDE}}-updated",
 	"koKR": "{{multilingualKoKR}}-updated"
 }
 ### 删除多语言
 ### 权限：需要 ADMIN 角色 +  MULTILINGUAL_DELETE 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效多语言 ID
 ### 请求参数：无请求体，URL 参数：`id` 为多语言 ID
 ### 返回参数：无
 POST {{baseUrl}}/system/multilingual/delete?id={{multilingualId}}
 Token: {{user_token}}
@@ -1,60 +0,0 @@
 ### GaoRegisterAction 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@actionId =
 ### 分页查询登记行为
 POST {{baseUrl}}/gao/action/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 16
 }
 ### 查询启用行为
 POST {{baseUrl}}/gao/action/enabled/list
 Token: {{user_token}}
 ### 查询行为详情
 POST {{baseUrl}}/gao/action/detail?id={{actionId}}
 Token: {{user_token}}
 ### 创建登记行为
 POST {{baseUrl}}/gao/action/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"name": "签到",
 	"description": "客户到店签到",
 	"enabled": true,
 	"requirePhoto": false,
 	"sort": 10,
 	"permissionCodeList": [
 		"RECORD:CREATE"
 	]
 }
 ### 更新登记行为
 POST {{baseUrl}}/gao/action/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{actionId}}",
 	"name": "物品领取",
 	"description": "登记客户领取物品",
 	"enabled": true,
 	"requirePhoto": true,
 	"sort": 20,
 	"permissionCodeList": [
 		"RECORD:CREATE",
 		"STAT:READ"
 	]
 }
 ### 删除登记行为
 POST {{baseUrl}}/gao/action/delete?id={{actionId}}
 Token: {{user_token}}
@@ -1,119 +0,0 @@
 ### GaoCustomer 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@customerId =
@introducerCustomerId =
@customerCode = GAO-0001
 ### 分页查询客户
 POST {{baseUrl}}/gao/customer/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 16
 }
 ### 搜索客户
 POST {{baseUrl}}/gao/customer/search
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"keyword": "张",
 	"introducerCustomerId": "{{introducerCustomerId}}"
 }
 ### 查询客户详情
 POST {{baseUrl}}/gao/customer/detail?id={{customerId}}
 Token: {{user_token}}
 ### 按客户编码查询
 POST {{baseUrl}}/gao/customer/detail/code?code={{customerCode}}
 Token: {{user_token}}
 ### 查询某客户邀请了哪些人
 POST {{baseUrl}}/gao/customer/invited/list?introducerCustomerId={{customerId}}
 Token: {{user_token}}
 ### 创建客户
 POST {{baseUrl}}/gao/customer/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"code": "{{customerCode}}",
 	"name": "张三",
 	"age": 56,
 	"telephone": "020-88886666",
 	"address": "广州市天河区某街道",
 	"remark": "首诊客户",
 	"disease": "肩颈不适",
 	"conditioningPart": [
 		{
 			"code": "neck",
 			"name": "颈部"
 		},
 		{
 			"code": "shoulder",
 			"name": "肩部"
 		}
 	],
 	"introducerCustomerId": "{{introducerCustomerId}}"
 }
 ### 更新客户
 POST {{baseUrl}}/gao/customer/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{customerId}}",
 	"code": "{{customerCode}}",
 	"name": "张三",
 	"age": 57,
 	"telephone": "020-88886667",
 	"address": "广州市天河区某街道 88 号",
 	"remark": "复诊客户",
 	"disease": "腰背调理",
 	"conditioningPart": {
 		"parts": [
 			"waist",
 			"back"
 		]
 	},
 	"introducerCustomerId": "{{introducerCustomerId}}"
 }
 ### 删除客户
 POST {{baseUrl}}/gao/customer/delete?id={{customerId}}
 Token: {{user_token}}
 ### 创建客户邀请关系
 POST {{baseUrl}}/gao/customer/invite/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"customerId": "{{customerId}}",
 	"introducerCustomerId": "{{introducerCustomerId}}"
 }
 ### 查询客户邀请关系详情
 POST {{baseUrl}}/gao/customer/invite/detail?customerId={{customerId}}
 Token: {{user_token}}
 ### 更新客户邀请关系
 POST {{baseUrl}}/gao/customer/invite/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"customerId": "{{customerId}}",
 	"introducerCustomerId": "{{introducerCustomerId}}"
 }
 ### 删除客户邀请关系
 POST {{baseUrl}}/gao/customer/invite/delete?customerId={{customerId}}
 Token: {{user_token}}
@@ -1,86 +0,0 @@
 ### GaoRegisterRecord 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@recordId =
@customerId =
@customerCode = GAO-0001
@actionId =
 ### 分页查询登记记录
 POST {{baseUrl}}/gao/record/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 16
 }
 ### 查询登记记录详情
 POST {{baseUrl}}/gao/record/detail?id={{recordId}}
 Token: {{user_token}}
 ### 创建登记记录，直接传客户 ID
 POST {{baseUrl}}/gao/record/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"customerId": "{{customerId}}",
 	"actionId": "{{actionId}}",
 	"remark": "客户到店签到"
 }
 ### 创建登记记录，扫码后传客户编码
 POST {{baseUrl}}/gao/record/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"customerCode": "{{customerCode}}",
 	"actionId": "{{actionId}}",
 	"remark": "扫码快速登记"
 }
 ### 更新登记记录
 POST {{baseUrl}}/gao/record/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{recordId}}",
 	"customerId": "{{customerId}}",
 	"actionId": "{{actionId}}",
 	"remark": "补充备注",
 	"registeredAt": 1785110400
 }
 ### 删除登记记录
 POST {{baseUrl}}/gao/record/delete?id={{recordId}}
 Token: {{user_token}}
 ### 按日查询某个行为记录
 POST {{baseUrl}}/gao/record/period/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"actionId": "{{actionId}}",
 	"periodType": "DAY",
 	"periodValue": 20260727
 }
 ### 按月统计某个行为记录
 POST {{baseUrl}}/gao/record/period/stat
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"actionId": "{{actionId}}",
 	"periodType": "MONTH",
 	"periodValue": 202607
 }
 ### 查询客户所有登记统计
 POST {{baseUrl}}/gao/record/customer/stat?customerId={{customerId}}
 Token: {{user_token}}
@@ -1,8 +0,0 @@
 {
 	"dev": {
 		"baseUrl": "http://localhost:8091"
 	},
 	"prod": {
 		"baseUrl": "https://api.example.com"
 	}
 }
@@ -1,77 +0,0 @@
 # 通用对象说明
 ## TimiResponse<T>
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | code | Integer | 响应码，`20000` 为成功 |
 | msg | String | 响应消息 |
 | data | T | 业务数据体，具体结构由接口返回对象决定 |
 ## Page<T>
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | index | int | 页码下标，从 `0` 开始 |
 | size | long | 每页数量 |
 | equalsExample | T | 精确匹配示例对象，非空字段参与精确查询 |
 | likesExample | T | 模糊匹配示例对象，非空字段参与模糊查询 |
 | equalsLogic | Logic | 精确匹配字段之间的连接逻辑，默认 `AND` |
 | likesLogic | Logic | 模糊匹配字段之间的连接逻辑，默认 `OR` |
 | orderMap | LinkedHashMap<String, OrderType> | 排序字段映射，键通常为字段名，值为排序方向 |
 ## PageResult<T>
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | total | long | 总数据量 |
 | pages | int | 总页数 |
 | list | List<T> | 当前页数据列表 |
 ## UUIDEntity
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | id | String | 主键 ID，UUID 字符串 |
 | createdAt | Long | 创建时间，Unix 时间戳毫秒 |
 | updatedAt | Long | 更新时间，Unix 时间戳毫秒 |
 | deletedAt | Long | 删除时间，Unix 时间戳毫秒，未删除时通常为空 |
 ## Multilingual
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | id | String | 多语言 ID |
 | zhCN | String | 简体中文文本 |
 | zhTW | String | 繁体中文文本 |
 | enUS | String | 英文文本 |
 | ruRU | String | 俄文文本 |
 | jaJP | String | 日文文本 |
 | deDE | String | 德文文本 |
 | koKR | String | 韩文文本 |
 | lastAccessAt | Long | 最后访问时间，Unix 时间戳毫秒 |
 | createdAt | Long | 创建时间，Unix 时间戳毫秒 |
 | updatedAt | Long | 更新时间，Unix 时间戳毫秒 |
 | deletedAt | Long | 删除时间，Unix 时间戳毫秒，未删除时通常为空 |
 ## Logic
 | 枚举 | 说明 |
 |---|---|
 | AND | 多个条件同时满足 |
 | OR | 多个条件满足其一 |
 ## OrderType
 | 枚举 | 说明 |
 |---|---|
 | ASC | 升序 |
 | DESC | 降序 |
 ## ImageType
 | 枚举 | 说明 |
 |---|---|
 | AUTO | 双线性 |
 | SMOOTH | 模糊 |
 | PIXELATED | 像素 |
@@ -1,31 +0,0 @@
 # 权限对象说明
 ## Permission
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | id | String | 权限 ID |
 | createdAt | Long | 创建时间，Unix 时间戳毫秒 |
 | updatedAt | Long | 更新时间，Unix 时间戳毫秒 |
 | deletedAt | Long | 删除时间，Unix 时间戳毫秒 |
 | code | String | 权限代码，需与数据库 `permission.code` 保持一致 |
 | nameLangId | String | 权限名称的多语言键 |
 | description | String | 权限说明 |
 | name | String | 当前语言下的权限名称 |
 ## BatchCreateReq
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | prefixCode | String | 权限代码前缀，例如 `ROLE` |
 | prefixName | String | 权限名称前缀，例如 `角色` |
 | types | Type[] | 需要批量生成的权限类型列表，详见 `BatchCreateType` |
 ## BatchCreateType
 | 枚举 | 说明 |
 |---|---|
 | CREATE | 创建权限 |
 | READ | 读取权限 |
 | UPDATE | 更新权限 |
 | DELETE | 删除权限 |
@@ -1,34 +0,0 @@
 # 角色对象说明
 ## Role
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | id | String | 角色 ID |
 | createdAt | Long | 创建时间，Unix 时间戳毫秒 |
 | updatedAt | Long | 更新时间，Unix 时间戳毫秒 |
 | deletedAt | Long | 删除时间，Unix 时间戳毫秒 |
 | code | String | 角色代码，常见值见 `RoleCode` |
 | nameLangId | String | 角色名称的多语言键 |
 | description | String | 角色说明 |
 | name | String | 当前语言下的角色名称 |
 | permissionList | List<Permission> | 角色自身直接绑定的权限列表 |
 | allPermissionList | List<Permission> | 角色全部权限列表，包含继承自子角色的权限 |
 | childRoleList | List<Role> | 子角色列表 |
 | permissionIdList | Set<String> | 权限 ID 列表，创建或更新角色时使用 |
 | childRoleIdList | Set<String> | 子角色 ID 列表，创建或更新角色时使用 |
 ## UserRoleAuthorizeReq
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | userId | String | 目标用户 ID |
 | roleIdList | List<String> | 需要授权的角色 ID 列表 |
 | roleCodeList | List<String> | 需要授权的角色代码列表 |
 ## RoleCode
 | 枚举 | 说明 |
 |---|---|
 | SYSTEM | 系统 |
 | ADMIN | 管理员 |
@@ -1,73 +0,0 @@
 # 用户对象说明
 ## User
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | id | String | 用户 ID |
 | createdAt | Long | 创建时间，Unix 时间戳毫秒 |
 | updatedAt | Long | 更新时间，Unix 时间戳毫秒 |
 | deletedAt | Long | 删除时间，Unix 时间戳毫秒 |
 | name | String | 登录名，系统内唯一 |
 | nick | String | 用户昵称 |
 | password | String | 明文密码，请求时填写，响应通常不返回 |
 | email | String | 邮箱地址 |
 | emailVerifyAt | Long | 邮箱验证时间，Unix 时间戳毫秒 |
 | phoneNo | String | 手机号，11 位大陆手机号 |
 | phoneNoVerifyAt | Long | 手机号验证时间，Unix 时间戳毫秒 |
 | wrapperType | ImageType | 背景图渲染算法，详见 `ImageType` |
 | avatarType | ImageType | 头像渲染算法，详见 `ImageType` |
 | exp | Integer | 经验值 |
 | sex | Integer | 性别，当前代码未定义枚举说明 |
 | birthdate | Long | 出生日期，Unix 时间戳毫秒 |
 | qq | String | QQ 号 |
 | description | String | 个人说明 |
 | lastLoginIP | String | 上次登录 IP |
 | lastLoginAt | Long | 上次登录时间，Unix 时间戳毫秒 |
 | unmuteAt | Long | 解除禁言时间，Unix 时间戳毫秒 |
 | unbanAt | Long | 解除封禁时间，Unix 时间戳毫秒 |
 | roleList | List<String> | 角色代码列表 |
 | permissionList | List<String> | 权限代码列表 |
 | attachmentList | List<Attachment> | 附件列表 |
 | settingList | List<Setting> | 设置列表 |
 ## LoginRequest
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | user | String | 用户标识，可能是 UID、邮箱或用户名 |
 | password | String | 明文密码 |
 ## LoginResponse
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | token | String | 登录令牌 |
 | expireAt | Long | 令牌过期时间，Unix 时间戳毫秒 |
 | user | User | 当前登录用户 |
 ## UpdatePasswordRequest
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | oldValue | String | 原密码 |
 | newValue | String | 新密码 |
 ## PhoneVerifyCodeSendRequest
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | phoneNo | String | 手机号，必须为 11 位大陆手机号 |
 ## PhoneVerifyRequest
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | phoneNo | String | 手机号，必须为 11 位大陆手机号 |
 | verifyCode | String | 6 位数字验证码 |
 ## CancelRequest
 | 字段 | 类型 | 说明 |
 |---|---|---|
 | password | String | 当前密码，用于确认注销 |
@@ -1,84 +0,0 @@
 ### PermissionController 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@user_token =
@permissionId =
@permissionCode = TEST_PERMISSION
@permissionNameLangId = permission.test.name
@permissionDescription = 测试权限
@moduleCode = CORE
 ### 分页查询权限
 ### 权限：需要 PERMISSION_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Page<Permission>，详见 ./http/object/permission.md
 ### 返回参数：PageResult<Permission>，详见 ./http/object/permission.md
 POST {{baseUrl}}/user/permission/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 10,
 	"likesExample": {
 		"code": "{{permissionCode}}",
 		"moduleCode": "{{moduleCode}}"
 	}
 }
 ### 创建权限
 ### 权限：当前代码要求 PERMISSION_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Permission，详见 ./http/object/permission.md
 ### 返回参数：无
 POST {{baseUrl}}/user/permission/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"moduleCode": "{{moduleCode}}",
 	"code": "{{permissionCode}}",
 	"nameLangId": "{{permissionNameLangId}}",
 	"description": "{{permissionDescription}}"
 }
 ### 批量创建权限
 ### 权限：需要 PERMISSION_CREATE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：BatchCreateReq，详见 ./http/object/permission.md
 ### 返回参数：无
 POST {{baseUrl}}/user/permission/create/batch
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"moduleCode": "{{moduleCode}}",
 	"prefixCode": "ROLE",
 	"prefixName": "角色",
 	"types": ["CREATE", "READ", "UPDATE", "DELETE"]
 }
 ### 更新权限
 ### 权限：需要 PERMISSION_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`，`id` 必须存在
 ### 请求参数：Permission，详见 ./http/object/permission.md
 ### 返回参数：无
 POST {{baseUrl}}/user/permission/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{permissionId}}",
 	"moduleCode": "{{moduleCode}}",
 	"code": "{{permissionCode}}",
 	"nameLangId": "{{permissionNameLangId}}",
 	"description": "测试权限-已更新"
 }
 ### 删除权限
 ### 权限：需要 PERMISSION_DELETE 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效权限 ID
 ### 请求参数：无请求体，URL 参数：`id` 为权限 ID
 ### 返回参数：无
 POST {{baseUrl}}/user/permission/delete?id={{permissionId}}
 Token: {{user_token}}
@@ -1,113 +0,0 @@
 ### RoleController 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@permissionId =
@roleId =
@roleCode = TEST_ROLE
@roleNameLangId = role.test.name
@roleDescription = 测试角色
@childRoleId =
@authorizedUserId =
@moduleCode = CORE
 ### 分页查询角色
 ### 权限：需要 ADMIN 角色 +  ROLE_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Page<Role>，详见 ./http/object/role.md
 ### 返回参数：PageResult<Role>，详见 ./http/object/role.md
 POST {{baseUrl}}/user/role/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 16,
 	"likesExample": {
 		"moduleCode": "{{moduleCode}}"
 	}
 }
 ### 查询角色详情
 ### 权限：需要 ADMIN 角色 +  ROLE_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效角色 ID
 ### 请求参数：无请求体，URL 参数：`id` 为角色 ID
 ### 返回参数：Role，详见 ./http/object/role.md
 POST {{baseUrl}}/user/role/detail?id={{roleId}}
 Token: {{user_token}}
 ### 创建角色
 ### 权限：需要 ADMIN 角色 +  ROLE_CREATE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Role，详见 ./http/object/role.md
 ### 返回参数：无
 POST {{baseUrl}}/user/role/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"moduleCode": "{{moduleCode}}",
 	"code": "{{roleCode}}",
 	"nameLangId": "{{roleNameLangId}}",
 	"description": "{{roleDescription}}",
 	"permissionIdList": ["{{permissionId}}"],
 	"childRoleIdList": []
 }
 ### 更新角色
 ### 权限：需要 ADMIN 角色 +  ROLE_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`，`id` 必须存在
 ### 请求参数：Role，详见 ./http/object/role.md
 ### 返回参数：无
 POST {{baseUrl}}/user/role/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{roleId}}",
 	"moduleCode": "{{moduleCode}}",
 	"code": "{{roleCode}}",
 	"nameLangId": "{{roleNameLangId}}",
 	"description": "测试角色-已更新",
 	"permissionIdList": ["{{permissionId}}"],
 	"childRoleIdList": ["{{childRoleId}}"]
 }
 ### 删除角色
 ### 权限：需要 ADMIN 角色 +  ROLE_DELETE 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效角色 ID
 ### 请求参数：无请求体，URL 参数：`id` 为角色 ID
 ### 返回参数：无
 POST {{baseUrl}}/user/role/delete?id={{roleId}}
 Token: {{user_token}}
 ### 查询用户角色
 ### 权限：需要 ADMIN 角色 +  USER_ROLE_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `userId` 必须传有效用户 ID
 ### 请求参数：无请求体，URL 参数：`userId` 为用户 ID
 ### 返回参数：List<Role>，详见 ./http/object/role.md
 POST {{baseUrl}}/user/role/authorized/list?userId={{authorizedUserId}}
 Token: {{user_token}}
 ### 设置用户角色
 ### 权限：需要 ADMIN 角色 + 同时具备 USER_ROLE_CREATE 和 USER_ROLE_DELETE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：UserRoleAuthorizeReq，详见 ./http/object/role.md
 ### 返回参数：无
 POST {{baseUrl}}/user/role/authorized/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"userId": "{{authorizedUserId}}",
 	"moduleCode": "{{moduleCode}}",
 	"roleIdList": ["{{roleId}}"],
 	"roleCodeList": ["{{roleCode}}"]
 }
 ### 查询用户已授权权限
 ### 权限：需要 ADMIN 角色 +  USER_ROLE_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `userId` 必须传有效用户 ID
 ### 请求参数：无请求体，URL 参数：`userId` 为用户 ID
 ### 返回参数：List<Permission>，详见 ./http/object/permission.md
 POST {{baseUrl}}/user/role/authorized/permission?userId={{authorizedUserId}}
 Token: {{user_token}}
@@ -1,186 +0,0 @@
 ### UserController 接口测试
 ### 在 IDEA 中选择 dev 或 prod 环境后执行
@userId =
@name = System
@password = u#HA027xq$i9]P}uB]LweJspTb!3oS^.
@newPassword = qwe123
@nick = 测试用户
@email = test@example.com
 ### 分页查询用户
 ### 权限：需要 ADMIN 角色 + USER_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：Page<User>，详见 ./http/object/user.md
 ### 返回参数：PageResult<User>，详见 ./http/object/user.md
 POST {{baseUrl}}/user/list
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"index": 0,
 	"size": 16
 }
 ### 查询用户详情
 ### 权限：需要 ADMIN 角色 + USER_READ 权限
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效用户 ID
 ### 请求参数：无请求体，URL 参数：`id` 为用户 ID
 ### 返回参数：User，详见 ./http/object/user.md
 POST {{baseUrl}}/user/detail?id={{userId}}
 Token: {{user_token}}
 ### 创建用户
 ### 权限：需要 ADMIN 角色 + USER_CREATE 权限
 ### 前置条件：需要先登录并回填 `user_token`，重复用户名通常会失败
 ### 请求参数：User，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/create
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"name": "{{name}}",
 	"nick": "{{nick}}",
 	"email": "{{email}}",
 	"phoneNo": "13800138000",
 	"password": "{{password}}"
 }
 ### 更新用户
 ### 权限：需要 ADMIN 角色 + USER_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`，`id` 必须存在
 ### 请求参数：User，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/update
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"id": "{{userId}}",
 	"name": "{{name}}",
 	"nick": "{{nick}}",
 	"email": "{{email}}",
 	"phoneNo": "13800138000"
 }
 ### 删除用户
 ### 权限：需要 ADMIN 角色
 ### 前置条件：需要先登录并回填 `user_token`，URL 参数 `id` 必须传有效用户 ID
 ### 请求参数：无请求体，URL 参数：`id` 为用户 ID
 ### 返回参数：无
 POST {{baseUrl}}/user/delete?id={{userId}}
 Token: {{user_token}}
 ### 注册
 ### 权限：无需登录
 ### 前置条件：重复用户名通常会失败
 ### 请求参数：User，详见 ./http/object/user.md
 ### 返回参数：LoginResponse，详见 ./http/object/user.md
 POST {{baseUrl}}/user/register
 Content-Type: application/json
 {
 	"name": "Test",
 	"nick": "测试用户",
 	"phoneNo": "13800138000",
 	"password": "qwe123"
 }
 ### 登录
 ### 权限：无需登录
 ### 前置条件：成功后需要把响应中的 token 回填到 `user_token`
 ### 请求参数：LoginRequest，详见 ./http/object/user.md
 ### 返回参数：LoginResponse，详见 ./http/object/user.md
 POST {{baseUrl}}/user/login
 Content-Type: application/json
 {
 	"user": "{{name}}",
 	"password": "{{password}}"
 }
 > {%
 client.global.set("user_token", response.body?.data?.token)
 %}
 ### 令牌登录
 ### 权限：需要有效 Token
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：无
 ### 返回参数：LoginResponse，详见 ./http/object/user.md
 GET {{baseUrl}}/user/login/token
 Token: {{user_token}}
 ### 登出
 ### 权限：当前控制器未声明 RequiredToken/权限注解，按服务端实际会话处理
 ### 前置条件：当前接口通常用于退出当前登录态
 ### 请求参数：无
 ### 返回参数：无
 POST {{baseUrl}}/user/logout
 Token: {{user_token}}
 ### 修改当前用户密码
 ### 权限：需要 USER_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：UpdatePasswordRequest，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/update/password
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"oldValue": "{{password}}",
 	"newValue": "{{newPassword}}"
 }
 ### 修改当前用户邮箱
 ### 权限：需要 USER_UPDATE 权限
 ### 前置条件：当前方法体为空，接口尚未实现
 ### 请求参数：无
 ### 返回参数：无
 POST {{baseUrl}}/user/update/email
 Content-Type: application/json
 Token: {{user_token}}
 {}
 ### 发送当前用户手机号验证码
 ### 权限：需要 USER_UPDATE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：PhoneVerifyCodeSendRequest，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/phone/verify/send
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"phoneNo": "13800138000"
 }
 ### 验证当前用户手机号
 ### 权限：需要 USER_UPDATE 权限
 ### 前置条件：需要先调用手机号验证码发送接口获取验证码
 ### 请求参数：PhoneVerifyRequest，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/phone/verify
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"phoneNo": "13800138000",
 	"verifyCode": "123456"
 }
 ### 注销当前用户
 ### 权限：需要 USER_DELETE 权限
 ### 前置条件：需要先登录并回填 `user_token`
 ### 请求参数：CancelRequest，详见 ./http/object/user.md
 ### 返回参数：无
 POST {{baseUrl}}/user/cancel
 Content-Type: application/json
 Token: {{user_token}}
 {
 	"password": "{{password}}"
 }
@@ -11,7 +11,7 @@
 	<groupId>com.imyeyu.timiserverapi</groupId>
 	<artifactId>TimiServerAPI</artifactId>
-	<version>1.0.33</version>
+	<version>1.0.56</version>
 	<packaging>jar</packaging>
 	<name>TimiServerAPI</name>
 	<description>imyeyu.com API</description>
@@ -188,7 +188,11 @@
 		<dependency>
 			<groupId>com.imyeyu.spring</groupId>
 			<artifactId>timi-spring</artifactId>
-			<version>0.0.19</version>
+			<version>0.0.20</version>
 		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-freemarker</artifactId>
 		</dependency>
 		<dependency>
 			<groupId>com.imyeyu.network</groupId>
@@ -215,6 +219,11 @@
 			<artifactId>tinypinyin</artifactId>
 			<version>2.0.3</version>
 		</dependency>
 		<dependency>
 			<groupId>com.hankcs</groupId>
 			<artifactId>hanlp</artifactId>
 			<version>portable-1.8.4</version>
 		</dependency>
 		<dependency>
 			<groupId>com.imyeyu.font.icon</groupId>
 			<artifactId>timi-icon-font</artifactId>
@@ -1,35 +0,0 @@
 package com.imyeyu.api.annotation;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 /**
 * 启用配置注解
 *
 * @author 夜雨
 * @since 2023-07-15 10:00
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
 public @interface EnableSetting {
 	/**
 	 *
 	 *
 	 * @author 夜雨
 	 * @since 2026-04-27 14:45
 	 */
 	enum Logic {
 		AND,
 		OR
 	}
 	Logic logic() default Logic.AND;
 	/** @return 未启用配置时响应消息语言映射键 */
 	String message() default "service.offline";
 }
@@ -1,55 +0,0 @@
 package com.imyeyu.api.annotation;
 import com.imyeyu.api.modules.common.service.SettingService;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.lang.NonNull;
 import org.springframework.stereotype.Component;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.servlet.HandlerInterceptor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * 启用配置注解处理器
 *
 * @author 夜雨
 * @since 2023-07-15 10:01
 */
@Component
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
 public class EnableSettingInterceptor implements HandlerInterceptor {
 	private final SettingService service;
 	public boolean preHandle(@NonNull HttpServletRequest req, @NonNull HttpServletResponse resp, @NonNull Object handler) throws InvocationTargetException, IllegalAccessException {
 		if (handler instanceof HandlerMethod handlerMethod) {
 			EnableSetting annotation = handlerMethod.getMethodAnnotation(EnableSetting.class);
 			if (annotation == null) {
 				return true;
 			}
 			EnableSetting.Logic logic = annotation.logic();
 			List<Boolean> valueList = new ArrayList<>();
 			for (Method method : annotation.getClass().getMethods()) {
 				if (method.getName().equals("message")) {
 					continue;
 				}
 				Enum<?>[] enums = (Enum<?>[]) method.invoke(annotation);
 				for (Enum<?> anEnum : enums) {
 					valueList.add(service.getSystem(anEnum).isTrue());
 				}
 			}
 			if (logic == EnableSetting.Logic.AND) {
 				return valueList.stream().allMatch(Boolean::booleanValue);
 			} else {
 				return valueList.stream().anyMatch(Boolean::booleanValue);
 			}
 		}
 		return true;
 	}
 }
@@ -0,0 +1,17 @@
 package com.imyeyu.api.annotation;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 ///
 ///
 /// @author 夜雨
 /// @since 2026-09-08 15:22
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
 public @interface SettingBizType {
 	String value();
 }
@@ -45,6 +45,11 @@ public enum CorePermissionCode implements BuiltinPermissionCode {
 	TAG_UPDATE("TAG:UPDATE", "标签修改", false, true),
 	TAG_DELETE("TAG:DELETE", "标签删除", false, true),
 	ARTICLE_CREATE("ARTICLE:CREATE", "文章创建", false, true),
 	ARTICLE_READ("ARTICLE:READ", "文章读取", false, true),
 	ARTICLE_UPDATE("ARTICLE:UPDATE", "文章修改", false, true),
 	ARTICLE_DELETE("ARTICLE:DELETE", "文章删除", false, true),
 	USER_CREATE("USER:CREATE", "用户创建", false, true),
 	USER_READ("USER:READ", "用户读取", false, true),
 	USER_UPDATE("USER:UPDATE", "用户修改", false, true),
@@ -0,0 +1,27 @@
 package com.imyeyu.api.bean;
 import com.imyeyu.api.annotation.SettingBizType;
 import com.imyeyu.api.modules.common.entity.Setting;
 import com.imyeyu.utils.Text;
 ///
 ///
 /// @author 夜雨
 /// @since 2026-09-08 15:18
 public interface SettingEnum {
 	default String getBizType() {
 		Class<? extends SettingEnum> implEnum = getClass();
 		SettingBizType bizType = implEnum.getAnnotation(SettingBizType.class);
 		if (bizType == null) {
 			return Text.bizClassName(implEnum);
 		}
 		return bizType.value();
 	}
 	String name();
 	String getDefaultValue();
 	Setting.ValueType getValueType();
 }
@@ -2,6 +2,7 @@ package com.imyeyu.api.config;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.imyeyu.api.modules.common.entity.Multilingual;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.bean.GaoUserInviteCache;
 import com.imyeyu.spring.bean.RedisConfigParams;
 import com.imyeyu.spring.config.AbstractRedisConfig;
@@ -209,4 +210,10 @@ public class RedisConfig extends AbstractRedisConfig {
 	public Redis<String, GaoUserInviteCache> getGaoUserInviteRedisTemplate() {
 		return getRedis(database, RedisSerializers.STRING, RedisSerializers.jacksonSerializer(jackson, GaoUserInviteCache.class));
 	}
 	/// @return AI 会话，AI 会话 ID: 会话授权内容
 	@Bean("redisGaoAiSession")
 	public Redis<String, GaoAiSession> getGaoAiSessionRedisTemplate() {
 		return getRedis(database, RedisSerializers.STRING, RedisSerializers.jacksonSerializer(jackson, GaoAiSession.class));
 	}
 }
@@ -32,4 +32,22 @@ public class ThreadPoolConfig {
 		executor.initialize();
 		return executor;
 	}
 	/// 创建操作审计线程池
 	///
 	/// @return 操作审计线程池
 	@Bean(name = "auditTaskExecutor")
 	public ThreadPoolTaskExecutor auditTaskExecutor() {
 		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 		executor.setCorePoolSize(4);
 		executor.setMaxPoolSize(8);
 		executor.setQueueCapacity(2000);
 		executor.setKeepAliveSeconds(60);
 		executor.setWaitForTasksToCompleteOnShutdown(true);
 		executor.setAwaitTerminationSeconds(60);
 		executor.setThreadNamePrefix("audit-task-executor-");
 		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 		executor.initialize();
 		return executor;
 	}
 }
@@ -6,7 +6,6 @@ import com.fasterxml.jackson.databind.MapperFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.json.JsonMapper;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import com.imyeyu.api.annotation.EnableSettingInterceptor;
 import com.imyeyu.api.annotation.RequestRateLimitInterceptor;
 import com.imyeyu.api.annotation.RequireCorePermissionInterceptor;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermissionInterceptor;
@@ -40,7 +39,6 @@ public class WebConfig implements WebMvcConfigurer {
 	private final ObjectMapper jackson;
 	private final SystemAPIInterceptor systemAPIInterceptor;
 	private final JournalAPIInterceptor journalAPIInterceptor;
 	private final EnableSettingInterceptor enableSettingInterceptor;
 	private final RequestRateLimitInterceptor requestRateLimitInterceptor;
 	private final RequireGaoPermissionInterceptor requireGaoPermissionInterceptor;
 	private final RequireCorePermissionInterceptor requireCorePermissionInterceptor;
@@ -54,7 +52,6 @@ public class WebConfig implements WebMvcConfigurer {
 	public void addInterceptors(InterceptorRegistry registry) {
 		registry.addInterceptor(systemAPIInterceptor).addPathPatterns(SystemAPIInterceptor.PATH);
 		registry.addInterceptor(journalAPIInterceptor).addPathPatterns(JournalAPIInterceptor.PATH);
 		registry.addInterceptor(enableSettingInterceptor).addPathPatterns("/**");
 		registry.addInterceptor(requireCorePermissionInterceptor).addPathPatterns("/**");
 		registry.addInterceptor(requireGaoPermissionInterceptor).addPathPatterns("/**");
 		registry.addInterceptor(requestRateLimitInterceptor).addPathPatterns("/**");
@@ -1,52 +0,0 @@
 package com.imyeyu.api.modules.common.bean;
 import com.imyeyu.api.modules.common.entity.Setting;
 import com.imyeyu.java.bean.timi.TimiCode;
 import com.imyeyu.java.bean.timi.TimiException;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 /**
 * 设置模块
 *
 * @author 夜雨
 * @since 2026-04-24 00:59
 */
@Getter
@AllArgsConstructor
 public enum SettingModule {
 	COMMON(Setting.Module.Common.class),
 	DOMAIN(Setting.Module.Domain.class),
 	FOREVER_MC(Setting.Module.ForeverMC.class),
 	MULTILINGUAL(Setting.Module.Multilingual.class),
 	GITEA(Setting.Module.Gitea.class),
 	MUSIC(Setting.Module.Music.class),
 	JOURNAL(Setting.Module.Journal.class),
 	TEMP_FILE(Setting.Module.TempFile.class),
 	USER(Setting.Module.User.class),
 	SYSTEM(Setting.Module.System.class),
 	SYSTEM_STATUS(Setting.Module.SystemStatus.class);
 	/** 模块枚举类 */
 	final Class<? extends Enum<?>> clazz;
 	public static <T extends Enum<?>> SettingModule fromClass(Class<T> clazz) {
 		for (SettingModule value : values()) {
 			if (value.clazz.equals(clazz)) {
 				return value;
 			}
 		}
 		throw new TimiException(TimiCode.ERROR, "not found System Module: %s".formatted(clazz.getName()));
 	}
 }
@@ -0,0 +1,41 @@
 package com.imyeyu.api.modules.common.bean;
 import com.imyeyu.api.annotation.SettingBizType;
 import com.imyeyu.api.bean.SettingEnum;
 import com.imyeyu.api.modules.common.entity.Setting;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 /**
 *
 *
 * @author 夜雨
 * @since 2026-04-24 14:47
 */
@Getter
@SettingBizType("TEMP_FILE")
@AllArgsConstructor
 public enum TempFileSetting implements SettingEnum {
 	/** 启用服务 */
 	ENABLE(Boolean.TRUE.toString(), Setting.ValueType.BOOLEAN),
 	/** 最小缓存时长 */
 	TTL_MIN("1h", Setting.ValueType.TIME),
 	/** 默认缓存时长 */
 	TTL_DEFAULT("3d", Setting.ValueType.TIME),
 	/** 最大缓存时长 */
 	TTL_MAX("7d", Setting.ValueType.TIME),
 	/** 已过期文件残留时长 */
 	RESIDUE_TTL("90d", Setting.ValueType.TIME),
 	/** 每个 IP 限制有效临时文件容量 */
 	LIMIT_SIZE_OF_IP("10 GB", Setting.ValueType.BYTE_SIZE);
 	final String defaultValue;
 	final Setting.ValueType valueType;
 }
@@ -0,0 +1,96 @@
 package com.imyeyu.api.modules.common.controller;
 import com.fasterxml.jackson.annotation.JsonView;
 import com.imyeyu.api.annotation.RequireCorePermission;
 import com.imyeyu.api.bean.CorePermissionCode;
 import com.imyeyu.api.modules.common.entity.Article;
 import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.service.ArticleService;
 import com.imyeyu.api.modules.common.service.AttachmentService;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
 import com.imyeyu.spring.bean.Page;
 import com.imyeyu.spring.bean.PageResult;
 import com.imyeyu.spring.util.ResponseView;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 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;
 /// 文章接口
 ///
 /// @author Codex
 /// @since 2026-09-09
@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/article")
 public class ArticleController {
 	private final ArticleService service;
 	private final AttachmentService attachmentService;
 	/// 查询文章列表
 	///
 	/// @param page 分页参数
 	/// @return 文章分页
 	@JsonView(ResponseView.Public.class)
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.ARTICLE_READ)
 	@PostMapping("/list")
 	public PageResult<Article> list(@RequestBody Page<Article> page) {
 		return service.page(page);
 	}
 	/// 查询文章详情
 	///
 	/// @param id 文章 ID
 	/// @return 文章详情
 	@JsonView(ResponseView.Public.class)
 	@RequestRateLimit
 	@RequestMapping("/detail")
 	public Article detail(@RequestParam String id) {
 		Article article = service.get(id);
 		article.setAttachmentList(attachmentService.listByBizId(Attachment.BizType.ARTICLE, article.getId()));
 		return article;
 	}
 	/// 创建文章
 	///
 	/// @param article 文章
 	/// @return 创建后的文章
 	@AOPLog
 	@JsonView(ResponseView.Public.class)
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.ARTICLE_CREATE)
 	@PostMapping("/create")
 	public Article create(@RequestBody Article article) {
 		service.create(article);
 		return article;
 	}
 	/// 更新文章
 	///
 	/// @param article 文章
 	@AOPLog
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.ARTICLE_UPDATE)
 	@PostMapping("/update")
 	public void update(@RequestBody Article article) {
 		service.update(article);
 	}
 	/// 删除文章
 	///
 	/// @param id 文章 ID
 	@AOPLog
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.ARTICLE_DELETE)
 	@PostMapping("/delete")
 	public void delete(@RequestParam String id) {
 		service.delete(id);
 	}
 }
@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.common.controller;
 import com.imyeyu.api.modules.common.vo.ClientLogRequest;
 import com.imyeyu.api.modules.system.entity.Logger;
 import com.imyeyu.api.modules.system.service.LoggerService;
 import com.imyeyu.spring.annotation.AOPLog;
@@ -29,7 +30,9 @@ public class LoggerController {
 	@AOPLog
 	@RequiredToken
 	@PostMapping("/create")
-	public void create(@Valid @RequestBody Logger logger) {
+	public void create(@Valid @RequestBody ClientLogRequest request) {
 		Logger logger = Logger.info(Logger.Module.COMMON, "CLIENT_LOG");
 		logger.setContent(request.getContent());
 		service.create(logger);
 	}
 }
@@ -58,6 +58,14 @@ public class NotifyController {
 	@RequiredToken
 	@PostMapping("/create")
 	public Notify create(@RequestBody Notify notify) {
 		String sendFrom = userLoginService.isLogged() ? userLoginService.getRequireLoginUserId() : null;
 		notify.setCreatedBy(sendFrom);
 		for (NotifyDetail detail : notify.getDetailList()) {
 			detail.setNotifyId(notify.getId());
 			if (TimiJava.isNotEmpty(sendFrom)) {
 				detail.setSendFrom(sendFrom);
 			}
 		}
 		service.create(notify);
 		return notify;
 	}
@@ -15,8 +15,12 @@ import lombok.extern.slf4j.Slf4j;
 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 java.util.List;
 import java.util.Map;
 /**
 *
 *
@@ -26,11 +30,30 @@ import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequiredArgsConstructor
-@RequestMapping("/system/setting")
+@RequestMapping("/setting")
 public class SettingController {
 	private final SettingService service;
 	/**
 	 * 查询公开配置映射
 	 *
 	 * @param bizType 业务类型
 	 * @param bizId 业务 ID，可为空
 	 * @param code 配置代码列表，可为空
 	 * @return 公开配置映射
 	 */
 	@JsonView(ResponseView.Public.class)
 	@RequestRateLimit
 	@RequestMapping("/map")
 	public Map<String, Setting> map(
 			@RequestParam String bizType,
 			@RequestParam(required = false) String bizId,
 			@RequestParam(required = false) List<String> code
 	) {
 		return service.mapPublic(bizType, bizId, code);
 	}
 	/**
 	 * 查询配置列表
 	 *
@@ -53,6 +76,7 @@ public class SettingController {
 	 */
 	@JsonView(ResponseView.Admin.class)
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.SETTING_READ)
 	@PostMapping("/detail")
 	public Setting detail(@RequestBody String id) {
 		return service.get(id);
@@ -66,6 +90,7 @@ public class SettingController {
 	 */
 	@AOPLog
 	@JsonView(ResponseView.Admin.class)
 	@RequireCorePermission(CorePermissionCode.SETTING_CREATE)
 	@RequestRateLimit
 	@PostMapping("/create")
 	public Setting create(@RequestBody Setting setting) {
@@ -80,6 +105,7 @@ public class SettingController {
 	 */
 	@AOPLog
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.SETTING_UPDATE)
 	@PostMapping("/update")
 	public void update(@RequestBody Setting setting) {
 		service.update(setting);
@@ -34,6 +34,10 @@ public class Article extends UUIDEntity implements SettingSupport {
 		/// GAO 门店日记
 		GAO_STORE_DIARY,
 		GAO_HELP,
 		GAO_SYSTEM,
 		/// 反馈
 		FEEDBACK
 	}
@@ -52,6 +52,12 @@ public class Attachment extends UUIDEntity {
 		GAO_SALES_ORDER,
 		GAO_POINT_REDEMPTION,
 		GAO_POINT_REDEMPTION_RETURN,
 		GAO_CUSTOMER_FOLLOW_UP_REMINDER,
 		TEMP_FILE,
 		MIRROR
@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.common.entity;
 import com.imyeyu.spring.annotation.table.Transient;
 import com.imyeyu.spring.entity.UUIDEntity;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -39,4 +40,7 @@ public class GroovyScript extends UUIDEntity {
 	/// 当前发布版本 ID
 	private String publishedVersionId;
 	@Transient
 	private GroovyScriptVersion latest;
 }
@@ -20,11 +20,11 @@ public class Notify extends UUIDEntity {
 	/** 业务类型 */
 	private String bizType;
-	/** 提醒业务类型 */
+	/** 业务提醒类型 */
 	private String bizRemindedType;
-	/** 提醒业务 ID */
+	/** 业务提醒查重键 */
-	private String bizRemindedId;
+	private String bizRemindedKey;
 	/** 参数 */
 	private String args;
@@ -7,7 +7,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.imyeyu.api.TimiServerAPI;
 import com.imyeyu.api.modules.common.bean.SettingModule;
 import com.imyeyu.spring.annotation.table.Transient;
 import com.imyeyu.spring.entity.UUIDEntity;
 import com.imyeyu.spring.util.ResponseView;
@@ -62,6 +61,9 @@ public class Setting extends UUIDEntity {
 		/** 时间 */
 		TIME,
 		/// 字节大小
 		BYTE_SIZE,
 		/** 时长 */
 		DURATION,
@@ -102,16 +104,6 @@ public class Setting extends UUIDEntity {
 	@Transient
 	private Enum<?> keyRaw;
 	public Setting(Enum<?> key) {
 		setKeyRaw(key);
 	}
 	public Setting(Enum<?> key, Object value, ValueType valueType) {
 		setKeyRaw(key);
 		this.value = value.toString();
 		this.valueType = valueType;
 	}
 	/**
 	 * 以字符串形式返回配置值
 	 *
@@ -221,298 +213,4 @@ public class Setting extends UUIDEntity {
 			throw new IllegalArgumentException("setting value is not valid json: %s".formatted(value), e);
 		}
 	}
 	public void setKeyRaw(Enum<?> key) {
 		this.keyRaw = key;
 		this.bizType = SettingModule.fromClass(key.getClass()).toString();
 		this.code = key.toString();
 	}
 	public boolean is(Enum<?> key) {
 		return SettingModule.fromClass(key.getClass()).toString().equals(bizType) && key.toString().equals(code);
 	}
 	/**
 	 *
 	 *
 	 * @author 夜雨
 	 * @since 2026-04-24 14:23
 	 */
 	public static final class Module {
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:39
 		 */
 		public enum Common {
 			/** 微信收款码 */
 			WECHAT_RECEIVE_QR_CODE
 		}
 		/**
 		 * 域名
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-26 17:18
 		 */
 		public enum Domain {
 			ROOT,
 			API,
 			GIT,
 			BLOG,
 			SPACE,
 			FOREVER_MC
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:14
 		 */
 		public enum Blog {
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:03
 		 */
 		public enum User {
 			/** 启用登录 */
 			ENABLE_LOGIN,
 			/** 启用注册 */
 			ENABLE_REGISTER,
 			/** 允许数据更新 */
 			ENABLE_PROFILE_UPDATE,
 			/** 令牌有效期 */
 			TOKEN_TTL
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:21
 		 */
 		public enum Comment {
 			/** 启用服务 */
 			ENABLE
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:03
 		 */
 		public enum ICP {
 			IMYEYU_COM
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 15:01
 		 */
 		public enum ForeverMC {
 			PLAYER_BIND_MAX,
 			LOGIN_TOKEN_TTL
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:57
 		 */
 		public enum Multilingual {
 			/** 翻译 API */
 			TRANSLATE_API,
 			/** 翻译 AppId */
 			TRANSLATE_APP_ID,
 			/** 翻译密钥 */
 			TRANSLATE_KEY,
 			/** 翻译计划任务表达式 */
 			TRANSLATE_CORN,
 			/** 缓存时长 */
 			CACHE_TTL
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:55
 		 */
 		public enum Gitea {
 			/** 接口地址 */
 			API,
 			/** 关于页面所属文章 ID */
 			ABOUT_ARTICLE_ID,
 			/** 仓库文件地址 */
 			REPOSITORY_PATH
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:52
 		 */
 		public enum Music {
 			/** 启用服务 */
 			ENABLE,
 			/** 通信消息最大帧长度 */
 			MAX_FRAME_LENGTH,
 			/** 受控端 IP */
 			PLAYER_IP,
 			/** 受控端端口 */
 			PLAYER_PORT,
 			/** 控制端 IP */
 			CONTROLLER_IP,
 			/** 控制端端口 */
 			CONTROLLER_PORT,
 			/** 控制端入口地址 */
 			CONTROLLER_URI,
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:49
 		 */
 		public enum Journal {
 			/** 启用服务 */
 			ENABLE,
 			/** 审核中 */
 			REVIEWING,
 			/** 访问密钥 */
 			KEY,
 			/** 微信小程序 AppId */
 			APP_ID,
 			/** 微信小程序 AppSecret */
 			APP_SECRET,
 			/** 备忘录内容 */
 			MEMO,
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:47
 		 */
 		public enum TempFile {
 			/** 启用服务 */
 			ENABLE,
 			/** 最小缓存时长 */
 			TTL_MIN,
 			/** 默认缓存时长 */
 			TTL_DEFAULT,
 			/** 最大缓存时长 */
 			TTL_MAX,
 			/** 已过期文件残留时长 */
 			RESIDUE_TTL,
 			/** 每个 IP 限制有效临时文件容量 */
 			LIMIT_SIZE_OF_IP
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-27 14:35
 		 */
 		public enum FileSync {
 			ENABLE,
 			CRON,
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:23
 		 */
 		public enum System {
 			/** 文件系统基准路径 */
 			FILE_BASE_PATH,
 			/** 设置缓存时长 */
 			SETTING_TTL,
 			/** 哀悼滤镜 */
 			ENABLE_MOURN_FILTER,
 		}
 		/**
 		 *
 		 *
 		 * @author 夜雨
 		 * @since 2026-04-24 14:23
 		 */
 		public enum SystemStatus {
 			/** 状态采集数据量 */
 			LIMIT,
 			/** 状态采集网卡 */
 			NETWORK_MAC,
 			/** 状态采集频率 */
 			RATE,
 		}
 	}
 }
@@ -2,10 +2,14 @@ package com.imyeyu.api.modules.common.mapper;
 import com.imyeyu.api.modules.common.entity.GroovyScriptVersion;
 import com.imyeyu.spring.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Select;
 /// Groovy 脚本版本 Mapper
 ///
 /// @author Codex
 /// @since 2026-09-04
 public interface GroovyScriptVersionMapper extends BaseMapper<GroovyScriptVersion, String> {
 	@Select("SELECT * FROM `groovy_script_version` WHERE `script_id` = #{scriptId} " + NOT_DELETE + " ORDER BY `version` DESC " + LIMIT_1)
 	GroovyScriptVersion selectLatest(String scriptId);
 }
@@ -2,9 +2,8 @@ package com.imyeyu.api.modules.common.mapper;
 import com.imyeyu.api.modules.common.entity.Notify;
 import com.imyeyu.api.modules.common.vo.NotifyManagementItem;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
 import com.imyeyu.spring.mapper.BaseMapper;
 import org.apache.ibatis.annotations.Param;
 import java.util.List;
@@ -16,9 +15,18 @@ import java.util.List;
 */
 public interface NotifyMapper extends BaseMapper<Notify, String> {
-	/// 查询业务提醒是否已创建
+	/// 原子创建业务提醒
-	@Select("SELECT EXISTS (SELECT 1 FROM `notify` WHERE `biz_type` = #{bizType} AND `biz_reminded_type` = #{bizRemindedType} AND `biz_reminded_id` = #{bizRemindedId} AND `deleted_at` IS NULL)")
+	int insertIfAbsent(Notify notify);
-	boolean existsByBizReminded(@Param("bizType") String bizType, @Param("bizRemindedType") String bizRemindedType, @Param("bizRemindedId") String bizRemindedId);
+
 	/// 按业务查重键查询未删除通知
 	///
 	/// @param bizType 业务类型
 	/// @param bizRemindedType 业务提醒类型
 	/// @param bizRemindedKey 业务提醒查重键
 	/// @return 通知
 	Notify selectByBusinessKey(@Param("bizType") String bizType,
 		@Param("bizRemindedType") String bizRemindedType,
 		@Param("bizRemindedKey") String bizRemindedKey);
 	/// 分页查询管理端通知
 	///
@@ -3,6 +3,8 @@ package com.imyeyu.api.modules.common.mapper;
 import com.imyeyu.api.modules.common.entity.Setting;
 import com.imyeyu.spring.mapper.BaseMapper;
 import java.util.List;
 /**
 * 系统配置
 *
@@ -10,4 +12,6 @@ import com.imyeyu.spring.mapper.BaseMapper;
 * @since 2021-07-20 22:26
 */
 public interface SettingMapper extends BaseMapper<Setting, String> {
 	List<Setting> selectPublicByQuery(String bizType, String bizId, List<String> codeList);
 }
@@ -1,8 +1,8 @@
 package com.imyeyu.api.modules.common.service;
 import com.imyeyu.api.modules.common.bean.GroovyScriptExecutionResult;
 import com.imyeyu.api.modules.common.entity.GroovyScript;
 import com.imyeyu.api.modules.common.entity.GroovyScriptVersion;
 import com.imyeyu.api.modules.common.bean.GroovyScriptExecutionResult;
 import com.imyeyu.spring.service.BaseService;
 import java.util.List;
@@ -16,6 +16,12 @@ import java.util.Map;
 /// @since 2026-09-04
 public interface GroovyScriptService extends BaseService<GroovyScript, String> {
 	/// 按业务归属查询脚本列表
 	///
 	/// @param bizType 业务归属
 	/// @return 脚本列表
 	List<GroovyScript> listByBizType(GroovyScript.BizType bizType);
 	/// 按业务归属和代码查询脚本
 	///
 	/// @param bizType 业务归属
@@ -23,26 +29,14 @@ public interface GroovyScriptService extends BaseService<GroovyScript, String> {
 	/// @return 脚本，不存在时返回 null
 	GroovyScript getByCode(GroovyScript.BizType bizType, String code);
 	/// 创建脚本元数据
 	///
 	/// 新建脚本默认停用，且没有已发布版本
 	///
 	/// @param script 脚本元数据
 	void create(GroovyScript script);
 	/// 更新脚本元数据
 	///
 	/// 业务归属和代码是脚本稳定标识，创建后不可变更
 	///
 	/// @param script 脚本元数据
 	void update(GroovyScript script);
 	/// 设置脚本启用状态
 	///
 	/// @param id 脚本 ID
 	/// @param enabled true 为允许执行已发布版本
 	void setEnabled(String id, boolean enabled);
 	GroovyScriptVersion getLatestVersion(String scriptId);
 	/// 创建不可变的脚本版本
 	///
 	/// @param scriptId 脚本 ID
@@ -67,11 +61,6 @@ public interface GroovyScriptService extends BaseService<GroovyScript, String> {
 	/// @param scriptId 脚本 ID
 	void unpublish(String scriptId);
 	/// 删除脚本
 	///
 	/// @param id 脚本 ID
 	void delete(String id);
 	/// 执行已发布且启用的脚本
 	///
 	/// @param bizType 业务归属
@@ -26,6 +26,12 @@ public interface NotifyDetailService extends BaseService<NotifyDetail, String> {
 	/// @param detailId 通知详情 ID
 	void requeue(String detailId);
 	/// 取消尚未生效的通知详情
 	///
 	/// @param detailId 通知详情 ID
 	/// @param reason 取消原因
 	void cancelPending(String detailId, String reason);
 	/// 分页查询用户的站内通知
 	///
 	/// @param page 分页参数
@@ -14,13 +14,18 @@ import com.imyeyu.spring.service.BaseService;
 */
 public interface NotifyService extends BaseService<Notify, String> {
-	/// 查询业务提醒是否已创建
+	/// 原子创建业务提醒，重复查重键不会创建通知详情
 	///
 	/// @param notify 通知
 	void createIfAbsent(Notify notify);
 	/// 按业务查重键查询未删除通知
 	///
 	/// @param bizType 业务类型
-	/// @param bizRemindedType 被提醒业务类型
+	/// @param bizRemindedType 业务提醒类型
-	/// @param bizRemindedId 被提醒业务 ID
+	/// @param bizRemindedKey 业务提醒查重键
-	/// @return true 为已创建
+	/// @return 通知
-	boolean existsByBizReminded(String bizType, String bizRemindedType, String bizRemindedId);
+	Notify getByBusinessKey(String bizType, String bizRemindedType, String bizRemindedKey);
 	/// 分页查询当前用户创建的通知
 	///
@@ -1,12 +1,13 @@
 package com.imyeyu.api.modules.common.service;
-import com.imyeyu.api.modules.common.bean.SettingModule;
+import com.imyeyu.api.bean.SettingEnum;
 import com.imyeyu.api.modules.common.bean.attachment.SettingSupport;
 import com.imyeyu.api.modules.common.entity.Setting;
 import com.imyeyu.java.TimiJava;
 import com.imyeyu.spring.service.BaseService;
 import java.util.List;
 import java.util.Map;
 /**
 * 配置服务
@@ -18,12 +19,22 @@ public interface SettingService extends BaseService<Setting, String> {
 	Setting getByCode(String bizType, String bizId, String code);
-	default Setting getSystem(Enum<?> bizType) {
+	default Setting getSystem(SettingEnum setting) {
-		return getByCode(SettingModule.fromClass(bizType.getClass()).name(), TimiJava.ZERO_UUID, bizType.toString());
+		return getByCode(setting.getBizType(), TimiJava.ZERO_UUID, setting.name());
 	}
 	List<Setting> listByBizId(String bizType, String bizId);
 	/**
 	 * 查询公开配置映射
 	 *
 	 * @param bizType 业务类型
 	 * @param bizId 业务 ID，可为空
 	 * @param code 配置代码列表，可为空
 	 * @return 公开配置映射
 	 */
 	Map<String, Setting> mapPublic(String bizType, String bizId, List<String> code);
 	default List<Setting> listBySettingSupport(SettingSupport settingSupport) {
 		String bizType = settingSupport.getClass().getSimpleName().toUpperCase();
 		return listByBizId(bizType, settingSupport.getId());
@@ -184,6 +184,7 @@ public class AttachmentServiceImplement extends AbstractEntityService<Attachment
 		try (InputStream inputStream = getInputStreamByMongoId(source.getMongoId())) {
 			target.setInputStream(inputStream);
 			create(target);
 			target.setInputStream(null);
 			return target;
 		} catch (IOException e) {
 			if (target.getMongoId() != null) {
@@ -57,7 +57,7 @@ public class AttachmentVariantServiceImplement implements AttachmentVariantServi
 	private static final int THUMB_MAX_HEIGHT = 4096;
 	private static final long THUMB_MAX_PIXELS = 16_000_000L;
 	private static final long THUMB_CACHE_TTL = Time.D * 7;
-	private static final long THUMB_LOCK_TTL = Time.M * 10;
+	private static final long THUMB_LOCK_TTL = Time.M;
 	private static final double THUMB_TARGET_SECONDS = 2;
 	private static final int VARIANT_NAME_MAX_LENGTH = 255;
 	private static final String THUMB_OUTPUT_FORMAT = "png";
@@ -1,9 +1,9 @@
 package com.imyeyu.api.modules.common.service.implement;
 import com.imyeyu.api.config.dbsource.TimiServerDBConfig;
 import com.imyeyu.api.modules.common.bean.GroovyScriptExecutionResult;
 import com.imyeyu.api.modules.common.entity.GroovyScript;
 import com.imyeyu.api.modules.common.entity.GroovyScriptVersion;
 import com.imyeyu.api.modules.common.bean.GroovyScriptExecutionResult;
 import com.imyeyu.api.modules.common.mapper.GroovyScriptMapper;
 import com.imyeyu.api.modules.common.mapper.GroovyScriptVersionMapper;
 import com.imyeyu.api.modules.common.service.GroovyScriptService;
@@ -52,6 +52,14 @@ public class GroovyScriptServiceImplement extends AbstractEntityService<GroovySc
 		return mapper;
 	}
 	@Override
 	public List<GroovyScript> listByBizType(GroovyScript.BizType bizType) {
 		TimiException.required(bizType, "未找到脚本业务归属");
 		GroovyScript example = new GroovyScript();
 		example.setBizType(bizType);
 		return mapper.selectAllByExample(example);
 	}
 	@Override
 	public GroovyScript getByCode(GroovyScript.BizType bizType, String code) {
 		GroovyScript example = new GroovyScript();
@@ -95,6 +103,11 @@ public class GroovyScriptServiceImplement extends AbstractEntityService<GroovySc
 		invalidateAfterCommit(script.getId());
 	}
 	@Override
 	public GroovyScriptVersion getLatestVersion(String scriptId) {
 		return versionMapper.selectLatest(scriptId);
 	}
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
 	public GroovyScriptVersion createVersion(String scriptId, String content) {
@@ -104,7 +117,7 @@ public class GroovyScriptServiceImplement extends AbstractEntityService<GroovySc
 		GroovyScriptVersion version = new GroovyScriptVersion();
 		version.setScriptId(scriptId);
-		version.setVersion(nextVersion(scriptId));
+		version.setVersion(versionMapper.selectLatest(scriptId).getVersion() + 1);
 		version.setContent(content);
 		version.setChecksum(checksum(content));
 		versionMapper.insert(version);
@@ -218,13 +231,6 @@ public class GroovyScriptServiceImplement extends AbstractEntityService<GroovySc
 		return version;
 	}
 	private int nextVersion(String scriptId) {
 		return listVersion(scriptId).stream()
 				.map(GroovyScriptVersion::getVersion)
 				.max(Integer::compareTo)
 				.orElse(0) + 1;
 	}
 	private String cacheKey(GroovyScriptVersion version) {
 		return "%s:%s".formatted(version.getId(), version.getChecksum());
 	}
@@ -108,6 +108,36 @@ public class NotifyDetailServiceImplement extends AbstractEntityService<NotifyDe
 		super.delete(detailId);
 	}
 	/// 取消尚未生效的通知详情
 	///
 	/// @param detailId 通知详情 ID
 	/// @param reason 取消原因
 	@Override
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	public void cancelPending(String detailId, String reason) {
 		TimiException.required(detailId, "未找到通知详情 ID");
 		NotifyDetail detail = get(detailId);
 		TimiException.required(detail, "未找到通知详情");
 		if (detail.getStatus() == NotifyDetail.Status.CANCEL) {
 			return;
 		}
 		long now = Time.now();
 		boolean canCancel = detail.getMsgType() == NotifyDetail.MsgType.INTERNAL
 			? detail.getSendAt() != null && now < detail.getSendAt()
 			: detail.getMsgType() != null && detail.getMsgType().isQueue()
 				&& detail.getStatus() == NotifyDetail.Status.WAITING;
 		if (!canCancel) {
 			return;
 		}
 		if (detail.getMsgType().isQueue()) {
 			detail.getMsgType().getService().destroyQueue(detail);
 		}
 		detail.setStatus(NotifyDetail.Status.CANCEL);
 		detail.setResultDesc(TimiJava.defaultIfEmpty(reason, "通知已取消"));
 		update(detail);
 	}
 	/// 重新将通知详情放入消息队列
 	///
 	/// @param detailId 通知详情 ID
@@ -6,10 +6,9 @@ import com.imyeyu.api.modules.common.entity.NotifyDetail;
 import com.imyeyu.api.modules.common.mapper.NotifyMapper;
 import com.imyeyu.api.modules.common.service.NotifyDetailService;
 import com.imyeyu.api.modules.common.service.NotifyService;
 import com.imyeyu.api.modules.system.entity.Logger;
 import com.imyeyu.api.modules.system.service.LoggerService;
 import com.imyeyu.api.modules.common.vo.NotifyManagementItem;
-import com.imyeyu.api.modules.user.service.UserLoginService;
+import com.imyeyu.api.modules.system.audit.AuditOperation;
 import com.imyeyu.api.modules.system.audit.OperationAudit;
 import com.imyeyu.java.TimiJava;
 import com.imyeyu.java.bean.timi.TimiCode;
 import com.imyeyu.java.bean.timi.TimiException;
@@ -17,12 +16,13 @@ import com.imyeyu.spring.bean.Page;
 import com.imyeyu.spring.bean.PageResult;
 import com.imyeyu.spring.mapper.BaseMapper;
 import com.imyeyu.spring.service.AbstractEntityService;
 import com.imyeyu.utils.Time;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import java.util.List;
 import java.util.UUID;
 /**
 * 通知服务实现
@@ -30,13 +30,10 @@ import java.util.List;
 * @author 夜雨
 * @since 2026-05-13 14:46
 */
@Slf4j
@Service
@RequiredArgsConstructor
 public class NotifyServiceImplement extends AbstractEntityService<Notify, String> implements NotifyService {
 	private final LoggerService loggerService;
 	private final UserLoginService userLoginService;
 	private final NotifyDetailService detailService;
 	private final NotifyMapper mapper;
@@ -46,45 +43,67 @@ public class NotifyServiceImplement extends AbstractEntityService<Notify, String
 		return mapper;
 	}
 	@Override
 	public boolean existsByBizReminded(String bizType, String bizRemindedType, String bizRemindedId) {
 		return mapper.existsByBizReminded(bizType, bizRemindedType, bizRemindedId);
 	}
 	/// 创建通知并级联创建通知详情
 	///
 	/// @param notify 通知
 	@OperationAudit(AuditOperation.COMMON_NOTIFY_CREATE)
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
 	public void create(Notify notify) {
-		Logger logger = new Logger(Logger.Module.COMMON, "COMMON_NOTIFY_CREATE");
+		prepareCreate(notify);
-		try {
+		super.create(notify);
-			TimiException.required(notify, "未找到通知");
+		createDetails(notify);
-			TimiException.required(notify.getDetailList(), "未找到通知详情列表");
+	}
 			String sendFrom = userLoginService.isLogged() ? userLoginService.getRequireLoginUserId() : null;
 			notify.setCreatedBy(sendFrom);
 			super.create(notify);
-			for (NotifyDetail detail : notify.getDetailList()) {
+	/// 原子创建业务提醒并级联创建通知详情
-				detail.setNotifyId(notify.getId());
+	///
-				if (TimiJava.isNotEmpty(sendFrom)) {
+	/// @param notify 通知
-					detail.setSendFrom(sendFrom);
+	@OperationAudit(AuditOperation.COMMON_NOTIFY_CREATE)
-				}
+	@Transactional(TimiServerDBConfig.ROLLBACKER)
-				detailService.create(detail);
+	@Override
-			}
+	public void createIfAbsent(Notify notify) {
-			logger.setLevel(Logger.Level.INFO);
+		prepareCreate(notify);
-			logger.setResult(notify.getId());
+		if (mapper.insertIfAbsent(notify) == 0) {
-		} catch (TimiException e) {
+			return;
-			logger.setLevel(Logger.Level.WARN);
+		}
-			logger.setException(e.getMessage());
+		createDetails(notify);
-			throw e;
+	}
-		} catch (Exception e) {
+
-			logger.setLevel(Logger.Level.ERROR);
+	/// 按业务查重键查询未删除通知
-			logger.setException(TimiJava.serializeThrowable(e));
+	///
-			log.error("创建通知失败", e);
+	/// @param bizType 业务类型
-			throw new TimiException(TimiCode.ERROR, "创建通知失败", e);
+	/// @param bizRemindedType 业务提醒类型
-		} finally {
+	/// @param bizRemindedKey 业务提醒查重键
-			loggerService.create(logger);
+	/// @return 通知
 	@Override
 	public Notify getByBusinessKey(String bizType, String bizRemindedType, String bizRemindedKey) {
 		TimiException.required(bizType, "未找到通知业务类型");
 		TimiException.required(bizRemindedType, "未找到通知提醒类型");
 		TimiException.required(bizRemindedKey, "未找到通知查重键");
 		return mapper.selectByBusinessKey(bizType, bizRemindedType, bizRemindedKey);
 	}
 	/// 校验并补全通知创建字段
 	///
 	/// @param notify 通知
 	private void prepareCreate(Notify notify) {
 		TimiException.required(notify, "未找到通知");
 		TimiException.required(notify.getDetailList(), "未找到通知详情列表");
 		notify.setId(TimiJava.defaultIfEmpty(notify.getId(), UUID.randomUUID().toString()));
 		notify.setCreatedBy(TimiJava.defaultIfEmpty(notify.getCreatedBy(), TimiJava.ZERO_UUID));
 		notify.setCreatedAt(TimiJava.defaultIfNull(notify.getCreatedAt(), Time.now()));
 		notify.setUpdatedAt(null);
 		notify.setDeletedAt(null);
 	}
 	/// 创建通知详情
 	///
 	/// @param notify 通知
 	private void createDetails(Notify notify) {
 		for (NotifyDetail detail : notify.getDetailList()) {
 			detail.setNotifyId(notify.getId());
 			detail.setSendFrom(TimiJava.defaultIfEmpty(detail.getSendFrom(), TimiJava.ZERO_UUID));
 			detailService.create(detail);
 		}
 	}
@@ -122,6 +141,8 @@ public class NotifyServiceImplement extends AbstractEntityService<Notify, String
 	/// @param notifyId 通知 ID
 	/// @param userId 用户 ID
 	@Override
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@OperationAudit(AuditOperation.COMMON_NOTIFY_DELETE)
 	public void deleteManagement(String notifyId, String userId) {
 		getManagement(notifyId, userId);
 		delete(notifyId);
@@ -132,6 +153,7 @@ public class NotifyServiceImplement extends AbstractEntityService<Notify, String
 	/// @param notifyId 通知 ID
 	/// @param userId 用户 ID
 	@Override
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	public void cancelManagement(String notifyId, String userId) {
 		getManagement(notifyId, userId);
 		cancel(notifyId);
@@ -140,32 +162,17 @@ public class NotifyServiceImplement extends AbstractEntityService<Notify, String
 	/// 删除通知并级联软删除通知详情
 	///
 	/// @param notifyId 通知 ID
 	@OperationAudit(AuditOperation.COMMON_NOTIFY_DELETE)
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
 	public void delete(String notifyId) {
-		Logger logger = new Logger(Logger.Module.COMMON, "COMMON_NOTIFY_DELETE");
+		TimiException.required(notifyId, "未找到通知 ID");
-		try {
+		TimiException.required(get(notifyId), "未找到通知");
-			TimiException.required(notifyId, "未找到通知 ID");
+		List<NotifyDetail> detailList = detailService.listByNotifyId(notifyId);
-			TimiException.required(get(notifyId), "未找到通知");
+		for (NotifyDetail detail : detailList) {
-			List<NotifyDetail> detailList = detailService.listByNotifyId(notifyId);
+			detailService.delete(detail.getId());
 			for (NotifyDetail detail : detailList) {
 				detailService.delete(detail.getId());
 			}
 			super.delete(notifyId);
 			logger.setLevel(Logger.Level.INFO);
 			logger.setResult(notifyId);
 		} catch (TimiException e) {
 			logger.setLevel(Logger.Level.WARN);
 			logger.setException(e.getMessage());
 			throw e;
 		} catch (Exception e) {
 			logger.setLevel(Logger.Level.ERROR);
 			logger.setException(TimiJava.serializeThrowable(e));
 			log.error("删除通知失败", e);
 			throw new TimiException(TimiCode.ERROR, "删除通知失败", e);
 		} finally {
 			loggerService.create(logger);
 		}
 		super.delete(notifyId);
 	}
 	/// 取消通知中尚未成功发送的通知详情
@@ -17,6 +17,8 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 /**
 * 系统配置服务实现
@@ -53,6 +55,12 @@ public class SettingServiceImplement extends AbstractEntityService<Setting, Stri
 		return mapper.selectAllByExample(example);
 	}
 	@Override
 	public Map<String, Setting> mapPublic(String bizType, String bizId, List<String> code) {
 		TimiException.required(bizType, "not found bizType");
 		return mapper.selectPublicByQuery(bizType, bizId, code).stream().collect(Collectors.toMap(Setting::getCode, Function.identity()));
 	}
 	@Transactional(TimiServerDBConfig.ROLLBACKER)
 	@Override
 	public void updateByBizId(String bizType, String bizId, List<Setting> list) {
@@ -3,6 +3,7 @@ package com.imyeyu.api.modules.common.service.implement;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.imyeyu.api.modules.common.bean.TempFileSetting;
 import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.entity.Setting;
 import com.imyeyu.api.modules.common.service.AttachmentService;
@@ -52,11 +53,11 @@ public class TempFileServiceImplement implements TempFileService {
 		try {
 			logger.setContent(jackson.writeValueAsString(logRequestArgs(files, ttl)));
-			Setting ttlMin = settingService.getSystem(Setting.Module.TempFile.TTL_MIN);
+			Setting ttlMin = settingService.getSystem(TempFileSetting.TTL_MIN);
-			Setting ttlMax = settingService.getSystem(Setting.Module.TempFile.TTL_MAX);
+			Setting ttlMax = settingService.getSystem(TempFileSetting.TTL_MAX);
-			Setting ttlDefault = settingService.getSystem(Setting.Module.TempFile.TTL_DEFAULT);
+			Setting ttlDefault = settingService.getSystem(TempFileSetting.TTL_DEFAULT);
-			Setting residueTime = settingService.getSystem(Setting.Module.TempFile.RESIDUE_TTL);
+			Setting residueTime = settingService.getSystem(TempFileSetting.RESIDUE_TTL);
-			String limitStr = settingService.getSystem(Setting.Module.TempFile.LIMIT_SIZE_OF_IP).asString();
+			String limitStr = settingService.getSystem(TempFileSetting.LIMIT_SIZE_OF_IP).asString();
 			long limit = IOSize.parse(limitStr);
@@ -0,0 +1,18 @@
 package com.imyeyu.api.modules.common.vo;
 import jakarta.validation.constraints.Size;
 import lombok.Data;
 /// 客户端诊断日志请求
 ///
 /// 客户端日志不是操作审计，操作编码、模块、级别、用户和 IP 均由服务端决定
 ///
 /// @author Codex
 /// @since 2026-09-09
@Data
 public class ClientLogRequest {
 	/// 日志内容
 	@Size(max = 32768, message = "日志内容不能超过 32 KB")
 	private String content;
 }
@@ -0,0 +1,32 @@
 package com.imyeyu.api.modules.gao.ai.config;
 import lombok.Getter;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 /// GAO 智能体配置
 ///
 /// 密钥只从部署环境变量或外部配置读取，不允许写入仓库
 ///
 /// @author Codex
 /// @since 2026-09-15
@Getter
@Component
 public class GaoAiProperties {
 	/// AI 会话有效期，单位秒
 	@Value("${gao.ai.session-ttl-seconds:300}")
 	private long sessionTtlSeconds;
 	/// 工具单页最大条数
 	@Value("${gao.ai.max-tool-page-size:20}")
 	private int maxToolPageSize;
 	/// Dify 连接超时，单位秒
 	@Value("${gao.ai.connect-timeout-seconds:10}")
 	private long connectTimeoutSeconds;
 	/// Dify 流式读取空闲超时，单位秒
 	@Value("${gao.ai.read-timeout-seconds:600}")
 	private long readTimeoutSeconds;
 }
@@ -0,0 +1,98 @@
 package com.imyeyu.api.modules.gao.ai.controller;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiAccessException;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiChatService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiChatRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationListRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationReadRequest;
 import com.imyeyu.spring.annotation.IgnoreGlobalReturn;
 import com.imyeyu.spring.annotation.RequestRateLimit;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 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.server.ResponseStatusException;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 /// GAO 智能体聊天接口
 ///
 /// 浏览器只携带 Timi 登录令牌访问本接口，不接触 Dify 或 MCP 密钥
 ///
 /// @author Codex
 /// @since 2026-09-15
@RestController
@RequiredArgsConstructor
@RequestMapping("/gao/ai")
 public class GaoAiChatController {
 	private final GaoAiChatService chatService;
 	/// 发起门店智能体流式聊天
 	///
 	/// @param request 聊天请求
 	/// @return SSE 发射器
 	@RequestRateLimit
 	@IgnoreGlobalReturn
 	@PostMapping(value = "/chat", produces = "text/event-stream")
 	public SseEmitter chat(@RequestBody GaoAiChatRequest request) {
 		try {
 			return chatService.chat(request);
 		} catch (GaoAiAccessException e) {
 			throw accessException(e);
 		}
 	}
 	/// 列出当前登录用户的历史会话
 	///
 	/// @param request 历史会话分页请求
 	/// @return 历史会话分页结果
 	@RequestRateLimit
 	@PostMapping("/conversation/list")
 	public JsonNode listConversation(@RequestBody(required = false) GaoAiConversationListRequest request) {
 		try {
 			return chatService.listConversation(request);
 		} catch (GaoAiAccessException e) {
 			throw accessException(e);
 		}
 	}
 	/// 读取指定历史会话的消息
 	///
 	/// @param request 历史会话读取请求
 	/// @return 会话消息分页结果
 	@RequestRateLimit
 	@PostMapping("/conversation/read")
 	public JsonNode readConversation(@RequestBody GaoAiConversationReadRequest request) {
 		try {
 			return chatService.readConversation(request);
 		} catch (GaoAiAccessException e) {
 			throw accessException(e);
 		}
 	}
 	/// 删除当前登录用户的历史会话
 	///
 	/// @param conversationId Dify 会话 ID
 	/// @return 无
 	@RequestRateLimit
 	@PostMapping("/conversation/delete")
 	public void deleteConversation(@RequestParam String conversationId) {
 		try {
 			chatService.deleteConversation(conversationId);
 		} catch (GaoAiAccessException e) {
 			throw accessException(e);
 		}
 	}
 	/// 转换智能体访问异常
 	///
 	/// @param exception 智能体访问异常
 	/// @return HTTP 响应状态异常
 	private ResponseStatusException accessException(GaoAiAccessException exception) {
 		return new ResponseStatusException(HttpStatus.valueOf(exception.getStatus()), exception.getMessage(), exception);
 	}
 }
@@ -0,0 +1,40 @@
 package com.imyeyu.api.modules.gao.ai.entity;
 import lombok.Data;
 /// GAO 智能体审计记录
 ///
 /// 业务审计通过现有系统日志服务落库，本对象只承载脱敏后的结构化内容
 ///
 /// @author Codex
 /// @since 2026-09-15
@Data
 public class GaoAiAuditLog {
 	/// 登录用户 ID
 	private String userId;
 	/// 门店 ID
 	private String storeId;
 	/// 问题摘要哈希，不保存问题原文
 	private String questionDigest;
 	/// Dify 会话 ID
 	private String conversationId;
 	/// 调用的工具名称
 	private String toolName;
 	/// 查询耗时，单位毫秒
 	private long duration;
 	/// 查询状态
 	private String status;
 	/// 返回条数
 	private long resultCount;
 	/// 记录时间，单位毫秒
 	private long createdAt;
 }
@@ -0,0 +1,39 @@
 package com.imyeyu.api.modules.gao.ai.entity;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.util.LinkedHashSet;
 import java.util.Set;
 /// GAO 智能体短期会话授权
 ///
 /// 该对象只存储在服务端，`sessionId` 不是 JWT，也不是用户登录令牌
 ///
 /// @author Codex
 /// @since 2026-09-15
@Data
@NoArgsConstructor
 public class GaoAiSession {
 	/// 不可预测的 AI 会话 ID
 	private String sessionId;
 	/// 登录用户 ID
 	private String userId;
 	/// 固定的门店 ID
 	private String storeId;
 	/// Dify 会话 ID，可为空
 	private String difyConversationId;
 	/// 允许调用的只读工具
 	private Set<String> allowedTools = new LinkedHashSet<>();
 	/// 过期时间，单位毫秒
 	private long expiresAt;
 	/// 已调用工具次数
 	private long usedCount;
 }
@@ -0,0 +1,86 @@
 package com.imyeyu.api.modules.gao.ai.mcp;
 import com.imyeyu.api.modules.common.service.SettingService;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiSessionService;
 import com.imyeyu.api.modules.gao.ai.service.implement.GaoAiSessionServiceImplement.GaoAiSessionException;
 import com.imyeyu.api.modules.gao.bean.GaoSystemSetting;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 /// Dify MCP 请求认证
 ///
 /// 服务密钥只证明请求来自 Dify，门店和用户身份完全来自 AI 会话
 ///
 /// @author Codex
 /// @since 2026-09-15
@Service
@RequiredArgsConstructor
 public class GaoAiMcpAuthentication {
 	private final SettingService settingService;
 	private final GaoAiSessionService sessionService;
 	/// 校验 Dify 服务密钥和 AI 会话
 	///
 	/// @param authorization Authorization 请求头
 	/// @param headerSessionId X-Timi-AI-Session 请求头
 	/// @param argumentSessionId MCP 工具参数中的 AI 会话 ID
 	/// @param toolName 工具名称，可为空
 	/// @return 已认证会话
 	public GaoAiSession authenticate(String authorization, String headerSessionId, String argumentSessionId, String toolName) {
 		authenticateService(authorization);
 		String sessionId = headerSessionId;
 		if (isBlank(sessionId) && !isBlank(argumentSessionId)) {
 			sessionId = argumentSessionId;
 		}
 		GaoAiSession session = sessionService.require(sessionId);
 		if (toolName != null && (session.getAllowedTools() == null || !session.getAllowedTools().contains(toolName))) {
 			throw new GaoAiSessionException("AI 会话无权调用该工具", 403);
 		}
 		return session;
 	}
 	/// 只校验 Dify 服务间密钥
 	///
 	/// MCP 初始化和工具声明阶段尚未绑定店长会话，只能校验服务间身份
 	///
 	/// @param authorization Authorization 请求头
 	public void authenticateService(String authorization) {
 		String key = settingService.getSystem(GaoSystemSetting.DIFY_MCP_SERVICE_KEY).asString();
 		String actualKey = bearerValue(authorization);
 		if (key.isEmpty() || actualKey.isEmpty() || !constantTimeEquals(key, actualKey)) {
 			throw new GaoAiSessionException("MCP 服务认证失败", 401);
 		}
 	}
 	private String bearerValue(String authorization) {
 		if (authorization == null) {
 			return "";
 		}
 		String value = authorization.trim();
 		if (7 > value.length() || !value.regionMatches(true, 0, "Bearer ", 0, 7)) {
 			return "";
 		}
 		return value.substring(7).trim();
 	}
 	private boolean constantTimeEquals(String left, String right) {
 		return MessageDigest.isEqual(left.getBytes(StandardCharsets.UTF_8), right.getBytes(StandardCharsets.UTF_8));
 	}
 	private String trim(String value) {
 		return value == null ? "" : value.trim();
 	}
 	/// 判断字符串是否为空
 	///
 	/// @param value 待判断字符串
 	/// @return true 为 null、空字符串或空白字符串
 	private boolean isBlank(String value) {
 		return value == null || value.trim().isEmpty();
 	}
 }
@@ -0,0 +1,273 @@
 package com.imyeyu.api.modules.gao.ai.mcp;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiAuditLog;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.tool.GaoAiTool;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiAuditService;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiSessionService;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiToolException;
 import com.imyeyu.api.modules.gao.ai.service.implement.GaoAiSessionServiceImplement.GaoAiSessionException;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import com.imyeyu.spring.annotation.IgnoreGlobalReturn;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 /// GAO 智能体 MCP Streamable HTTP 接口
 ///
 /// Dify 通过 Docker 内网访问本接口，业务查询只允许调用已注册的只读工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Slf4j
@RestController
@RequestMapping("/mcp/gao-ai")
 public class GaoAiMcpController {
 	private final ObjectMapper jackson;
 	private final GaoAiMcpAuthentication authentication;
 	private final GaoAiSessionService sessionService;
 	private final GaoAiAuditService auditService;
 	private final Map<String, GaoAiTool> toolMap;
 	public GaoAiMcpController(ObjectMapper jackson, GaoAiMcpAuthentication authentication,
 		GaoAiSessionService sessionService, GaoAiAuditService auditService, List<GaoAiTool> toolList) {
 		this.jackson = jackson;
 		this.authentication = authentication;
 		this.sessionService = sessionService;
 		this.auditService = auditService;
 		this.toolMap = toolList.stream().collect(Collectors.toUnmodifiableMap(GaoAiTool::name, Function.identity()));
 	}
 	/// 处理 MCP JSON-RPC 请求
 	///
 	/// @param authorization Dify 服务密钥
 	/// @param aiSessionId AI 会话头
 	/// @param request JSON-RPC 请求
 	/// @return JSON-RPC 响应
 	@IgnoreGlobalReturn
 	@PostMapping
 	public ResponseEntity<Object> handle(@RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
 		@RequestHeader(value = "X-Timi-AI-Session", required = false) String aiSessionId,
 		@RequestBody JsonNode request) {
 		JsonNode id = request == null ? null : request.get("id");
 		String method = text(request, "method");
 		String toolName = text(request == null ? null : request.path("params"), "name");
 		log.info("GAO MCP 请求：method={}, toolName={}, authorizationPresent={}, aiSessionPresent={}, aiSessionLength={}",
 			method, toolName, hasText(authorization), hasText(aiSessionId), length(aiSessionId));
 		try {
 			if (request == null || !request.isObject()) {
 				return response(400, error(id, -32600, "MCP 请求格式无效"));
 			}
 			if (method == null) {
 				return response(400, error(id, -32600, "MCP 请求缺少 method"));
 			}
 			return switch (method) {
 				case "initialize" -> {
 					authentication.authenticateService(authorization);
 					yield response(200, success(id, initializeResult()));
 				}
 				case "notifications/initialized", "ping" -> {
 					authentication.authenticateService(authorization);
 					yield response(200, success(id, Map.of()));
 				}
 				case "tools/list" -> {
 					authentication.authenticateService(authorization);
 					yield response(200, success(id, toolsResult()));
 				}
 				case "tools/call" -> {
 					JsonNode params = request.path("params");
 					String argumentSessionId = text(params.path("arguments"), "aiSessionId");
 					GaoAiSession session = authentication.authenticate(authorization, aiSessionId, argumentSessionId, text(params, "name"));
 					if (hasText(argumentSessionId) && !hasText(aiSessionId)) {
 						log.info("GAO MCP 使用工具参数中的 AI 会话：toolName={}, aiSessionLength={}", toolName, length(argumentSessionId));
 					}
 					yield response(200, success(id, executeTool(session, params, hasText(aiSessionId) ? aiSessionId : argumentSessionId)));
 				}
 				default -> response(400, error(id, -32601, "MCP 方法不支持"));
 			};
 		} catch (GaoAiSessionException e) {
 			log.warn("GAO MCP 认证失败：method={}, toolName={}, status={}, authorizationPresent={}, aiSessionPresent={}, aiSessionLength={}, reason={}",
 				method, toolName, e.getStatus(), hasText(authorization), hasText(aiSessionId), length(aiSessionId), e.getMessage());
 			return response(e.getStatus(), error(id, -32001, e.getMessage()));
 		} catch (GaoAiToolException e) {
 			log.warn("GAO MCP 工具调用失败：method={}, toolName={}, status={}, aiSessionPresent={}, reason={}",
 				method, toolName, e.getStatus(), hasText(aiSessionId), e.getMessage());
 			return response(e.getStatus(), error(id, -32602, e.getMessage()));
 		} catch (RuntimeException e) {
 			log.warn("GAO 智能体 MCP 请求失败", e);
 			return response(500, error(id, -32603, "智能体查询失败，请稍后重试"));
 		}
 	}
 	private Object executeTool(GaoAiSession session, JsonNode params, String aiSessionId) {
 		if (params == null || !params.isObject()) {
 			throw new GaoAiToolException("工具参数格式无效", 400);
 		}
 		String toolName = text(params, "name");
 		GaoAiTool tool = toolMap.get(toolName);
 		if (tool == null) {
 			throw new GaoAiToolException("工具不存在或未启用", 403);
 		}
 		JsonNode arguments = params == null || !params.has("arguments") ? jackson.createObjectNode() : params.get("arguments");
 		if (arguments == null || !arguments.isObject()) {
 			throw new GaoAiToolException("工具参数格式无效", 400);
 		}
 		ObjectNode businessArguments = ((ObjectNode) arguments).deepCopy();
 		businessArguments.remove("aiSessionId");
 		if (containsField(businessArguments, "storeId")) {
 			throw new GaoAiToolException("工具请求不允许携带 storeId", 403);
 		}
 		GaoAiToolRequest request;
 		try {
 			request = jackson.treeToValue(businessArguments, GaoAiToolRequest.class);
 		} catch (Exception e) {
 			throw new GaoAiToolException("工具参数格式无效", 400);
 		}
 		long startedAt = System.currentTimeMillis();
 		try {
 			GaoAiToolResult result = tool.execute(session, request);
 			long duration = System.currentTimeMillis() - startedAt;
 			if (hasText(aiSessionId)) {
 				sessionService.increaseUsedCount(aiSessionId);
 			}
 			recordAudit(session, request, toolName, duration, "SUCCESS", result == null ? 0L : result.getDetails().size());
 			Map<String, Object> content = new LinkedHashMap<>();
 			content.put("type", "text");
 			content.put("text", writeJson(result));
 			return Map.of("content", List.of(content), "structuredContent", result);
 		} catch (GaoAiToolException e) {
 			recordAudit(session, request, toolName, System.currentTimeMillis() - startedAt, "ERROR", 0L);
 			throw e;
 		} catch (RuntimeException e) {
 			recordAudit(session, request, toolName, System.currentTimeMillis() - startedAt, "ERROR", 0L);
 			throw e;
 		}
 	}
 	private Map<String, Object> initializeResult() {
 		Map<String, Object> result = new LinkedHashMap<>();
 		result.put("protocolVersion", "2025-03-26");
 		result.put("capabilities", Map.of("tools", Map.of("listChanged", false)));
 		result.put("serverInfo", Map.of("name", "TimiServerAPI-GAO-AI", "version", "1.0"));
 		return result;
 	}
 	private Map<String, Object> toolsResult() {
 		List<Map<String, Object>> tools = toolMap.values().stream()
 			.map(tool -> {
 			Map<String, Object> item = new LinkedHashMap<>();
 			item.put("name", tool.name());
 			item.put("description", tool.description());
 			item.put("inputSchema", tool.inputSchema());
 			return item;
 			}).toList();
 		return Map.of("tools", tools);
 	}
 	private void recordAudit(GaoAiSession session, GaoAiToolRequest request, String toolName, long duration,
 		String status, long resultCount) {
 		GaoAiAuditLog audit = new GaoAiAuditLog();
 		audit.setUserId(session.getUserId());
 		audit.setStoreId(session.getStoreId());
 		audit.setQuestionDigest(auditService.digest(request == null ? null : request.getQuery()));
 		audit.setConversationId(session.getDifyConversationId());
 		audit.setToolName(toolName);
 		audit.setDuration(Math.max(0L, duration));
 		audit.setStatus(status);
 		audit.setResultCount(resultCount);
 		audit.setCreatedAt(System.currentTimeMillis());
 		auditService.record(audit);
 	}
 	private ResponseEntity<Object> response(int status, Object body) {
 		return ResponseEntity.status(status).body(body);
 	}
 	private Map<String, Object> success(JsonNode id, Object result) {
 		Map<String, Object> response = new LinkedHashMap<>();
 		response.put("jsonrpc", "2.0");
 		response.put("id", id);
 		response.put("result", result);
 		return response;
 	}
 	private Map<String, Object> error(JsonNode id, int code, String message) {
 		Map<String, Object> response = new LinkedHashMap<>();
 		response.put("jsonrpc", "2.0");
 		response.put("id", id);
 		response.put("error", Map.of("code", code, "message", message));
 		return response;
 	}
 	private String text(JsonNode node, String field) {
 		if (node == null || !node.hasNonNull(field)) {
 			return null;
 		}
 		String value = node.get(field).asText();
 		return value == null || value.trim().isEmpty() ? null : value.trim();
 	}
 	/// 判断字符串是否有实际内容
 	///
 	/// @param value 待判断字符串
 	/// @return true 为有内容
 	private boolean hasText(String value) {
 		return value != null && !value.trim().isEmpty();
 	}
 	/// 获取字符串长度
 	///
 	/// @param value 待计算字符串
 	/// @return 字符串长度
 	private int length(String value) {
 		return value == null ? 0 : value.trim().length();
 	}
 	private boolean containsField(JsonNode node, String field) {
 		if (node == null) {
 			return false;
 		}
 		if (node.isObject()) {
 			if (node.has(field)) {
 				return true;
 			}
 			for (JsonNode child : node) {
 				if (containsField(child, field)) {
 					return true;
 				}
 			}
 		}
 		if (node.isArray()) {
 			for (JsonNode child : node) {
 				if (containsField(child, field)) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
 	private String writeJson(Object value) {
 		try {
 			return jackson.writeValueAsString(value);
 		} catch (Exception e) {
 			throw new GaoAiToolException("工具结果序列化失败", 500);
 		}
 	}
 }
@@ -0,0 +1,37 @@
 package com.imyeyu.api.modules.gao.ai.mcp;
 import com.imyeyu.spring.annotation.IgnoreGlobalReturn;
 import org.springframework.http.CacheControl;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 /// GAO MCP OAuth 探测兼容接口
 ///
 /// Dify 即使配置固定请求头认证，也会预先探测 OAuth 元数据。本服务不提供 OAuth，必须返回原始 404，
 /// 不能落入全局异常处理后被包装为业务 JSON
 ///
 /// @author Codex
 /// @since 2026-09-15
@RestController
 public class GaoAiMcpOAuthDiscoveryController {
 	/// 返回未实现的 OAuth 探测结果
 	///
 	/// @return 原始 HTTP 404
 	@IgnoreGlobalReturn
 	@GetMapping({
 		"/.well-known/oauth-authorization-server",
 		"/.well-known/oauth-authorization-server/mcp/gao-ai",
 		"/.well-known/oauth-protected-resource",
 		"/.well-known/oauth-protected-resource/mcp/gao-ai",
 		"/.well-known/openid-configuration",
 		"/.well-known/openid-configuration/mcp/gao-ai",
 		"/mcp/gao-ai/.well-known/oauth-authorization-server",
 		"/mcp/gao-ai/.well-known/oauth-protected-resource",
 		"/mcp/gao-ai/.well-known/openid-configuration"
 	})
 	public ResponseEntity<Void> notSupported() {
 		return ResponseEntity.notFound().cacheControl(CacheControl.noStore()).build();
 	}
 }
@@ -0,0 +1,46 @@
 package com.imyeyu.api.modules.gao.ai.mcp;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 /// GAO 智能体只读工具名称
 ///
 /// @author Codex
 /// @since 2026-09-15
 public final class GaoAiToolNames {
 	public static final String STORE_OVERVIEW = "store_overview";
 	public static final String CUSTOMER_SEARCH = "customer_search";
 	public static final String CUSTOMER_PROFILE = "customer_profile";
 	public static final String ORDER_QUERY = "order_query";
 	public static final String EVENT_QUERY = "event_query";
 	public static final String PRODUCT_INVENTORY_QUERY = "product_inventory_query";
 	public static final String POINT_QUERY = "point_query";
 	public static final String BUSINESS_REPORT = "business_report";
 	public static final String STORE_DIARY_QUERY = "store_diary_query";
 	public static final String METRIC_DEFINITION = "metric_definition";
 	public static final Set<String> READ_ONLY_TOOLS = java.util.Collections.unmodifiableSet(new LinkedHashSet<>(List.of(
 		STORE_OVERVIEW,
 		CUSTOMER_SEARCH,
 		CUSTOMER_PROFILE,
 		ORDER_QUERY,
 		EVENT_QUERY,
 		PRODUCT_INVENTORY_QUERY,
 		POINT_QUERY,
 		BUSINESS_REPORT,
 		STORE_DIARY_QUERY,
 		METRIC_DEFINITION
 	)));
 	private GaoAiToolNames() {
 	}
 	/// 生成稳定的工具顺序
 	///
 	/// @return 工具名称集合
 	public static Set<String> orderedReadOnlyTools() {
 		return new LinkedHashSet<>(READ_ONLY_TOOLS);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 门店经营报表工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class BusinessReportTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.BUSINESS_REPORT;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店销售趋势、应收、客户复购和产品排行";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.businessReport(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 客户经营档案工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class CustomerProfileTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.CUSTOMER_PROFILE;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店单个客户的套餐、积分、消费和事件档案";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.customerProfile(session, request);
 	}
 }
@@ -0,0 +1,37 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 客户查询工具
 ///
 /// 同时承载客户搜索和客户经营档案查询
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class CustomerTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.CUSTOMER_SEARCH;
 	}
 	@Override
 	public String description() {
 		return "按客户姓名或编码查询当前门店客户摘要";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.customerSearch(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 登记事件查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class EventTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.EVENT_QUERY;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店登记事件记录及事件统计，严格只读";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.eventQuery(session, request);
 	}
 }
@@ -0,0 +1,56 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import java.util.LinkedHashMap;
 import java.util.Map;
 /// GAO 智能体只读工具
 ///
 /// @author Codex
 /// @since 2026-09-15
 public interface GaoAiTool {
 	/// @return 工具名称
 	String name();
 	/// @return 工具描述
 	String description();
 	/// 执行工具查询
 	///
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 脱敏查询结果
 	GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request);
 	/// @return MCP 输入参数结构
 	default Map<String, Object> inputSchema() {
 		Map<String, Object> timeRange = Map.of(
 			"type", "object",
 			"properties", Map.of(
 				"preset", Map.of("type", "string", "enum", new String[]{"TODAY", "LAST_7_DAYS", "LAST_30_DAYS", "THIS_MONTH", "THIS_YEAR", "CUSTOM"}),
 				"startDate", Map.of("type", "string", "description", "自定义开始日期，格式 yyyy-MM-dd"),
 				"endDate", Map.of("type", "string", "description", "自定义结束日期，格式 yyyy-MM-dd")
 			),
 			"additionalProperties", false
 		);
 		Map<String, Object> properties = new LinkedHashMap<>();
 		properties.put("query", Map.of("type", "string", "description", "自然语言关键词"));
 		properties.put("timeRange", timeRange);
 		properties.put("filters", Map.of("type", "object"));
 		properties.put("pageSize", Map.of("type", "integer", "minimum", 1, "maximum", 20));
 		properties.put("cursor", Map.of("type", "string"));
 		properties.put("aiSessionId", Map.of(
 			"type", "string",
 			"description", "由工作流变量注入的 AI 会话 ID，不允许由模型生成"
 		));
 		return Map.of(
 			"type", "object",
 			"properties", properties,
 			"additionalProperties", false
 		);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 指标口径查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class MetricDefinitionTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.METRIC_DEFINITION;
 	}
 	@Override
 	public String description() {
 		return "查询门店经营助手使用的固定指标名称和计算口径";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.metricDefinition(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 订单和资金查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class OrderTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.ORDER_QUERY;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店销售订单、履约和资金摘要，严格只读";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.orderQuery(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 积分查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class PointTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.POINT_QUERY;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店积分账户、积分流水、规则和兑换摘要，严格只读";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.pointQuery(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 产品库存查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class ProductInventoryTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.PRODUCT_INVENTORY_QUERY;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店产品、SKU 和库存余额，严格只读";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.productInventoryQuery(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 门店日记查询工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class StoreDiaryTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.STORE_DIARY_QUERY;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店日记和营业日信息，严格只读";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.storeDiaryQuery(session, request);
 	}
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.mcp.tool;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
 /// 门店经营总览工具
 ///
 /// @author Codex
 /// @since 2026-09-15
@Component
@RequiredArgsConstructor
 public class StoreOverviewTool implements GaoAiTool {
 	private final GaoAiQueryService queryService;
 	@Override
 	public String name() {
 		return GaoAiToolNames.STORE_OVERVIEW;
 	}
 	@Override
 	public String description() {
 		return "查询当前门店指定周期的营业日、销售、应收和库存健康总览";
 	}
 	@Override
 	public GaoAiToolResult execute(GaoAiSession session, GaoAiToolRequest request) {
 		return queryService.storeOverview(session, request);
 	}
 }
@@ -0,0 +1,22 @@
 package com.imyeyu.api.modules.gao.ai.service;
 /// GAO 智能体访问异常
 ///
 /// @author Codex
 /// @since 2026-09-15
 public class GaoAiAccessException extends RuntimeException {
 	private final int status;
 	/// @param message 用户可读消息
 	/// @param status HTTP 状态码
 	public GaoAiAccessException(String message, int status) {
 		super(message);
 		this.status = status;
 	}
 	/// @return HTTP 状态码
 	public int getStatus() {
 		return status;
 	}
 }
@@ -0,0 +1,21 @@
 package com.imyeyu.api.modules.gao.ai.service;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiAuditLog;
 /// GAO 智能体审计服务
 ///
 /// @author Codex
 /// @since 2026-09-15
 public interface GaoAiAuditService {
 	/// 记录脱敏后的 AI 查询审计
 	///
 	/// @param auditLog 审计记录
 	void record(GaoAiAuditLog auditLog);
 	/// 计算问题摘要哈希
 	///
 	/// @param question 问题原文
 	/// @return SHA-256 摘要
 	String digest(String question);
 }
@@ -0,0 +1,37 @@
 package com.imyeyu.api.modules.gao.ai.service;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiChatRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationListRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationReadRequest;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 /// GAO 智能体聊天服务
 ///
 /// @author Codex
 /// @since 2026-09-15
 public interface GaoAiChatService {
 	/// 创建 AI 会话并转发 Dify 流式响应
 	///
 	/// @param request 聊天请求
 	/// @return SSE 发射器
 	SseEmitter chat(GaoAiChatRequest request);
 	/// 列出当前登录用户的历史会话
 	///
 	/// @param request 历史会话分页请求
 	/// @return 历史会话分页结果
 	JsonNode listConversation(GaoAiConversationListRequest request);
 	/// 读取当前登录用户的历史会话消息
 	///
 	/// @param request 历史会话读取请求
 	/// @return 会话消息分页结果
 	JsonNode readConversation(GaoAiConversationReadRequest request);
 	/// 删除当前登录用户的历史会话
 	///
 	/// @param conversationId Dify 会话 ID
 	void deleteConversation(String conversationId);
 }
@@ -0,0 +1,62 @@
 package com.imyeyu.api.modules.gao.ai.service;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 /// GAO 智能体只读查询服务
 ///
 /// @author Codex
 /// @since 2026-09-15
 public interface GaoAiQueryService {
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 门店经营总览
 	GaoAiToolResult storeOverview(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 客户搜索结果
 	GaoAiToolResult customerSearch(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 客户经营档案
 	GaoAiToolResult customerProfile(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 订单查询结果
 	GaoAiToolResult orderQuery(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 事件查询结果
 	GaoAiToolResult eventQuery(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 产品库存查询结果
 	GaoAiToolResult productInventoryQuery(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 积分查询结果
 	GaoAiToolResult pointQuery(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 经营报表结果
 	GaoAiToolResult businessReport(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 门店日记查询结果
 	GaoAiToolResult storeDiaryQuery(GaoAiSession session, GaoAiToolRequest request);
 	/// @param session 已认证 AI 会话
 	/// @param request 工具请求
 	/// @return 指标口径
 	GaoAiToolResult metricDefinition(GaoAiSession session, GaoAiToolRequest request);
 }
@@ -0,0 +1,35 @@
 package com.imyeyu.api.modules.gao.ai.service;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 /// GAO 智能体会话服务
 ///
 /// @author Codex
 /// @since 2026-09-15
 public interface GaoAiSessionService {
 	/// 创建绑定用户和门店的 AI 会话
 	///
 	/// @param userId 用户 ID
 	/// @param storeId 门店 ID
 	/// @param difyConversationId Dify 会话 ID，可为空
 	/// @return AI 会话
 	GaoAiSession create(String userId, String storeId, String difyConversationId);
 	/// 获取有效 AI 会话
 	///
 	/// @param sessionId AI 会话 ID
 	/// @return AI 会话
 	GaoAiSession require(String sessionId);
 	/// 增加工具调用次数
 	///
 	/// @param sessionId AI 会话 ID
 	/// @return 更新后的会话
 	GaoAiSession increaseUsedCount(String sessionId);
 	/// 删除 AI 会话
 	///
 	/// @param sessionId AI 会话 ID
 	void delete(String sessionId);
 }
@@ -0,0 +1,22 @@
 package com.imyeyu.api.modules.gao.ai.service;
 /// GAO 智能体工具请求异常
 ///
 /// @author Codex
 /// @since 2026-09-15
 public class GaoAiToolException extends RuntimeException {
 	private final int status;
 	/// @param message 异常消息
 	/// @param status HTTP 状态码
 	public GaoAiToolException(String message, int status) {
 		super(message);
 		this.status = status;
 	}
 	/// @return HTTP 状态码
 	public int getStatus() {
 		return status;
 	}
 }
@@ -0,0 +1,78 @@
 package com.imyeyu.api.modules.gao.ai.service.implement;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiAuditLog;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiAuditService;
 import com.imyeyu.api.modules.system.entity.Logger;
 import com.imyeyu.api.modules.system.service.LoggerService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.LinkedHashMap;
 import java.util.Map;
 /// GAO 智能体审计服务实现
 ///
 /// @author Codex
 /// @since 2026-09-15
@Slf4j
@Service
@RequiredArgsConstructor
 public class GaoAiAuditServiceImplement implements GaoAiAuditService {
 	private final ObjectMapper jackson;
 	private final LoggerService loggerService;
 	@Override
 	public void record(GaoAiAuditLog auditLog) {
 		if (auditLog == null) {
 			return;
 		}
 		Map<String, Object> content = new LinkedHashMap<>();
 		content.put("storeId", auditLog.getStoreId());
 		content.put("questionDigest", auditLog.getQuestionDigest());
 		content.put("conversationId", auditLog.getConversationId());
 		content.put("toolName", auditLog.getToolName());
 		content.put("duration", auditLog.getDuration());
 		content.put("status", auditLog.getStatus());
 		content.put("resultCount", auditLog.getResultCount());
 		content.put("createdAt", auditLog.getCreatedAt());
 		try {
 			Logger logger = new Logger(Logger.Module.GAO, auditLevel(auditLog.getStatus()), "GAO_AI_QUERY");
 			logger.setUserId(auditLog.getUserId());
 			logger.setContent(jackson.writeValueAsString(content));
 			logger.setResult(auditLog.getStatus());
 			logger.setDuration((int) Math.min(Integer.MAX_VALUE, Math.max(0L, auditLog.getDuration())));
 			loggerService.create(logger);
 		} catch (JsonProcessingException | RuntimeException e) {
 			log.warn("写入 GAO 智能体审计日志失败", e);
 		}
 	}
 	/// 计算问题摘要哈希
 	///
 	/// @param question 问题原文
 	/// @return SHA-256 摘要
 	public String digest(String question) {
 		try {
 			byte[] bytes = MessageDigest.getInstance("SHA-256").digest(
 				(question == null ? "" : question).getBytes(StandardCharsets.UTF_8));
 			StringBuilder result = new StringBuilder(bytes.length * 2);
 			for (byte value : bytes) {
 				result.append("%02x".formatted(value & 0xff));
 			}
 			return result.toString();
 		} catch (NoSuchAlgorithmException e) {
 			throw new IllegalStateException("当前 JDK 不支持 SHA-256", e);
 		}
 	}
 	private Logger.Level auditLevel(String status) {
 		return "SUCCESS".equals(status) ? Logger.Level.INFO : Logger.Level.WARN;
 	}
 }
@@ -0,0 +1,753 @@
 package com.imyeyu.api.modules.gao.ai.service.implement;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.imyeyu.api.bean.ModuleCode;
 import com.imyeyu.api.modules.common.service.SettingService;
 import com.imyeyu.api.modules.gao.ai.config.GaoAiProperties;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiAuditLog;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiAccessException;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiAuditService;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiChatService;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiSessionService;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiChatRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationListRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiConversationReadRequest;
 import com.imyeyu.api.modules.gao.bean.GaoRoleCode;
 import com.imyeyu.api.modules.gao.bean.GaoSystemSetting;
 import com.imyeyu.api.modules.gao.entity.GaoStore;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.service.GaoStoreService;
 import com.imyeyu.api.modules.system.bean.DifySetting;
 import com.imyeyu.api.modules.user.entity.User;
 import com.imyeyu.api.modules.user.service.RoleChecker;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.URI;
 import java.net.URLEncoder;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 /// GAO 智能体聊天服务实现
 ///
 /// 使用 JDK HttpClient 读取 Dify SSE，再通过 Spring MVC SseEmitter 输出给前端
 ///
 /// @author Codex
 /// @since 2026-09-15
@Slf4j
@Service
@RequiredArgsConstructor
 public class GaoAiChatServiceImplement implements GaoAiChatService {
 	private static final ZoneId ZONE = ZoneId.systemDefault();
 	private final ObjectMapper jackson;
 	private final GaoAiProperties properties;
 	private final UserLoginService userLoginService;
 	private final RoleChecker roleChecker;
 	private final GaoStoreScopeService storeScopeService;
 	private final GaoStoreService storeService;
 	private final GaoAiSessionService sessionService;
 	private final GaoAiAuditService auditService;
 	private final SettingService settingService;
 	private HttpClient httpClient;
 	private ExecutorService streamExecutor;
 	private ScheduledExecutorService timeoutExecutor;
 	@PostConstruct
 	private void postConstruct() {
 		this.streamExecutor = Executors.newVirtualThreadPerTaskExecutor();
 		this.timeoutExecutor = Executors.newSingleThreadScheduledExecutor(Thread.ofVirtual().factory());
 		this.httpClient = HttpClient.newBuilder()
 		                            .connectTimeout(Duration.ofSeconds(positive(properties.getConnectTimeoutSeconds(), 10L)))
 		                            .executor(streamExecutor)
 		                            .version(HttpClient.Version.HTTP_1_1)
 		                            .build();
 	}
 	@Override
 	public SseEmitter chat(GaoAiChatRequest request) {
 		if (request == null || isBlank(request.getMessage())) {
 			throw new GaoAiAccessException("问题不能为空", 400);
 		}
 		String message = request.getMessage().trim();
 		if (256 < message.length()) {
 			throw new GaoAiAccessException("问题长度不能超过 256 个字符", 400);
 		}
 		if (request.getConversationId() != null && 128 < request.getConversationId().length()) {
 			throw new GaoAiAccessException("会话 ID 无效", 400);
 		}
 		User user = requireAiUser();
 		String storeId;
 		try {
 			storeId = storeScopeService.resolveStoreId(request.getStoreId());
 		} catch (RuntimeException e) {
 			throw new GaoAiAccessException("当前账号没有可用的所属门店", 403);
 		}
 		GaoStore store = storeId == null ? null : storeService.get(storeId);
 		if (store == null || !store.isActivated()) {
 			throw new GaoAiAccessException("当前账号没有可用的所属门店", 403);
 		}
 		GaoAiSession session = sessionService.create(user.getId(), storeId, request.getConversationId());
 		return stream(session, message);
 	}
 	@Override
 	public JsonNode listConversation(GaoAiConversationListRequest request) {
 		User user = requireAiUser();
 		String lastId = optionalValue(request == null ? null : request.getLastId(), "上一页游标", 128);
 		int limit = normalizeLimit(request == null ? null : request.getLimit());
 		String sortBy = normalizeSortBy(request == null ? null : request.getSortBy());
 		StringBuilder url = new StringBuilder("/conversations");
 		appendQueryParameter(url, "user", difyUser(user));
 		appendQueryParameter(url, "last_id", lastId);
 		appendQueryParameter(url, "limit", String.valueOf(limit));
 		appendQueryParameter(url, "sort_by", sortBy);
 		return sanitizeConversationList(parseJson(sendDify(newDifyRequest(url.toString()).GET().build(), "查询历史会话")));
 	}
 	@Override
 	public JsonNode readConversation(GaoAiConversationReadRequest request) {
 		User user = requireAiUser();
 		if (request == null) {
 			throw new GaoAiAccessException("会话读取参数不能为空", 400);
 		}
 		String conversationId = requiredValue(request.getConversationId(), "会话 ID", 128);
 		String firstId = optionalValue(request.getFirstId(), "上一页游标", 128);
 		int limit = normalizeLimit(request.getLimit());
 		StringBuilder url = new StringBuilder("/messages");
 		appendQueryParameter(url, "user", difyUser(user));
 		appendQueryParameter(url, "conversation_id", conversationId);
 		appendQueryParameter(url, "first_id", firstId);
 		appendQueryParameter(url, "limit", String.valueOf(limit));
 		return sanitizeConversationMessages(parseJson(sendDify(newDifyRequest(url.toString()).GET().build(), "读取历史会话")));
 	}
 	@Override
 	public void deleteConversation(String conversationId) {
 		User user = requireAiUser();
 		String value = requiredValue(conversationId, "会话 ID", 128);
 		ObjectNode body = jackson.createObjectNode();
 		body.put("user", difyUser(user));
 		HttpRequest request = newDifyRequest("/conversations/" + encodePathSegment(value))
 			.method("DELETE", HttpRequest.BodyPublishers.ofString(writeJson(body), StandardCharsets.UTF_8))
 			.header("Content-Type", "application/json")
 			.build();
 		sendDify(request, "删除历史会话");
 	}
 	private SseEmitter stream(GaoAiSession session, String message) {
 		long readTimeoutSeconds = positive(properties.getReadTimeoutSeconds(), 600L);
 		long emitterTimeout = Math.min(Long.MAX_VALUE - 1L, readTimeoutSeconds * 1000L + 30_000L);
 		SseEmitter emitter = new SseEmitter(emitterTimeout);
 		AtomicBoolean finished = new AtomicBoolean();
 		AtomicBoolean auditRecorded = new AtomicBoolean();
 		AtomicReference<String> status = new AtomicReference<>("CANCELLED");
 		AtomicReference<CompletableFuture<HttpResponse<InputStream>>> upstreamRef = new AtomicReference<>();
 		AtomicReference<ScheduledFuture<?>> timeoutRef = new AtomicReference<>();
 		long startedAt = System.currentTimeMillis();
 		Runnable cancel = () -> {
 			status.compareAndSet("CANCELLED", "CANCELLED");
 			finished.set(true);
 			CompletableFuture<HttpResponse<InputStream>> upstream = upstreamRef.get();
 			if (upstream != null) {
 				upstream.cancel(true);
 			}
 			cancelTimeout(timeoutRef);
 			recordAudit(session, message, status.get(), startedAt, auditRecorded);
 		};
 		emitter.onCompletion(cancel);
 		emitter.onTimeout(cancel);
 		emitter.onError(error -> cancel.run());
 		try {
 			HttpRequest httpRequest = buildRequest(session, message, readTimeoutSeconds);
 			CompletableFuture<HttpResponse<InputStream>> upstream = httpClient.sendAsync(httpRequest, HttpResponse.BodyHandlers.ofInputStream());
 			upstreamRef.set(upstream);
 			if (finished.get()) {
 				upstream.cancel(true);
 				return emitter;
 			}
 			touchTimeout(timeoutRef, readTimeoutSeconds, () -> timeout(emitter, finished, upstreamRef, timeoutRef, status, auditRecorded, session, message, startedAt));
 			upstream.thenAcceptAsync(response -> readResponse(response, emitter, finished, upstreamRef, timeoutRef,
 				status, auditRecorded, session, message, startedAt, readTimeoutSeconds), streamExecutor)
 				.exceptionally(error -> {
 					if (!finished.get()) {
 						logStreamError("异步请求", session, error);
 						status.set("ERROR");
 						emitError(emitter, "DIFY_UNAVAILABLE", "智能体服务暂时不可用，请稍后重试");
 						safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 					}
 					return null;
 				});
 		} catch (RuntimeException e) {
 			logStreamError("创建请求", session, e);
 			status.set("ERROR");
 			emitError(emitter, "DIFY_REQUEST_ERROR", "智能体服务暂时不可用，请稍后重试");
 			safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 		}
 		return emitter;
 	}
 	private HttpRequest buildRequest(GaoAiSession session, String message, long readTimeoutSeconds) {
 		ObjectNode body = jackson.createObjectNode();
 		body.put("query", message);
 		body.put("response_mode", "streaming");
 		body.put("user", "gao-store-manager:" + session.getUserId());
 		if (!isBlank(session.getDifyConversationId())) {
 			body.put("conversation_id", session.getDifyConversationId());
 		}
 		ObjectNode inputs = body.putObject("inputs");
 		inputs.put("query", message);
 		inputs.put("aiSessionId", session.getSessionId());
 		GaoStore store = storeService.get(session.getStoreId());
 		inputs.put("storeName", store == null ? "当前门店" : store.getName());
 		inputs.put("today", LocalDate.now(ZONE).toString());
 		return newDifyRequest("/chat-messages")
 		                  .timeout(Duration.ofSeconds(readTimeoutSeconds))
 		                  .header("X-Timi-AI-Session", session.getSessionId())
 		                  .header("Content-Type", "application/json")
 		                  .setHeader("Accept", "text/event-stream")
 		                  .POST(HttpRequest.BodyPublishers.ofString(writeJson(body), StandardCharsets.UTF_8))
 		                  .build();
 	}
 	/// 获取当前登录且有权使用智能体的用户
 	///
 	/// @return 当前登录用户
 	private User requireAiUser() {
 		User user = userLoginService.getLoginUser();
 		if (user == null) {
 			throw new GaoAiAccessException("登录已过期，请重新登录", 401);
 		}
 		if (!roleChecker.hasAny(ModuleCode.GAO, GaoRoleCode.STORE_MANAGER.name())) {
 			throw new GaoAiAccessException("当前账号无权使用门店智能助手", 403);
 		}
 		return user;
 	}
 	/// 创建 Dify API 请求
 	///
 	/// @param path Dify API 路径，可包含已编码的查询参数
 	/// @return Dify API 请求构造器
 	private HttpRequest.Builder newDifyRequest(String path) {
 		String appApiKey = settingService.getSystem(GaoSystemSetting.DIFY_APP_API_KEY).asString();
 		if (isBlank(appApiKey)) {
 			throw new GaoAiAccessException("智能体服务未配置", 503);
 		}
 		return HttpRequest.newBuilder(difyUri(path))
 		                  .timeout(Duration.ofSeconds(Math.min(60L, positive(properties.getReadTimeoutSeconds(), 600L))))
 		                  .header("Authorization", "Bearer " + appApiKey)
 		                  .header("Accept", "application/json");
 	}
 	/// 调用 Dify API
 	///
 	/// @param request Dify API 请求
 	/// @param operation 操作名称
 	/// @return Dify 响应正文
 	private String sendDify(HttpRequest request, String operation) {
 		HttpResponse<String> response;
 		try {
 			response = httpClient.send(request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
 		} catch (InterruptedException e) {
 			Thread.currentThread().interrupt();
 			throw new GaoAiAccessException("智能体服务请求被中断", 503);
 		} catch (IOException | RuntimeException e) {
 			log.warn("{}失败", operation, e);
 			throw new GaoAiAccessException("智能体服务暂时不可用，请稍后重试", 503);
 		}
 		if (response.statusCode() < 200 || 299 < response.statusCode()) {
 			log.warn("{}失败：statusCode={}", operation, response.statusCode());
 			int status = response.statusCode() == 404 ? 404 : 503;
 			String message = status == 404 ? "历史会话不存在" : "智能体服务暂时不可用，请稍后重试";
 			throw new GaoAiAccessException(message, status);
 		}
 		return response.body();
 	}
 	/// 解析 Dify JSON 响应
 	///
 	/// @param responseBody 响应正文
 	/// @return JSON 节点
 	private JsonNode parseJson(String responseBody) {
 		try {
 			return jackson.readTree(responseBody);
 		} catch (IOException | RuntimeException e) {
 			log.warn("解析智能体历史会话响应失败", e);
 			throw new GaoAiAccessException("智能体服务返回数据无效", 503);
 		}
 	}
 	/// 过滤会话列表中的 Dify 内部字段
 	///
 	/// @param response Dify 响应
 	/// @return 脱敏后的响应
 	private JsonNode sanitizeConversationList(JsonNode response) {
 		if (response == null || !response.isObject()) {
 			return response;
 		}
 		ObjectNode result = jackson.createObjectNode();
 		copyFields(response, result, "has_more", "limit");
 		ArrayNode data = result.putArray("data");
 		for (JsonNode item : response.path("data")) {
 			if (!item.isObject()) {
 				continue;
 			}
 			ObjectNode conversation = data.addObject();
 			copyFields(item, conversation, "id", "name", "status", "introduction", "created_at", "updated_at");
 		}
 		return result;
 	}
 	/// 过滤会话消息中的 Dify 内部字段
 	///
 	/// @param response Dify 响应
 	/// @return 脱敏后的响应
 	private JsonNode sanitizeConversationMessages(JsonNode response) {
 		if (response == null || !response.isObject()) {
 			return response;
 		}
 		ObjectNode result = jackson.createObjectNode();
 		copyFields(response, result, "has_more", "limit");
 		ArrayNode data = result.putArray("data");
 		for (JsonNode item : response.path("data")) {
 			if (!item.isObject()) {
 				continue;
 			}
 			ObjectNode message = data.addObject();
 			copyFields(item, message, "id", "conversation_id", "query", "answer", "created_at", "status", "feedback");
 		}
 		return result;
 	}
 	/// 复制指定的 JSON 字段
 	///
 	/// @param source 源 JSON 对象
 	/// @param target 目标 JSON 对象
 	/// @param fieldNames 字段名称
 	/// @return 无
 	private void copyFields(JsonNode source, ObjectNode target, String... fieldNames) {
 		for (String fieldName : fieldNames) {
 			if (source.has(fieldName)) {
 				target.set(fieldName, source.get(fieldName));
 			}
 		}
 	}
 	/// 生成 Dify 用户标识
 	///
 	/// @param user 登录用户
 	/// @return Dify 用户标识
 	private String difyUser(User user) {
 		return "gao-store-manager:" + user.getId();
 	}
 	/// 添加 URL 查询参数
 	///
 	/// @param url URL 构造器
 	/// @param name 参数名称
 	/// @param value 参数值
 	/// @return 无
 	private void appendQueryParameter(StringBuilder url, String name, String value) {
 		if (isBlank(value)) {
 			return;
 		}
 		url.append(url.indexOf("?") < 0 ? '?' : '&')
 		   .append(name)
 		   .append('=')
 		   .append(URLEncoder.encode(value, StandardCharsets.UTF_8));
 	}
 	/// 生成 Dify API URI
 	///
 	/// @param path Dify API 路径
 	/// @return Dify API URI
 	private URI difyUri(String path) {
 		String baseUrl = settingService.getSystem(DifySetting.BASE_URL).asString();
 		if (isBlank(baseUrl)) {
 			throw new GaoAiAccessException("智能体服务未配置", 503);
 		}
 		String normalizedBaseUrl = baseUrl.trim();
 		while (normalizedBaseUrl.endsWith("/")) {
 			normalizedBaseUrl = normalizedBaseUrl.substring(0, normalizedBaseUrl.length() - 1);
 		}
 		try {
 			URI uri = URI.create(normalizedBaseUrl + (path.startsWith("/") ? path : "/" + path));
 			if (!uri.isAbsolute() || isBlank(uri.getScheme()) || isBlank(uri.getHost())) {
 				throw new IllegalArgumentException("Dify 地址必须是绝对 HTTP 地址");
 			}
 			return uri;
 		} catch (IllegalArgumentException e) {
 			throw new GaoAiAccessException("智能体服务配置无效", 503);
 		}
 	}
 	/// 编码 URL 路径片段
 	///
 	/// @param value 路径片段
 	/// @return 编码后的路径片段
 	private String encodePathSegment(String value) {
 		return URLEncoder.encode(value, StandardCharsets.UTF_8).replace("+", "%20");
 	}
 	/// 标准化分页条数
 	///
 	/// @param limit 请求的分页条数
 	/// @return 标准化后的分页条数
 	private int normalizeLimit(Integer limit) {
 		int value = limit == null ? 20 : limit;
 		if (!(0 < value) || 100 < value) {
 			throw new GaoAiAccessException("分页条数必须在 1 至 100 之间", 400);
 		}
 		return value;
 	}
 	/// 标准化会话排序方式
 	///
 	/// @param sortBy 请求的排序方式
 	/// @return 标准化后的排序方式
 	private String normalizeSortBy(String sortBy) {
 		String value = isBlank(sortBy) ? "-updated_at" : sortBy.trim();
 		if (!"created_at".equals(value) && !"-created_at".equals(value)
 			&& !"updated_at".equals(value) && !"-updated_at".equals(value)) {
 			throw new GaoAiAccessException("会话排序方式无效", 400);
 		}
 		return value;
 	}
 	/// 校验必填文本参数
 	///
 	/// @param value 参数值
 	/// @param name 参数名称
 	/// @param maxLength 最大长度
 	/// @return 去除首尾空白后的参数值
 	private String requiredValue(String value, String name, int maxLength) {
 		String result = optionalValue(value, name, maxLength);
 		if (result == null) {
 			throw new GaoAiAccessException(name + "不能为空", 400);
 		}
 		return result;
 	}
 	/// 校验可选文本参数
 	///
 	/// @param value 参数值
 	/// @param name 参数名称
 	/// @param maxLength 最大长度
 	/// @return 去除首尾空白后的参数值，无值时返回 null
 	private String optionalValue(String value, String name, int maxLength) {
 		if (isBlank(value)) {
 			return null;
 		}
 		String result = value.trim();
 		if (maxLength < result.length()) {
 			throw new GaoAiAccessException(name + "无效", 400);
 		}
 		return result;
 	}
 	private void readResponse(HttpResponse<InputStream> response, SseEmitter emitter, AtomicBoolean finished,
 		AtomicReference<CompletableFuture<HttpResponse<InputStream>>> upstreamRef, AtomicReference<ScheduledFuture<?>> timeoutRef,
 		AtomicReference<String> status, AtomicBoolean auditRecorded, GaoAiSession session, String message, long startedAt,
 		long readTimeoutSeconds) {
 		try (InputStream stream = response.body()) {
 			if (response.statusCode() < 200 || 299 < response.statusCode()) {
 				String responseBody = readErrorResponseBody(stream);
 				log.error("GAO 智能体返回异常状态：statusCode={}, sessionId={}, userId={}, storeId={}",
 					response.statusCode(), session.getSessionId(), session.getUserId(), session.getStoreId());
 				log.error("GAO 智能体错误响应体：sessionId={}, responseBody={}", session.getSessionId(), responseBody);
 				status.set("ERROR");
 				emitError(emitter, "DIFY_HTTP_ERROR", "智能体服务暂时不可用，请稍后重试");
 				safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 				return;
 			}
 			AtomicReference<String> sseEvent = new AtomicReference<>();
 			StringBuilder data = new StringBuilder();
 			try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
 				String line;
 				while (!finished.get() && (line = reader.readLine()) != null) {
 					touchTimeout(timeoutRef, positive(properties.getReadTimeoutSeconds(), 600L),
 						() -> timeout(emitter, finished, upstreamRef, timeoutRef, status, auditRecorded, session, message, startedAt));
 					if (line.startsWith("event:")) {
 						sseEvent.set(line.substring(6).trim());
 					} else if (line.startsWith("data:")) {
 						if (!data.isEmpty()) {
 							data.append('\n');
 						}
 						String dataLine = line.substring(5);
 						data.append(dataLine.startsWith(" ") ? dataLine.substring(1) : dataLine);
 					} else if (line.isEmpty() && !data.isEmpty()) {
 						processData(data.toString(), sseEvent.get(), emitter, status, finished, timeoutRef, auditRecorded,
 							session, message, startedAt);
 						data.setLength(0);
 						sseEvent.set(null);
 					}
 				}
 				if (!finished.get() && !data.isEmpty()) {
 					processData(data.toString(), sseEvent.get(), emitter, status, finished, timeoutRef, auditRecorded,
 						session, message, startedAt);
 				}
 			}
 			if (!finished.get()) {
 				status.compareAndSet("CANCELLED", "SUCCESS");
 				emitDone(emitter, session, startedAt, finished, timeoutRef, auditRecorded, message, status);
 			}
 		} catch (IOException | RuntimeException e) {
 			if (!finished.get()) {
 				logStreamError("读取响应", session, e);
 				status.set("ERROR");
 				emitError(emitter, "DIFY_STREAM_ERROR", "智能体连接中断，请重试");
 				safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 			}
 		}
 	}
 	/// 读取并压缩 Dify 错误响应体
 	///
 	/// @param stream Dify 响应流
 	/// @return 错误响应内容
 	/// @throws IOException 读取响应体失败
 	private String readErrorResponseBody(InputStream stream) throws IOException {
 		int maxLength = 8192;
 		byte[] bytes = stream.readNBytes(maxLength);
 		String body = new String(bytes, StandardCharsets.UTF_8)
 			.replace('\r', ' ')
 			.replace('\n', ' ')
 			.replace('\t', ' ')
 			.trim();
 		return maxLength <= bytes.length ? body + "..." : body;
 	}
 	private void processData(String rawData, String sseEvent, SseEmitter emitter, AtomicReference<String> status,
 		AtomicBoolean finished, AtomicReference<ScheduledFuture<?>> timeoutRef, AtomicBoolean auditRecorded,
 		GaoAiSession session, String message, long startedAt) {
 		if ("[DONE]".equals(rawData)) {
 			return;
 		}
 		JsonNode payload;
 		try {
 			payload = jackson.readTree(rawData);
 		} catch (IOException e) {
 			log.error("GAO 智能体 SSE 数据解析失败：sessionId={}, userId={}, storeId={}, dataLength={}",
 				session.getSessionId(), session.getUserId(), session.getStoreId(), rawData.length(), e);
 			return;
 		}
 		String event = firstText(text(payload, "event", null), sseEvent, "message");
 		String conversationId = firstText(text(payload, "conversation_id", null), text(payload, "conversationId", null));
 		if (conversationId != null) {
 			session.setDifyConversationId(conversationId);
 		}
 		switch (event) {
 			case "message", "agent_message", "text_chunk" -> {
 				String answer = firstRawText(payload, "answer");
 				if (answer == null) {
 					answer = firstRawText(payload, "text");
 				}
 				if (answer != null && !answer.isEmpty()) {
 					Map<String, String> messageData = Map.of("answer", answer);
 					safeSend(emitter, SseEmitter.event().name("message").data(messageData), finished);
 				}
 			}
 			case "message_end" -> emitDone(emitter, session, startedAt, finished, timeoutRef, auditRecorded, message, status);
 			case "node_started", "node_finished", "workflow_started", "workflow_finished" -> {
 				Map<String, Object> data = new LinkedHashMap<>();
 				data.put("tool", "实时数据查询");
 				data.put("status", event.endsWith("finished") ? "finished" : "started");
 				safeSend(emitter, SseEmitter.event().name("tool_status").data(data), finished);
 			}
 			case "message_file", "retriever_resources" -> {
 				Map<String, Object> data = new LinkedHashMap<>();
 				data.put("source", "实时业务数据或业务知识库");
 				safeSend(emitter, SseEmitter.event().name("citation").data(data), finished);
 			}
 			case "error" -> {
 				status.set("ERROR");
 				emitError(emitter, "DIFY_ERROR", "智能体查询失败，请稍后重试");
 				safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 			}
 			default -> {
 				// 未识别的 Dify 事件不透传原始内容，避免泄露内部节点和参数
 			}
 		}
 	}
 	private void emitDone(SseEmitter emitter, GaoAiSession session, long startedAt, AtomicBoolean finished,
 		AtomicReference<ScheduledFuture<?>> timeoutRef, AtomicBoolean auditRecorded, String message,
 		AtomicReference<String> status) {
 		if (finished.get()) {
 			return;
 		}
 		Map<String, Object> data = new LinkedHashMap<>();
 		data.put("conversationId", session.getDifyConversationId());
 		data.put("duration", Math.max(0L, System.currentTimeMillis() - startedAt));
 		safeSend(emitter, SseEmitter.event().name("done").data(data), finished);
 		status.compareAndSet("CANCELLED", "SUCCESS");
 		safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 	}
 	private void emitError(SseEmitter emitter, String code, String message) {
 		Map<String, Object> data = new LinkedHashMap<>();
 		data.put("code", code);
 		data.put("message", message);
 		try {
 			emitter.send(SseEmitter.event().name("error").data(data));
 		} catch (IOException | IllegalStateException ignored) {
 			// 浏览器已断开时无需再次写入
 		}
 	}
 	private boolean safeSend(SseEmitter emitter, SseEmitter.SseEventBuilder event, AtomicBoolean finished) {
 		if (finished.get()) {
 			return false;
 		}
 		try {
 			emitter.send(event);
 			return true;
 		} catch (IOException | IllegalStateException e) {
 			finished.set(true);
 			return false;
 		}
 	}
 	private void safeComplete(SseEmitter emitter, AtomicBoolean finished, AtomicReference<ScheduledFuture<?>> timeoutRef,
 		AtomicBoolean auditRecorded, GaoAiSession session, String message, long startedAt, AtomicReference<String> status) {
 		if (!finished.compareAndSet(false, true)) {
 			return;
 		}
 		cancelTimeout(timeoutRef);
 		recordAudit(session, message, status.get(), startedAt, auditRecorded);
 		try {
 			emitter.complete();
 		} catch (RuntimeException ignored) {
 			// SSE 已经关闭
 		}
 	}
 	private void timeout(SseEmitter emitter, AtomicBoolean finished,
 		AtomicReference<CompletableFuture<HttpResponse<InputStream>>> upstreamRef,
 		AtomicReference<ScheduledFuture<?>> timeoutRef, AtomicReference<String> status,
 		AtomicBoolean auditRecorded, GaoAiSession session, String message, long startedAt) {
 		if (finished.get()) {
 			return;
 		}
 		status.set("TIMEOUT");
 		CompletableFuture<HttpResponse<InputStream>> upstream = upstreamRef.get();
 		if (upstream != null) {
 			upstream.cancel(true);
 		}
 		emitError(emitter, "DIFY_TIMEOUT", "数据查询超时，请缩小时间范围后重试");
 		safeComplete(emitter, finished, timeoutRef, auditRecorded, session, message, startedAt, status);
 	}
 	private void touchTimeout(AtomicReference<ScheduledFuture<?>> timeoutRef, long seconds, Runnable action) {
 		ScheduledFuture<?> old = timeoutRef.getAndSet(timeoutExecutor.schedule(action, seconds, TimeUnit.SECONDS));
 		if (old != null) {
 			old.cancel(false);
 		}
 	}
 	private void cancelTimeout(AtomicReference<ScheduledFuture<?>> timeoutRef) {
 		ScheduledFuture<?> timeout = timeoutRef.getAndSet(null);
 		if (timeout != null) {
 			timeout.cancel(false);
 		}
 	}
 	private void recordAudit(GaoAiSession session, String message, String status, long startedAt, AtomicBoolean recorded) {
 		if (!recorded.compareAndSet(false, true)) {
 			return;
 		}
 		GaoAiAuditLog audit = new GaoAiAuditLog();
 		audit.setUserId(session.getUserId());
 		audit.setStoreId(session.getStoreId());
 		audit.setQuestionDigest(auditService.digest(message));
 		audit.setConversationId(session.getDifyConversationId());
 		audit.setToolName("dify_chatflow");
 		audit.setDuration(Math.max(0L, System.currentTimeMillis() - startedAt));
 		audit.setStatus(status);
 		audit.setResultCount(0L);
 		audit.setCreatedAt(System.currentTimeMillis());
 		auditService.record(audit);
 	}
 	/// 记录智能体流式请求异常
 	///
 	/// @param phase 异常阶段
 	/// @param session 智能体会话
 	/// @param error 异常
 	/// @return 无
 	private void logStreamError(String phase, GaoAiSession session, Throwable error) {
 		log.error("GAO 智能体流式请求异常：phase={}, sessionId={}, userId={}, storeId={}",
 			phase, session.getSessionId(), session.getUserId(), session.getStoreId(), error);
 	}
 	private String writeJson(ObjectNode body) {
 		try {
 			return jackson.writeValueAsString(body);
 		} catch (IOException e) {
 			throw new IllegalStateException("无法生成 Dify 请求", e);
 		}
 	}
 	private String text(JsonNode node, String field, String fallback) {
 		if (node != null && node.hasNonNull(field)) {
 			String value = node.get(field).asText();
 			return isBlank(value) ? fallback : value;
 		}
 		return fallback;
 	}
 	private String firstRawText(JsonNode node, String field) {
 		if (node != null && node.hasNonNull(field)) {
 			return node.get(field).asText();
 		}
 		return null;
 	}
 	private String firstText(String... values) {
 		for (String value : values) {
 			if (!isBlank(value)) {
 				return value;
 			}
 		}
 		return null;
 	}
 	private long positive(long value, long fallback) {
 		return 0 < value ? value : fallback;
 	}
 	private boolean isBlank(String value) {
 		return value == null || value.trim().isEmpty();
 	}
 }
@@ -0,0 +1,783 @@
 package com.imyeyu.api.modules.gao.ai.service.implement;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.imyeyu.api.modules.common.entity.Article;
 import com.imyeyu.api.modules.gao.ai.config.GaoAiProperties;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiQueryService;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiToolException;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolRequest;
 import com.imyeyu.api.modules.gao.ai.vo.GaoAiToolResult;
 import com.imyeyu.api.modules.gao.entity.GaoCustomer;
 import com.imyeyu.api.modules.gao.entity.GaoCustomerConsumptionRecord;
 import com.imyeyu.api.modules.gao.entity.GaoCustomerPackage;
 import com.imyeyu.api.modules.gao.entity.GaoEvent;
 import com.imyeyu.api.modules.gao.entity.GaoEventRecord;
 import com.imyeyu.api.modules.gao.entity.GaoFundRecord;
 import com.imyeyu.api.modules.gao.entity.GaoPointAccount;
 import com.imyeyu.api.modules.gao.entity.GaoPointLedger;
 import com.imyeyu.api.modules.gao.entity.GaoProductStock;
 import com.imyeyu.api.modules.gao.entity.GaoSalesOrder;
 import com.imyeyu.api.modules.gao.entity.GaoStore;
 import com.imyeyu.api.modules.gao.entity.GaoStoreBusinessDay;
 import com.imyeyu.api.modules.gao.service.GaoCustomerConsumptionRecordService;
 import com.imyeyu.api.modules.gao.service.GaoCustomerPackageService;
 import com.imyeyu.api.modules.gao.service.GaoCustomerService;
 import com.imyeyu.api.modules.gao.service.GaoEventRecordService;
 import com.imyeyu.api.modules.gao.service.GaoEventService;
 import com.imyeyu.api.modules.gao.service.GaoFundRecordService;
 import com.imyeyu.api.modules.gao.service.GaoPointAccountService;
 import com.imyeyu.api.modules.gao.service.GaoPointLedgerService;
 import com.imyeyu.api.modules.gao.service.GaoPointRedemptionService;
 import com.imyeyu.api.modules.gao.service.GaoPointRuleService;
 import com.imyeyu.api.modules.gao.service.GaoProductChartService;
 import com.imyeyu.api.modules.gao.service.GaoProductStockService;
 import com.imyeyu.api.modules.gao.service.GaoSalesOrderChartService;
 import com.imyeyu.api.modules.gao.service.GaoSalesOrderService;
 import com.imyeyu.api.modules.gao.service.GaoStoreBusinessDayService;
 import com.imyeyu.api.modules.gao.service.GaoStoreDiaryService;
 import com.imyeyu.api.modules.gao.service.GaoStoreService;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerPage;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerPackagePage;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordPage;
 import com.imyeyu.api.modules.gao.vo.GaoFundRecordPage;
 import com.imyeyu.api.modules.gao.vo.GaoPointLedgerPage;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionPage;
 import com.imyeyu.api.modules.gao.vo.GaoProductChartReq;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockPage;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderChartReq;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
 import com.imyeyu.api.modules.gao.vo.GaoStoreDiaryPage;
 import com.imyeyu.spring.bean.PageResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 /// GAO 智能体只读查询服务实现
 ///
 /// 所有查询都将会话中的门店 ID 写入既有查询请求，不接受工具参数中的门店范围
 ///
 /// @author Codex
 /// @since 2026-09-15
@Service
@RequiredArgsConstructor
 public class GaoAiQueryServiceImplement implements GaoAiQueryService {
 	private static final ZoneId ZONE = ZoneId.systemDefault();
 	private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE;
 	private static final DateTimeFormatter DAY_VALUE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
 	private static final Set<String> SENSITIVE_KEYS = Set.of(
 		"id",
 		"storeId",
 		"userId",
 		"customerId",
 		"operatorUserId",
 		"verifierUserId",
 		"creatorUserId",
 		"updatedBy",
 		"cancelOperatorUserId",
 		"sourcePayload",
 		"attachmentList",
 		"skuSpecSnapshot",
 		"password",
 		"token",
 		"apiKey",
 		"phone",
 		"mobile",
 		"telephone",
 		"email",
 		"address"
 	);
 	private final ObjectMapper jackson;
 	private final GaoAiProperties properties;
 	private final GaoStoreService storeService;
 	private final GaoStoreBusinessDayService businessDayService;
 	private final GaoCustomerService customerService;
 	private final GaoCustomerPackageService customerPackageService;
 	private final GaoCustomerConsumptionRecordService consumptionRecordService;
 	private final GaoEventService eventService;
 	private final GaoEventRecordService eventRecordService;
 	private final GaoSalesOrderService salesOrderService;
 	private final GaoSalesOrderChartService salesOrderChartService;
 	private final GaoFundRecordService fundRecordService;
 	private final GaoProductStockService stockService;
 	private final GaoProductChartService productChartService;
 	private final GaoPointAccountService pointAccountService;
 	private final GaoPointLedgerService pointLedgerService;
 	private final GaoPointRuleService pointRuleService;
 	private final GaoPointRedemptionService redemptionService;
 	private final GaoStoreDiaryService storeDiaryService;
 	@Override
 	public GaoAiToolResult storeOverview(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoStore store = requireStore(session);
 		GaoSalesOrderChartReq salesRequest = salesChartRequest(session, window, request);
 		List<?> daily = salesOrderChartService.daily(salesRequest);
 		Object receivable = salesOrderChartService.receivable(salesRequest);
 		GaoProductChartReq productRequest = productChartRequest(session, window, request);
 		List<?> stockHealth = productChartService.stockHealth(productRequest);
 		List<GaoStoreBusinessDay> businessDays = businessDayService.listByDateRange(
 			session.getStoreId(), window.beginDateValue(), window.endDateValue());
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("store", store.getName());
 		summary.put("salesDaily", daily);
 		summary.put("receivable", receivable);
 		summary.put("businessDays", businessDays);
 		summary.put("stockHealth", stockHealth);
 		List<Object> alerts = new ArrayList<>();
 		for (Object item : stockHealth) {
 			if (isLowStock(item)) {
 				alerts.add(item);
 			}
 		}
 		if (alerts.isEmpty() && !stockHealth.isEmpty()) {
 			alerts.add("当前查询范围未发现低库存产品");
 		}
 		return buildResult(session, window, summary, List.of(), alerts, "门店营业日、销售订单、应收和库存健康");
 	}
 	@Override
 	public GaoAiToolResult customerSearch(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoCustomerPage page = new GaoCustomerPage();
 		page.setStoreId(session.getStoreId());
 		page.setKeyword(firstText(request.getQuery(), filter(request, "keyword")));
 		page.setBeginCreatedAt(window.begin());
 		page.setEndCreatedAt(window.end());
 		setPage(page, request);
 		PageResult<GaoCustomer> result = customerService.pageByQuery(page);
 		return buildPagedResult(session, window, result, "客户档案", request.getCursor());
 	}
 	@Override
 	public GaoAiToolResult customerProfile(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoCustomer customer = findCustomer(session.getStoreId(), request);
 		if (customer == null) {
 			return buildResult(session, window, Map.of(), List.of(), List.of("当前门店未查到匹配客户"), "客户、套餐、积分、消费和事件档案");
 		}
 		GaoCustomerPackagePage packagePage = new GaoCustomerPackagePage();
 		packagePage.setStoreId(session.getStoreId());
 		packagePage.setCustomerId(customer.getId());
 		packagePage.setStatus(enumFilter(request, "status", GaoSalesOrder.Status.class));
 		packagePage.setIndex(0);
 		packagePage.setSize(maxPageSize());
 		PageResult<GaoCustomerPackage> packages = customerPackageService.pageByQuery(packagePage);
 		GaoPointAccount account = pointAccountService.getByCustomerId(session.getStoreId(), customer.getId());
 		GaoEventRecordPage eventPage = eventRecordPage(session, window, request);
 		eventPage.setCustomerId(customer.getId());
 		PageResult<GaoEventRecord> events = eventRecordService.pageByRange(eventPage);
 		if (events != null) {
 			attachEventDisplay(events.getList());
 		}
 		List<GaoCustomerConsumptionRecord> consumptions = consumptionRecordService.listActiveByWindow(
 			session.getStoreId(), customer.getId(), window.begin(), window.end());
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("customer", customer);
 		summary.put("pointAccount", account);
 		summary.put("packages", packages == null ? List.of() : packages.getList());
 		summary.put("events", events == null ? List.of() : events.getList());
 		summary.put("activeConsumptions", consumptions);
 		return buildResult(session, window, summary, List.of(), List.of(), "客户、套餐、积分、消费和事件档案");
 	}
 	@Override
 	public GaoAiToolResult orderQuery(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoSalesOrderPage page = new GaoSalesOrderPage();
 		page.setStoreId(session.getStoreId());
 		page.setCustomerId(resolveCustomerId(session.getStoreId(), filter(request, "customerId")));
 		page.setOrderType(enumFilter(request, "orderType", GaoSalesOrder.OrderType.class));
 		page.setStatus(enumFilter(request, "status", GaoSalesOrder.Status.class));
 		page.setPaymentStatus(enumFilter(request, "paymentStatus", GaoSalesOrder.PaymentStatus.class));
 		page.setRefundStatus(enumFilter(request, "refundStatus", GaoSalesOrder.RefundStatus.class));
 		page.setPendingReceive(booleanFilter(request, "pendingReceive"));
 		page.setFulfilledButUnpaid(booleanFilter(request, "fulfilledButUnpaid"));
 		page.setKeyword(firstText(request.getQuery(), filter(request, "keyword")));
 		page.setBeginAt(window.begin());
 		page.setEndAt(window.end());
 		setPage(page, request);
 		PageResult<GaoSalesOrder> orders = salesOrderService.pageByQuery(page);
 		GaoFundRecordPage fundPage = new GaoFundRecordPage();
 		fundPage.setStoreId(session.getStoreId());
 		fundPage.setCustomerId(page.getCustomerId());
 		fundPage.setBeginAt(window.begin());
 		fundPage.setEndAt(window.end());
 		fundPage.setIndex(0);
 		fundPage.setSize(maxPageSize());
 		PageResult<GaoFundRecord> funds = fundRecordService.pageByQuery(fundPage);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("ordersTotal", orders == null ? 0L : orders.getTotal());
 		summary.put("fundRecordsTotal", funds == null ? 0L : funds.getTotal());
 		summary.put("fundRecords", funds == null ? List.of() : funds.getList());
 		return buildResult(session, window, summary, pageDetails(orders), List.of(), "销售订单、履约和资金流水");
 	}
 	@Override
 	public GaoAiToolResult eventQuery(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoEventRecordPage page = eventRecordPage(session, window, request);
 		String eventId = filter(request, "eventId");
 		if (!isBlank(eventId)) {
 			GaoEvent event = eventService.get(eventId);
 			if (event != null && !session.getStoreId().equals(event.getStoreId())) {
 				throw new GaoAiToolException("事件不属于当前门店", 403);
 			}
 			page.setEventIdList(List.of(eventId));
 		}
 		String eventKeyword = firstText(filter(request, "event"), filter(request, "eventName"));
 		if (eventKeyword != null && isBlank(eventId)) {
 			List<String> eventIdList = eventService.listValid(session.getStoreId()).stream()
 				.filter(item -> containsIgnoreCase(item.getName(), eventKeyword))
 				.map(GaoEvent::getId)
 				.toList();
 			page.setEventIdList(eventIdList);
 		}
 		PageResult<GaoEventRecord> records = eventRecordService.pageByRange(page);
 		attachEventDisplay(records == null ? null : records.getList());
 		List<Object> details = pageDetails(records);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("total", records == null ? 0L : records.getTotal());
 		summary.put("returnedCount", details.size());
 		summary.put("numberValueTotal", eventRecordService.sumNumberValueByRange(page));
 		summary.put("optionStatistics", eventRecordService.optionStatByRange(page));
 		if (records != null && details.size() < records.getTotal()) {
 			summary.put("hasMore", true);
 			summary.put("nextCursor", String.valueOf(cursorIndex(request.getCursor()) + 1));
 		}
 		return buildResult(session, window, summary, details, List.of(), "登记事件记录和选项统计");
 	}
 	@Override
 	public GaoAiToolResult productInventoryQuery(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoProductStockPage page = new GaoProductStockPage();
 		page.setStoreId(session.getStoreId());
 		page.setProductId(filter(request, "productId"));
 		page.setKeyword(firstText(request.getQuery(), filter(request, "keyword")));
 		setPage(page, request);
 		PageResult<GaoProductStock> stocks = stockService.pageByQuery(page);
 		GaoProductChartReq productRequest = productChartRequest(session, window, request);
 		List<?> stockHealth = productChartService.stockHealth(productRequest);
 		List<?> stockMovementDaily = productChartService.stockMovementDaily(productRequest);
 		List<?> salesRank = productChartService.salesRank(productRequest);
 		List<Object> details = pageDetails(stocks);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("total", stocks == null ? 0L : stocks.getTotal());
 		summary.put("returnedCount", details.size());
 		summary.put("stockHealth", stockHealth);
 		summary.put("stockMovementDaily", stockMovementDaily);
 		summary.put("salesRank", salesRank);
 		if (stocks != null && details.size() < stocks.getTotal()) {
 			summary.put("hasMore", true);
 			summary.put("nextCursor", String.valueOf(cursorIndex(request.getCursor()) + 1));
 		}
 		return buildResult(session, window, summary, details, List.of(), "产品、SKU、库存和销售摘要");
 	}
 	@Override
 	public GaoAiToolResult pointQuery(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		String customerId = resolveCustomerId(session.getStoreId(), filter(request, "customerId"));
 		Map<String, Object> summary = new LinkedHashMap<>();
 		List<Object> details = new ArrayList<>();
 		if (customerId == null && request.getQuery() != null) {
 			customerId = resolveCustomerId(session.getStoreId(), request.getQuery());
 		}
 		if (customerId != null) {
 			summary.put("account", pointAccountService.getByCustomerId(session.getStoreId(), customerId));
 		}
 		GaoPointLedgerPage ledgerPage = new GaoPointLedgerPage();
 		ledgerPage.setStoreId(session.getStoreId());
 		ledgerPage.setCustomerId(customerId);
 		ledgerPage.setChangeType(enumFilter(request, "changeType", GaoPointLedger.ChangeType.class));
 		ledgerPage.setBeginAt(window.begin());
 		ledgerPage.setEndAt(window.end());
 		setPage(ledgerPage, request);
 		PageResult<GaoPointLedger> ledgers = pointLedgerService.pageByQuery(ledgerPage);
 		details.addAll(pageDetails(ledgers));
 		summary.put("ledgerTotal", ledgers == null ? 0L : ledgers.getTotal());
 		GaoPointRedemptionPage redemptionPage = new GaoPointRedemptionPage();
 		redemptionPage.setStoreId(session.getStoreId());
 		redemptionPage.setCustomerId(customerId);
 		redemptionPage.setKeyword(firstText(request.getQuery(), filter(request, "keyword")));
 		redemptionPage.setBeginAt(window.begin());
 		redemptionPage.setEndAt(window.end());
 		redemptionPage.setIndex(0);
 		redemptionPage.setSize(maxPageSize());
 		summary.put("redemptions", redemptionService.pageByQuery(redemptionPage));
 		summary.put("activeRules", pointRuleService.listActive(session.getStoreId(), null, null, System.currentTimeMillis()));
 		return buildResult(session, window, summary, details, List.of(), "积分账户、积分流水、规则和兑换");
 	}
 	@Override
 	public GaoAiToolResult businessReport(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "THIS_MONTH", true);
 		GaoSalesOrderChartReq salesRequest = salesChartRequest(session, window, request);
 		List<?> salesDaily = salesOrderChartService.daily(salesRequest);
 		Object receivable = salesOrderChartService.receivable(salesRequest);
 		List<?> customerRank = salesOrderChartService.customerRank(salesRequest);
 		List<?> repeatDaily = salesOrderChartService.repeatDaily(salesRequest);
 		List<?> repeatInterval = salesOrderChartService.repeatInterval(salesRequest);
 		GaoProductChartReq productRequest = productChartRequest(session, window, request);
 		List<?> productRank = productChartService.salesRank(productRequest);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("salesDaily", salesDaily);
 		summary.put("receivable", receivable);
 		summary.put("customerRank", customerRank);
 		summary.put("repeatDaily", repeatDaily);
 		summary.put("repeatInterval", repeatInterval);
 		summary.put("productRank", productRank);
 		return buildResult(session, window, summary, List.of(), List.of(), "销售趋势、排行、复购和应收分析");
 	}
 	@Override
 	public GaoAiToolResult storeDiaryQuery(GaoAiSession session, GaoAiToolRequest request) {
 		request = normalize(request);
 		TimeWindow window = resolveWindow(request, "TODAY", false);
 		GaoStoreDiaryPage page = new GaoStoreDiaryPage();
 		page.setStoreId(session.getStoreId());
 		page.setBeginCreatedAt(window.begin());
 		page.setEndCreatedAt(window.end());
 		setPage(page, request);
 		PageResult<Article> diaries = storeDiaryService.page(page);
 		return buildPagedResult(session, window, diaries, "门店日记和营业日信息", request.getCursor());
 	}
 	@Override
 	public GaoAiToolResult metricDefinition(GaoAiSession session, GaoAiToolRequest request) {
 		TimeWindow window = resolveWindow(normalize(request), "TODAY", false);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("有效销售订单", "状态为 ACTIVE 或 FULFILLED 的销售订单；已取消订单不计入有效销售");
 		summary.put("销售额", "有效销售订单的成交金额，单位为分，展示层按金额格式化");
 		summary.put("实收金额", "销售订单已确认收款金额，不包含待核销收款");
 		summary.put("应收金额", "成交金额减去已确认实收金额");
 		summary.put("有效消费", "状态为 ACTIVE 的客户消费事实，仅在订单全额实收后参与累计");
 		summary.put("可用库存", "库存现有量减去履约预占量");
 		summary.put("复购客户", "统计范围内发生两次及以上有效消费或有效订单的客户，具体以报表工具返回口径为准");
 		summary.put("数据边界", "实时业务数据只来自 GAO 查询服务，不包含知识库中的静态规则数据");
 		return buildResult(session, window, summary, List.of(), List.of(), "门店经营指标名称和计算口径");
 	}
 	private GaoAiToolRequest normalize(GaoAiToolRequest request) {
 		GaoAiToolRequest result = request == null ? new GaoAiToolRequest() : request;
 		if (result.getFilters() != null && containsStoreId(result.getFilters())) {
 			throw new GaoAiToolException("工具请求不允许携带 storeId", 403);
 		}
 		if (result.getQuery() != null && 256 < result.getQuery().length()) {
 			throw new GaoAiToolException("查询关键词过长", 400);
 		}
 		return result;
 	}
 	private GaoStore requireStore(GaoAiSession session) {
 		if (session == null || isBlank(session.getStoreId())) {
 			throw new GaoAiToolException("AI 会话缺少门店范围", 403);
 		}
 		GaoStore store = storeService.get(session.getStoreId());
 		if (store == null || !store.isActivated()) {
 			throw new GaoAiToolException("当前门店不存在或未启用", 403);
 		}
 		return store;
 	}
 	private GaoCustomer findCustomer(String storeId, GaoAiToolRequest request) {
 		String customerId = filter(request, "customerId");
 		if (!isBlank(customerId)) {
 			GaoCustomer customer = customerService.get(customerId);
 			if (customer != null && !storeId.equals(customer.getStoreId())) {
 				throw new GaoAiToolException("客户不属于当前门店", 403);
 			}
 			return customer;
 		}
 		String query = request.getQuery();
 		if (isBlank(query)) {
 			return null;
 		}
 		GaoCustomer customer = customerService.getByCode(storeId, query);
 		if (customer == null) {
 			customer = customerService.getByName(storeId, query);
 		}
 		if (customer != null) {
 			return customer;
 		}
 		GaoCustomerPage page = new GaoCustomerPage();
 		page.setStoreId(storeId);
 		page.setKeyword(query);
 		page.setIndex(0);
 		page.setSize(1);
 		PageResult<GaoCustomer> result = customerService.pageByQuery(page);
 		return result == null || result.getList() == null || result.getList().isEmpty() ? null : result.getList().getFirst();
 	}
 	private String resolveCustomerId(String storeId, String value) {
 		if (isBlank(value)) {
 			return null;
 		}
 		GaoCustomer customer = customerService.get(value);
 		if (customer != null) {
 			if (!storeId.equals(customer.getStoreId())) {
 				throw new GaoAiToolException("客户不属于当前门店", 403);
 			}
 			return customer.getId();
 		}
 		customer = customerService.getByCode(storeId, value);
 		if (customer == null) {
 			customer = customerService.getByName(storeId, value);
 		}
 		return customer == null ? null : customer.getId();
 	}
 	private GaoEventRecordPage eventRecordPage(GaoAiSession session, TimeWindow window, GaoAiToolRequest request) {
 		GaoEventRecordPage page = new GaoEventRecordPage();
 		page.setStoreId(session.getStoreId());
 		page.setVerificationStatus(enumFilter(request, "verificationStatus", GaoEventRecord.VerificationStatus.class));
 		page.setKeyword(firstText(request.getQuery(), filter(request, "keyword")));
 		page.setBeginAt(window.begin());
 		page.setEndAt(window.end());
 		setPage(page, request);
 		return page;
 	}
 	private GaoSalesOrderChartReq salesChartRequest(GaoAiSession session, TimeWindow window, GaoAiToolRequest request) {
 		GaoSalesOrderChartReq result = new GaoSalesOrderChartReq();
 		result.setStoreId(session.getStoreId());
 		result.setCustomerId(resolveCustomerId(session.getStoreId(), filter(request, "customerId")));
 		result.setProductId(filter(request, "productId"));
 		result.setSkuId(filter(request, "skuId"));
 		result.setBeginAt(window.begin());
 		result.setEndAt(window.end());
 		result.setTopN(maxPageSize());
 		return result;
 	}
 	private GaoProductChartReq productChartRequest(GaoAiSession session, TimeWindow window, GaoAiToolRequest request) {
 		GaoProductChartReq result = new GaoProductChartReq();
 		result.setStoreId(session.getStoreId());
 		result.setProductId(filter(request, "productId"));
 		result.setSkuId(filter(request, "skuId"));
 		result.setCategoryId(filter(request, "categoryId"));
 		result.setBeginAt(window.begin());
 		result.setEndAt(window.end());
 		result.setTopN(maxPageSize());
 		return result;
 	}
 	private void attachEventDisplay(List<GaoEventRecord> list) {
 		if (list == null || list.isEmpty()) {
 			return;
 		}
 		Map<String, GaoEvent> eventMap = eventService.mapByIdList(list.stream().map(GaoEventRecord::getEventId).distinct().toList());
 		Map<String, GaoCustomer> customerMap = customerService.mapByIdList(list.stream().map(GaoEventRecord::getCustomerId).distinct().toList());
 		for (GaoEventRecord record : list) {
 			record.setEvent(eventMap.get(record.getEventId()));
 			record.setCustomer(customerMap.get(record.getCustomerId()));
 		}
 		eventRecordService.attachSelectedOptionGroupList(list);
 	}
 	private GaoAiToolResult buildPagedResult(GaoAiSession session, TimeWindow window, PageResult<?> page, String metric,
 		String cursor) {
 		List<Object> details = pageDetails(page);
 		Map<String, Object> summary = new LinkedHashMap<>();
 		summary.put("total", page == null ? 0L : page.getTotal());
 		summary.put("returnedCount", details.size());
 		if (page != null && details.size() < page.getTotal()) {
 			summary.put("hasMore", true);
 			summary.put("nextCursor", String.valueOf(cursorIndex(cursor) + 1));
 		}
 		return buildResult(session, window, summary, details, List.of(), metric);
 	}
 	private List<Object> pageDetails(PageResult<?> page) {
 		return page == null || page.getList() == null ? new ArrayList<>() : sanitizeList(page.getList());
 	}
 	private GaoAiToolResult buildResult(GaoAiSession session, TimeWindow window, Map<String, Object> summary,
 		Collection<?> details, Collection<?> alerts, String metric) {
 		GaoAiToolResult result = new GaoAiToolResult();
 		Map<String, Object> scope = new LinkedHashMap<>();
 		GaoStore store = requireStore(session);
 		scope.put("storeName", store.getName());
 		scope.put("timeRange", window.display());
 		result.setScope(scope);
 		result.setSummary(sanitizeMap(summary));
 		result.setDetails(sanitizeList(details));
 		result.setAlerts(sanitizeList(alerts));
 		Map<String, Object> source = new LinkedHashMap<>();
 		source.put("metric", metric);
 		source.put("generatedAt", Instant.now().atZone(ZONE).toOffsetDateTime().toString());
 		result.setSource(source);
 		return result;
 	}
 	private TimeWindow resolveWindow(GaoAiToolRequest request, String defaultPreset, boolean trend) {
 		String preset = request.getTimeRange() == null ? defaultPreset : request.getTimeRange().getPreset();
 		if (isBlank(preset)) {
 			preset = defaultPreset;
 		}
 		preset = preset.trim().toUpperCase(Locale.ROOT);
 		LocalDate today = LocalDate.now(ZONE);
 		LocalDate start;
 		LocalDate end;
 		switch (preset) {
 			case "TODAY" -> {
 				start = today;
 				end = today;
 			}
 			case "LAST_7_DAYS" -> {
 				start = today.minusDays(6);
 				end = today;
 			}
 			case "LAST_30_DAYS" -> {
 				start = today.minusDays(29);
 				end = today;
 			}
 			case "THIS_MONTH" -> {
 				start = today.withDayOfMonth(1);
 				end = start.plusMonths(1).minusDays(1);
 			}
 			case "THIS_YEAR" -> {
 				start = today.withDayOfYear(1);
 				end = start.plusYears(1).minusDays(1);
 			}
 			case "CUSTOM" -> {
 				if (request.getTimeRange() == null || isBlank(request.getTimeRange().getStartDate())
 					|| isBlank(request.getTimeRange().getEndDate())) {
 					throw new GaoAiToolException("自定义时间范围必须同时提供开始和结束日期", 400);
 				}
 				try {
 					start = LocalDate.parse(request.getTimeRange().getStartDate(), DATE_FORMATTER);
 					end = LocalDate.parse(request.getTimeRange().getEndDate(), DATE_FORMATTER);
 				} catch (RuntimeException e) {
 					throw new GaoAiToolException("日期格式必须为 yyyy-MM-dd", 400);
 				}
 			}
 			default -> throw new GaoAiToolException("不支持的时间范围预设：" + preset, 400);
 		}
 		if (start.isAfter(end)) {
 			throw new GaoAiToolException("时间范围无效", 400);
 		}
 		long days = ChronoUnit.DAYS.between(start, end) + 1L;
 		long maxDays = trend ? 365L : 31L;
 		if (maxDays < days) {
 			throw new GaoAiToolException(trend ? "趋势查询最多支持 365 天" : "明细查询最多支持 31 天", 400);
 		}
 		long begin = start.atStartOfDay(ZONE).toInstant().toEpochMilli();
 		long finish = end.plusDays(1).atStartOfDay(ZONE).toInstant().toEpochMilli();
 		return new TimeWindow(start, end, begin, finish);
 	}
 	private int maxPageSize() {
 		int max = properties.getMaxToolPageSize();
 		if (20 < max) {
 			max = 20;
 		}
 		if (max < 1) {
 			max = 1;
 		}
 		return max;
 	}
 	private void setPage(com.imyeyu.java.bean.BasePage page, GaoAiToolRequest request) {
 		int size = request.getPageSize() == null ? maxPageSize() : request.getPageSize();
 		if (size < 1) {
 			size = 1;
 		}
 		if (maxPageSize() < size) {
 			size = maxPageSize();
 		}
 		page.setSize(size);
 		page.setIndex(cursorIndex(request.getCursor()));
 	}
 	private int cursorIndex(String cursor) {
 		if (isBlank(cursor)) {
 			return 0;
 		}
 		try {
 			int index = Integer.parseInt(cursor);
 			return index < 0 ? 0 : index;
 		} catch (NumberFormatException e) {
 			throw new GaoAiToolException("分页游标无效", 400);
 		}
 	}
 	private <E extends Enum<E>> E enumFilter(GaoAiToolRequest request, String key, Class<E> type) {
 		String value = filter(request, key);
 		if (isBlank(value)) {
 			return null;
 		}
 		try {
 			return Enum.valueOf(type, value.trim().toUpperCase(Locale.ROOT));
 		} catch (IllegalArgumentException e) {
 			throw new GaoAiToolException("过滤条件无效：" + key, 400);
 		}
 	}
 	private Boolean booleanFilter(GaoAiToolRequest request, String key) {
 		String value = filter(request, key);
 		return isBlank(value) ? null : Boolean.valueOf(value);
 	}
 	private String filter(GaoAiToolRequest request, String key) {
 		if (request == null || request.getFilters() == null) {
 			return null;
 		}
 		Object value = request.getFilters().get(key);
 		return value == null ? null : String.valueOf(value);
 	}
 	private String firstText(String... values) {
 		for (String value : values) {
 			if (!isBlank(value)) {
 				return value.trim();
 			}
 		}
 		return null;
 	}
 	private boolean containsIgnoreCase(String value, String keyword) {
 		return value != null && keyword != null && value.toLowerCase(Locale.ROOT).contains(keyword.toLowerCase(Locale.ROOT));
 	}
 	private boolean containsStoreId(Object value) {
 		if (value instanceof Map<?, ?> map) {
 			for (Map.Entry<?, ?> entry : map.entrySet()) {
 				if ("storeId".equals(String.valueOf(entry.getKey())) || containsStoreId(entry.getValue())) {
 					return true;
 				}
 			}
 		}
 		if (value instanceof Collection<?> collection) {
 			for (Object item : collection) {
 				if (containsStoreId(item)) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
 	private boolean isLowStock(Object value) {
 		if (value == null) {
 			return false;
 		}
 		Map<String, Object> map = rawMap(value);
 		Object lowStock = map.get("lowStock");
 		return lowStock instanceof Number number && 0 < number.intValue();
 	}
 	private List<Object> sanitizeList(Collection<?> values) {
 		List<Object> result = new ArrayList<>();
 		if (values == null) {
 			return result;
 		}
 		for (Object value : values) {
 			Object sanitized = sanitize(value);
 			if (sanitized != null) {
 				result.add(sanitized);
 			}
 		}
 		return result;
 	}
 	private Map<String, Object> sanitizeMap(Map<?, ?> source) {
 		Map<String, Object> result = new LinkedHashMap<>();
 		if (source == null) {
 			return result;
 		}
 		for (Map.Entry<?, ?> entry : source.entrySet()) {
 			String key = String.valueOf(entry.getKey());
 			if (isSensitiveKey(key)) {
 				continue;
 			}
 			Object value = sanitize(entry.getValue());
 			if (value != null) {
 				result.put(key, value);
 			}
 		}
 		return result;
 	}
 	private Object sanitize(Object value) {
 		if (value == null || value instanceof String || value instanceof Number || value instanceof Boolean || value instanceof Enum<?>) {
 			return value instanceof Enum<?> enumValue ? enumValue.name() : value;
 		}
 		if (value instanceof Map<?, ?> map) {
 			return sanitizeMap(map);
 		}
 		if (value instanceof Collection<?> collection) {
 			return sanitizeList(collection);
 		}
 		try {
 			return sanitizeMap(jackson.convertValue(value, new TypeReference<Map<String, Object>>() {}));
 		} catch (IllegalArgumentException e) {
 			return null;
 		}
 	}
 	private Map<String, Object> rawMap(Object value) {
 		if (value instanceof Map<?, ?> map) {
 			Map<String, Object> result = new LinkedHashMap<>();
 			map.forEach((key, item) -> result.put(String.valueOf(key), item));
 			return result;
 		}
 		return jackson.convertValue(value, new TypeReference<Map<String, Object>>() {});
 	}
 	private boolean isSensitiveKey(String key) {
 		return SENSITIVE_KEYS.contains(key) || key.endsWith("Id") || key.toLowerCase(Locale.ROOT).contains("password")
 			|| key.toLowerCase(Locale.ROOT).contains("token") || key.toLowerCase(Locale.ROOT).contains("url");
 	}
 	private boolean isBlank(String value) {
 		return value == null || value.trim().isEmpty();
 	}
 	private record TimeWindow(LocalDate start, LocalDate endDate, long begin, long end) {
 		private int beginDateValue() {
 			return Integer.parseInt(DAY_VALUE_FORMATTER.format(start));
 		}
 		private int endDateValue() {
 			return Integer.parseInt(DAY_VALUE_FORMATTER.format(endDate));
 		}
 		private String display() {
 			return "%s 至 %s".formatted(start, endDate);
 		}
 	}
 }
@@ -0,0 +1,111 @@
 package com.imyeyu.api.modules.gao.ai.service.implement;
 import com.imyeyu.api.modules.gao.ai.config.GaoAiProperties;
 import com.imyeyu.api.modules.gao.ai.entity.GaoAiSession;
 import com.imyeyu.api.modules.gao.ai.mcp.GaoAiToolNames;
 import com.imyeyu.api.modules.gao.ai.service.GaoAiSessionService;
 import com.imyeyu.spring.util.Redis;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
 import java.security.SecureRandom;
 import java.util.Base64;
 /// GAO 智能体会话服务实现
 ///
 /// @author Codex
 /// @since 2026-09-15
@Service
@RequiredArgsConstructor
 public class GaoAiSessionServiceImplement implements GaoAiSessionService {
 	private static final String KEY_PREFIX = "GAO:AI:SESSION:";
 	private final GaoAiProperties properties;
 	@Qualifier("redisGaoAiSession")
 	private final Redis<String, GaoAiSession> redis;
 	private final SecureRandom secureRandom = new SecureRandom();
 	@Override
 	public GaoAiSession create(String userId, String storeId, String difyConversationId) {
 		if (isBlank(userId) || isBlank(storeId)) {
 			throw new IllegalArgumentException("AI 会话缺少用户或门店");
 		}
 		long ttlSeconds = Math.max(1L, properties.getSessionTtlSeconds());
 		GaoAiSession session = new GaoAiSession();
 		session.setSessionId(newSessionId());
 		session.setUserId(userId);
 		session.setStoreId(storeId);
 		session.setDifyConversationId(blankToNull(difyConversationId));
 		session.setAllowedTools(GaoAiToolNames.orderedReadOnlyTools());
 		session.setExpiresAt(System.currentTimeMillis() + ttlSeconds * 1000L);
 		session.setUsedCount(0L);
 		redis.set(key(session.getSessionId()), session, ttlSeconds * 1000L);
 		return session;
 	}
 	@Override
 	public GaoAiSession require(String sessionId) {
 		if (isBlank(sessionId)) {
 			throw new GaoAiSessionException("缺少 AI 会话", 401);
 		}
 		GaoAiSession session = redis.get(key(sessionId.trim()));
 		if (session == null || session.getExpiresAt() <= System.currentTimeMillis()) {
 			redis.destroy(key(sessionId.trim()));
 			throw new GaoAiSessionException("AI 会话不存在或已过期", 401);
 		}
 		return session;
 	}
 	@Override
 	public GaoAiSession increaseUsedCount(String sessionId) {
 		GaoAiSession session = require(sessionId);
 		session.setUsedCount(session.getUsedCount() + 1L);
 		long remain = Math.max(1L, session.getExpiresAt() - System.currentTimeMillis());
 		redis.set(key(session.getSessionId()), session, remain);
 		return session;
 	}
 	@Override
 	public void delete(String sessionId) {
 		if (!isBlank(sessionId)) {
 			redis.destroy(key(sessionId.trim()));
 		}
 	}
 	private String newSessionId() {
 		byte[] bytes = new byte[32];
 		secureRandom.nextBytes(bytes);
 		return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
 	}
 	private String key(String sessionId) {
 		return KEY_PREFIX + sessionId;
 	}
 	private boolean isBlank(String value) {
 		return value == null || value.trim().isEmpty();
 	}
 	private String blankToNull(String value) {
 		return isBlank(value) ? null : value.trim();
 	}
 	/// AI 会话认证异常
 	public static class GaoAiSessionException extends RuntimeException {
 		private final int status;
 		public GaoAiSessionException(String message, int status) {
 			super(message);
 			this.status = status;
 		}
 		public int getStatus() {
 			return status;
 		}
 	}
 }
@@ -0,0 +1,20 @@
 package com.imyeyu.api.modules.gao.ai.vo;
 import lombok.Data;
 /// GAO 智能体聊天请求
 ///
 /// @author Codex
 /// @since 2026-09-15
@Data
 public class GaoAiChatRequest {
 	/// 店长问题
 	private String message;
 	/// Dify 会话 ID，可为空
 	private String conversationId;
 	/// GLOBAL_MANAGER 兼任店长时使用当前选中门店 ID，可为空
 	private String storeId;
 }
@@ -0,0 +1,22 @@
 package com.imyeyu.api.modules.gao.ai.vo;
 import lombok.Data;
 /// GAO 智能体历史会话列表请求
 ///
 /// 字段与 Dify 会话列表分页参数对应，但用户标识由后端注入
 ///
 /// @author Codex
 /// @since 2026-09-16
@Data
 public class GaoAiConversationListRequest {
 	/// 上一页最后一条会话 ID，可为空
 	private String lastId;
 	/// 返回条数，可为空
 	private Integer limit;
 	/// 排序方式，可选 `created_at`、`-created_at`、`updated_at`、`-updated_at`
 	private String sortBy;
 }
@@ -0,0 +1,22 @@
 package com.imyeyu.api.modules.gao.ai.vo;
 import lombok.Data;
 /// GAO 智能体历史会话消息读取请求
 ///
 /// 用户标识由后端注入，前端只能指定会话和分页游标
 ///
 /// @author Codex
 /// @since 2026-09-16
@Data
 public class GaoAiConversationReadRequest {
 	/// Dify 会话 ID
 	private String conversationId;
 	/// 上一页第一条消息 ID，可为空
 	private String firstId;
 	/// 返回条数，可为空
 	private Integer limit;
 }
@@ -0,0 +1,43 @@
 package com.imyeyu.api.modules.gao.ai.vo;
 import lombok.Data;
 import java.util.LinkedHashMap;
 import java.util.Map;
 /// GAO 智能体 MCP 工具通用请求
 ///
 /// @author Codex
 /// @since 2026-09-15
@Data
 public class GaoAiToolRequest {
 	/// 自然语言关键词
 	private String query;
 	/// 时间范围
 	private TimeRange timeRange;
 	/// 业务过滤条件，不允许携带 storeId
 	private Map<String, Object> filters = new LinkedHashMap<>();
 	/// 请求条数，服务端强制限制为 1 至 20
 	private Integer pageSize;
 	/// 分页游标，当前实现为不透明页码字符串
 	private String cursor;
 	/// 工具时间范围
 	@Data
 	public static class TimeRange {
 		/// 预设范围，例如 TODAY、THIS_MONTH、CUSTOM
 		private String preset;
 		/// 自定义开始日期，格式为 yyyy-MM-dd
 		private String startDate;
 		/// 自定义结束日期，格式为 yyyy-MM-dd，包含当天
 		private String endDate;
 	}
 }
@@ -0,0 +1,33 @@
 package com.imyeyu.api.modules.gao.ai.vo;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 /// GAO 智能体 MCP 工具统一返回
 ///
 /// @author Codex
 /// @since 2026-09-15
@Data
@NoArgsConstructor
 public class GaoAiToolResult {
 	/// 数据范围
 	private Map<String, Object> scope = new LinkedHashMap<>();
 	/// 聚合摘要
 	private Map<String, Object> summary = new LinkedHashMap<>();
 	/// 明细，最多返回 20 条
 	private List<Object> details = new ArrayList<>();
 	/// 风险和数据提示
 	private List<Object> alerts = new ArrayList<>();
 	/// 来源和生成时间
 	private Map<String, Object> source = new LinkedHashMap<>();
 }
@@ -39,6 +39,16 @@ public enum GaoPermissionCode implements BuiltinPermissionCode {
 	CUSTOMER_DELETE("CUSTOMER:DELETE", "客户删除", false, false),
 	CUSTOMER_FOLLOW_UP_REMINDER_CREATE("CUSTOMER_FOLLOW_UP_REMINDER:CREATE", "客户跟进提醒创建", false, false),
 	CUSTOMER_FOLLOW_UP_REMINDER_READ("CUSTOMER_FOLLOW_UP_REMINDER:READ", "客户跟进提醒读取", false, false),
 	CUSTOMER_FOLLOW_UP_REMINDER_UPDATE("CUSTOMER_FOLLOW_UP_REMINDER:UPDATE", "客户跟进提醒修改", false, false),
 	CUSTOMER_FOLLOW_UP_REMINDER_DELETE("CUSTOMER_FOLLOW_UP_REMINDER:DELETE", "客户跟进提醒删除", false, false),
 	CUSTOMER_FOLLOW_UP_REMINDER_COMPLETE("CUSTOMER_FOLLOW_UP_REMINDER:COMPLETE", "客户跟进提醒完成", false, false),
 	EVENT_CREATE("EVENT:CREATE", "登记事件创建", false, false),
 	EVENT_READ("EVENT:READ", "登记事件读取", false, false),
@@ -111,6 +121,8 @@ public enum GaoPermissionCode implements BuiltinPermissionCode {
 	CUSTOMER_PACKAGE_PRICE_OVERRIDE("CUSTOMER_PACKAGE:PRICE_OVERRIDE", "客户套餐成交价和权益配额调整", true, true),
 	CUSTOMER_PACKAGE_GIFT_CREATE("CUSTOMER_PACKAGE:GIFT_CREATE", "客户套餐创建赠送", true, true),
 	FUND_RECORD_READ("FUND_RECORD:READ", "资金流水读取", true, true),
 	FUND_RECEIVE_CREATE("FUND_RECEIVE:CREATE", "线下收款创建", true, true),
@@ -137,6 +149,14 @@ public enum GaoPermissionCode implements BuiltinPermissionCode {
 	POINT_SOURCE_VALUE("POINT:SOURCE_VALUE", "登记提交自定义积分值", true, true),
 	POINT_REDEMPTION_CREATE("POINT_REDEMPTION:CREATE", "积分兑换创建和读取", true, true),
 	POINT_REDEMPTION_POINT_ADJUST("POINT_REDEMPTION:POINT_ADJUST", "积分兑换减免积分", true, true),
 	POINT_REDEMPTION_RETURN("POINT_REDEMPTION:RETURN", "积分兑换退货", true, true),
 	POINT_REDEEM_SKU_MANAGE("POINT_REDEEM_SKU:MANAGE", "积分兑换 SKU 配置管理", true, true),
 	STAT_READ("STAT:READ", "统计读取", false, false),
 	QR_CODE_CREATE("QR_CODE:CREATE", "二维码创建", false, false),
@@ -0,0 +1,29 @@
 package com.imyeyu.api.modules.gao.bean;
 import com.imyeyu.api.annotation.SettingBizType;
 import com.imyeyu.api.bean.SettingEnum;
 import com.imyeyu.api.modules.common.entity.Setting;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 ///
 ///
 /// @author 夜雨
 /// @since 2026-09-09 16:11
@Getter
@SettingBizType("GAO_SYSTEM")
@AllArgsConstructor
 public enum GaoSystemSetting implements SettingEnum {
 	DIFY_APP_API_KEY(null, Setting.ValueType.STRING),
 	DIFY_MCP_SERVICE_KEY(null, Setting.ValueType.STRING),
 	AI_AGENT_EXAMPLE(null, Setting.ValueType.JSON_LIST),
 	AGREEMENT(null, Setting.ValueType.JSON_OBJECT);
 	final String defaultValue;
 	final Setting.ValueType valueType;
 }
@@ -5,6 +5,8 @@ import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.service.GaoCustomerChartService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerChartReq;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerDiseaseWordReq;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerDiseaseWordView;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordCalendarView;
 import com.imyeyu.api.modules.gao.vo.GaoEventRecordDailyStatView;
 import com.imyeyu.java.bean.timi.TimiException;
@@ -51,4 +53,15 @@ public class GaoCustomerChartController {
 		req.setStoreId(storeScopeService.resolveStoreId(req.getStoreId()));
 		return service.eventRecordCalendar(req);
 	}
 	/// 查询客户病症词频
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.STAT_READ)
 	@PostMapping("/customer/disease/word")
 	public List<GaoCustomerDiseaseWordView> customerDiseaseWord(@RequestBody GaoCustomerDiseaseWordReq req) {
 		TimiException.required(req, "not found req");
 		req.setStoreId(storeScopeService.resolveStoreId(req.getStoreId()));
 		return service.customerDiseaseWord(req);
 	}
 }
@@ -1,8 +1,12 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.service.AttachmentService;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoCustomerConsumptionRecord;
 import com.imyeyu.api.modules.gao.service.GaoCustomerConsumptionRecordService;
 import com.imyeyu.api.modules.gao.service.GaoCustomerService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerConsumptionRecordPage;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerConsumptionRecordPageResult;
@@ -15,6 +19,9 @@ import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import java.util.List;
 import java.util.Map;
 /// GAO 客户消费事实接口
 ///
 /// @author Codex
@@ -24,8 +31,10 @@ import org.springframework.web.bind.annotation.RestController;
@RequestMapping("/gao/customer/consumption-record")
 public class GaoCustomerConsumptionRecordController {
-	private final GaoCustomerConsumptionRecordService service;
+	private final AttachmentService attachmentService;
 	private final GaoCustomerService customerService;
 	private final GaoStoreScopeService storeScopeService;
 	private final GaoCustomerConsumptionRecordService service;
 	@AOPLog
 	@RequestRateLimit
@@ -34,6 +43,24 @@ public class GaoCustomerConsumptionRecordController {
 	public GaoCustomerConsumptionRecordPageResult list(@RequestBody GaoCustomerConsumptionRecordPage page) {
 		TimiException.required(page, "not found consumption record page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
-		return service.pageByQuery(page);
+
 		GaoCustomerConsumptionRecordPageResult result = service.pageByQuery(page);
 		List<String> customerIdList = result.getList()
 		                                    .stream()
 		                                    .map(GaoCustomerConsumptionRecord::getCustomerId)
 		                                    .filter(customerId -> customerId != null && !customerId.isBlank())
 		                                    .distinct()
 		                                    .toList();
 		var customerMap = customerService.mapByIdList(customerIdList);
 		Map<String, List<Attachment>> attachmentMap = attachmentService.mapByBizIdList(Attachment.BizType.GAO_CUSTOMER, customerIdList);
 		for (GaoCustomerConsumptionRecord record : result.getList()) {
 			var customer = customerMap.get(record.getCustomerId());
 			if (customer == null) {
 				continue;
 			}
 			customer.setAttachmentList(attachmentMap.getOrDefault(customer.getId(), List.of()));
 			record.setCustomer(customer);
 		}
 		return result;
 	}
 }
@@ -0,0 +1,182 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.fasterxml.jackson.annotation.JsonView;
 import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.service.AttachmentService;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoCustomer;
 import com.imyeyu.api.modules.gao.entity.GaoCustomerFollowUpReminder;
 import com.imyeyu.api.modules.gao.service.GaoCustomerFollowUpReminderService;
 import com.imyeyu.api.modules.gao.service.GaoCustomerService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPage;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerFollowUpReminderPageResult;
 import com.imyeyu.api.modules.user.entity.User;
 import com.imyeyu.api.modules.user.service.UserService;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
 import com.imyeyu.spring.util.ResponseView;
 import lombok.RequiredArgsConstructor;
 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 java.util.List;
 import java.util.Map;
 /// GAO 客户跟进提醒接口
 ///
 /// @author Codex
 /// @since 2026-09-17
@RestController
@RequiredArgsConstructor
@RequestMapping("/gao/customer/follow-up-reminder")
 public class GaoCustomerFollowUpReminderController {
 	private final GaoCustomerFollowUpReminderService service;
 	private final GaoCustomerService customerService;
 	private final GaoStoreScopeService storeScopeService;
 	private final UserService userService;
 	private final AttachmentService attachmentService;
 	/// 分页查询客户跟进提醒
 	///
 	/// @param page 查询条件
 	/// @return 分页结果
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_READ)
 	@PostMapping("/list")
 	@JsonView(ResponseView.Public.class)
 	public GaoCustomerFollowUpReminderPageResult list(@RequestBody GaoCustomerFollowUpReminderPage page) {
 		TimiException.required(page, "未找到分页参数");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		GaoCustomerFollowUpReminderPageResult result = service.pageByQuery(page);
 		fillList(result.getList());
 		return result;
 	}
 	/// 查询客户跟进提醒详情
 	///
 	/// @param id 跟进提醒 ID
 	/// @return 跟进提醒
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_READ)
 	@PostMapping("/detail")
 	@JsonView(ResponseView.Public.class)
 	public GaoCustomerFollowUpReminder detail(@RequestParam String id) {
 		GaoCustomerFollowUpReminder reminder = service.get(id);
 		TimiException.required(reminder, "未找到客户跟进提醒");
 		storeScopeService.checkStoreId(reminder.getStoreId());
 		fillDetail(reminder);
 		return reminder;
 	}
 	/// 创建客户跟进提醒
 	///
 	/// @param reminder 跟进提醒
 	/// @return 跟进提醒 ID
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_CREATE)
 	@PostMapping("/create")
 	public String create(@RequestBody GaoCustomerFollowUpReminder reminder) {
 		service.create(reminder);
 		return reminder.getId();
 	}
 	/// 修改客户跟进提醒
 	///
 	/// @param reminder 跟进提醒
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_UPDATE)
 	@PostMapping("/update")
 	public void update(@RequestBody GaoCustomerFollowUpReminder reminder) {
 		TimiException.required(reminder, "未找到客户跟进提醒");
 		TimiException.required(reminder.getId(), "未找到客户跟进提醒 ID");
 		GaoCustomerFollowUpReminder dbReminder = service.get(reminder.getId());
 		TimiException.required(dbReminder, "未找到客户跟进提醒");
 		storeScopeService.checkStoreId(dbReminder.getStoreId());
 		service.update(reminder);
 	}
 	/// 完成客户跟进提醒
 	///
 	/// @param id 跟进提醒 ID
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_COMPLETE)
 	@PostMapping("/complete")
 	public void complete(@RequestParam String id) {
 		GaoCustomerFollowUpReminder reminder = service.get(id);
 		TimiException.required(reminder, "未找到客户跟进提醒");
 		storeScopeService.checkStoreId(reminder.getStoreId());
 		service.complete(id);
 	}
 	/// 删除客户跟进提醒
 	///
 	/// @param id 跟进提醒 ID
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.CUSTOMER_FOLLOW_UP_REMINDER_DELETE)
 	@PostMapping("/delete")
 	public void delete(@RequestParam String id) {
 		GaoCustomerFollowUpReminder reminder = service.get(id);
 		TimiException.required(reminder, "未找到客户跟进提醒");
 		storeScopeService.checkStoreId(reminder.getStoreId());
 		service.delete(id);
 	}
 	/// 回填列表中的客户、负责人和附件
 	///
 	/// @param reminderList 提醒列表
 	private void fillList(List<GaoCustomerFollowUpReminder> reminderList) {
 		if (reminderList == null || reminderList.isEmpty()) {
 			return;
 		}
 		List<String> customerIdList = reminderList.stream()
 			.map(GaoCustomerFollowUpReminder::getCustomerId)
 			.distinct()
 			.toList();
 		Map<String, GaoCustomer> customerMap = customerService.mapByIdList(customerIdList);
 		Map<String, List<Attachment>> customerAttachmentMap = attachmentService.mapByBizIdList(
 			Attachment.BizType.GAO_CUSTOMER,
 			customerIdList);
 		Map<String, User> userMap = userService.mapByIdList(
 			reminderList.stream().map(GaoCustomerFollowUpReminder::getResponsibleUserId).distinct().toList());
 		Map<String, List<Attachment>> attachmentMap = attachmentService.mapByBizIdList(
 			Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER,
 			reminderList.stream().map(GaoCustomerFollowUpReminder::getId).toList());
 		for (GaoCustomerFollowUpReminder reminder : reminderList) {
 			GaoCustomer customer = customerMap.get(reminder.getCustomerId());
 			if (customer != null) {
 				customer.setAttachmentList(customerAttachmentMap.getOrDefault(customer.getId(), List.of()));
 			}
 			reminder.setCustomer(customer);
 			reminder.setResponsibleUser(userMap.get(reminder.getResponsibleUserId()));
 			reminder.setAttachmentList(attachmentMap.getOrDefault(reminder.getId(), List.of()));
 			reminder.resolveNotifyChannelList();
 		}
 	}
 	/// 回填详情中的客户、负责人和附件
 	///
 	/// @param reminder 跟进提醒
 	private void fillDetail(GaoCustomerFollowUpReminder reminder) {
 		GaoCustomer customer = customerService.get(reminder.getCustomerId());
 		customer.setAttachmentList(attachmentService.listByBizId(Attachment.BizType.GAO_CUSTOMER, customer.getId(), GaoCustomer.AttachType.PHOTO.name()));
 		User responsibleUser = userService.get(reminder.getResponsibleUserId());
 		reminder.setCustomer(customer);
 		reminder.setResponsibleUser(responsibleUser);
 		reminder.setAttachmentList(attachmentService.listByBizId(
 			Attachment.BizType.GAO_CUSTOMER_FOLLOW_UP_REMINDER, reminder.getId()));
 		reminder.resolveNotifyChannelList();
 	}
 }
@@ -69,6 +69,7 @@ public class GaoEventRecordController {
 		result.setTotal(pageResult.getTotal());
 		result.setList(pageResult.getList());
 		result.setNumberValueTotal(resolveNumberValueTotal(page));
 		result.setCustomerCount(service.countCustomerByRange(page));
 		{
 			List<String> customerIdList = result.getList().stream().map(GaoEventRecord::getCustomerId).toList();
 			Map<String, GaoEvent> eventMap = eventService.mapByIdList(result.getList().stream().map(GaoEventRecord::getEventId).toList());
@@ -4,7 +4,9 @@ import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.service.AttachmentService;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoCustomer;
 import com.imyeyu.api.modules.gao.entity.GaoFundRecord;
 import com.imyeyu.api.modules.gao.service.GaoCustomerService;
 import com.imyeyu.api.modules.gao.service.GaoFundRecordService;
 import com.imyeyu.api.modules.gao.service.GaoOrderPaymentService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
@@ -12,6 +14,7 @@ import com.imyeyu.api.modules.gao.vo.GaoFundRecordPage;
 import com.imyeyu.api.modules.gao.vo.GaoFundRevokeRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentRevokeRequest;
 import com.imyeyu.api.modules.user.entity.User;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import com.imyeyu.api.modules.user.service.UserService;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
@@ -38,10 +41,12 @@ import java.util.stream.Stream;
 public class GaoFundRecordController {
 	private final GaoFundRecordService service;
 	private final GaoCustomerService customerService;
 	private final GaoOrderPaymentService orderPaymentService;
 	private final GaoStoreScopeService storeScopeService;
 	private final AttachmentService attachmentService;
 	private final UserService userService;
 	private final UserLoginService userLoginService;
 	@AOPLog
 	@RequestRateLimit
@@ -66,6 +71,33 @@ public class GaoFundRecordController {
 		return result;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.FUND_RECEIVE_CREATE)
 	@PostMapping("/my-receive/list")
 	public PageResult<GaoFundRecord> listMyReceive(@RequestBody GaoFundRecordPage page) {
 		TimiException.required(page, "not found page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		page.setOperatorUserId(userLoginService.getRequireLoginUserId());
 		page.setOperationType(GaoFundRecord.OperationType.RECEIVE);
 		PageResult<GaoFundRecord> result = service.pageByQuery(page);
 		fillTransient(result.getList());
 		return result;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.FUND_RECEIVE_CREATE)
 	@PostMapping("/my-receive/detail")
 	public GaoFundRecord detailMyReceive(@RequestParam String id) {
 		GaoFundRecord result = service.detail(id);
 		TimiException.requiredTrue(result.getOperationType() == GaoFundRecord.OperationType.RECEIVE, "not found fund receive record");
 		TimiException.requiredTrue(userLoginService.getRequireLoginUserId().equals(result.getOperatorUserId()), "只能读取自己提交的收款");
 		storeScopeService.checkStoreId(result.getStoreId());
 		fillTransient(List.of(result));
 		return result;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.FUND_REVOKE)
@@ -95,10 +127,23 @@ public class GaoFundRecordController {
 			.distinct()
 			.toList();
 		Map<String, User> userMap = userIdList.isEmpty() ? Map.of() : userService.mapByIdList(userIdList);
 		List<String> customerIdList = recordList.stream()
 			.map(GaoFundRecord::getCustomerId)
 			.filter(value -> value != null && !value.isBlank())
 			.distinct()
 			.toList();
 		Map<String, GaoCustomer> customerMap = customerIdList.isEmpty() ? Map.of() : customerService.mapByIdList(customerIdList);
 		Map<String, List<Attachment>> customerPhotoMap = customerIdList.isEmpty()
 			? Map.of() : attachmentService.mapByBizIdList(Attachment.BizType.GAO_CUSTOMER, customerIdList, GaoCustomer.AttachType.PHOTO.name());
 		for (GaoFundRecord record : recordList) {
 			record.setAttachmentList(attachmentMap.getOrDefault(record.getId(), List.of()));
 			record.setOperator(userMap.get(record.getOperatorUserId()));
 			record.setVerifier(userMap.get(record.getVerifierUserId()));
 			GaoCustomer customer = customerMap.get(record.getCustomerId());
 			if (customer != null) {
 				customer.setAttachmentList(customerPhotoMap.getOrDefault(customer.getId(), List.of()));
 			}
 			record.setCustomer(customer);
 		}
 	}
 }
@@ -2,6 +2,7 @@ package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.modules.common.entity.Attachment;
 import com.imyeyu.api.modules.common.service.AttachmentService;
 import com.imyeyu.api.bean.PermissionMatchMode;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoCustomer;
@@ -78,6 +79,16 @@ public class GaoOrderFulfillmentController {
 		return result;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(value = { GaoPermissionCode.ORDER_FULFILLMENT_CREATE, GaoPermissionCode.ORDER_FULFILLMENT_VERIFY }, mode = PermissionMatchMode.ALL)
 	@PostMapping("/create-and-verify")
 	public GaoOrderFulfillment createAndVerify(@RequestBody GaoOrderFulfillmentCreateRequest request) {
 		GaoOrderFulfillment result = service.createAndVerify(request);
 		fillTransient(List.of(result));
 		return result;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.ORDER_FULFILLMENT_VERIFY)
@@ -101,8 +101,8 @@ public class GaoPackageConfigController {
 		if (skuIdList.isEmpty()) {
 			return;
 		}
-		Map<String, GaoProductSku> skuMap = skuIdList.stream()
+		Map<String, GaoProductSku> skuMap = skuService.listByIdList(skuIdList).stream()
-			.collect(java.util.stream.Collectors.toMap(item -> item, skuService::detail));
+			.collect(java.util.stream.Collectors.toMap(GaoProductSku::getId, item -> item));
 		for (GaoPackageConfig config : configList) {
 			for (GaoPackageConfigItem item : config.getItemList()) {
 				item.setSku(skuMap.get(item.getSkuId()));
@@ -0,0 +1,85 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoPointRedeemSku;
 import com.imyeyu.api.modules.gao.service.GaoPointRedeemSkuService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedeemSkuPage;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedeemSkuRequest;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
 import com.imyeyu.spring.bean.PageResult;
 import lombok.RequiredArgsConstructor;
 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;
 /// GAO 积分兑换 SKU 配置接口
 ///
 /// @author Codex
 /// @since 2026-09-14
@RestController
@RequiredArgsConstructor
@RequestMapping("/gao/point/redeem-sku")
 public class GaoPointRedeemSkuController {
 	private final GaoPointRedeemSkuService service;
 	private final GaoStoreScopeService storeScopeService;
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/list")
 	public PageResult<GaoPointRedeemSku> list(@RequestBody GaoPointRedeemSkuPage page) {
 		TimiException.required(page, "not found redeem sku page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		return service.pageByQuery(page);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/detail")
 	public GaoPointRedeemSku detail(@RequestParam String id, @RequestParam(required = false) String storeId) {
 		return service.detail(storeScopeService.resolveStoreId(storeId), id);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/create")
 	public GaoPointRedeemSku create(@RequestBody GaoPointRedeemSkuRequest request) {
 		TimiException.required(request, "not found redeem sku request");
 		request.setStoreId(storeScopeService.resolveStoreId(request.getStoreId()));
 		return service.create(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/update")
 	public GaoPointRedeemSku update(@RequestBody GaoPointRedeemSkuRequest request) {
 		TimiException.required(request, "not found redeem sku request");
 		return service.update(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/disable")
 	public void disable(@RequestParam String id, @RequestParam(required = false) String storeId) {
 		service.disable(storeScopeService.resolveStoreId(storeId), id);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEEM_SKU_MANAGE)
 	@PostMapping("/delete")
 	public void delete(@RequestParam String id, @RequestParam(required = false) String storeId) {
 		service.delete(storeScopeService.resolveStoreId(storeId), id);
 	}
 }
@@ -0,0 +1,80 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoPointRedemption;
 import com.imyeyu.api.modules.gao.entity.GaoPointRedemptionReturn;
 import com.imyeyu.api.modules.gao.service.GaoPointRedemptionService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionCreateRequest;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionPage;
 import com.imyeyu.api.modules.gao.vo.GaoPointRedemptionReturnRequest;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
 import com.imyeyu.spring.bean.PageResult;
 import lombok.RequiredArgsConstructor;
 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 java.util.List;
 /// GAO 积分兑换单接口
 ///
 /// @author Codex
 /// @since 2026-09-14
@RestController
@RequiredArgsConstructor
@RequestMapping("/gao/point/redemption")
 public class GaoPointRedemptionController {
 	private final GaoPointRedemptionService service;
 	private final GaoStoreScopeService storeScopeService;
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEMPTION_CREATE)
 	@PostMapping("/list")
 	public PageResult<GaoPointRedemption> list(@RequestBody GaoPointRedemptionPage page) {
 		TimiException.required(page, "not found redemption page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		return service.pageByQuery(page);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEMPTION_CREATE)
 	@PostMapping("/detail")
 	public GaoPointRedemption detail(@RequestParam String id, @RequestParam(required = false) String storeId) {
 		return service.detail(storeScopeService.resolveStoreId(storeId), id);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEMPTION_CREATE)
 	@PostMapping("/create")
 	public GaoPointRedemption create(@RequestBody GaoPointRedemptionCreateRequest request) {
 		TimiException.required(request, "not found redemption request");
 		request.setStoreId(storeScopeService.resolveStoreId(request.getStoreId()));
 		return service.create(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEMPTION_RETURN)
 	@PostMapping("/return")
 	public GaoPointRedemption returnRedemption(@RequestBody GaoPointRedemptionReturnRequest request) {
 		return service.returnRedemption(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_REDEMPTION_RETURN)
 	@PostMapping("/return/list")
 	public List<GaoPointRedemptionReturn> returnList(@RequestParam String redemptionId, @RequestParam(required = false) String storeId) {
 		return service.listReturns(storeScopeService.resolveStoreId(storeId), redemptionId);
 	}
 }
@@ -1,5 +1,7 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.modules.common.entity.GroovyScript;
 import com.imyeyu.api.modules.common.service.GroovyScriptService;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoPointRule;
@@ -31,6 +33,7 @@ public class GaoPointRuleController {
 	private final GaoStoreScopeService storeScopeService;
 	private final GaoPointRuleService ruleService;
 	private final GroovyScriptService groovyScriptService;
 	@AOPLog
 	@RequestRateLimit
@@ -54,9 +57,22 @@ public class GaoPointRuleController {
 		GaoPointRule rule = ruleService.get(id);
 		TimiException.required(rule, "not found point rule");
 		storeScopeService.checkStoreId(rule.getStoreId());
 		if (rule.getRuleMode() == GaoPointRule.RuleMode.GROOVY) {
 			GroovyScript script = groovyScriptService.get(rule.getGroovyScriptId());
 			script.setLatest(groovyScriptService.getLatestVersion(script.getId()));
 			rule.setGroovyScript(script);
 		}
 		return rule;
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_RULE_READ)
 	@PostMapping("/rule/script/list")
 	public List<GroovyScript> scriptList() {
 		return groovyScriptService.listByBizType(GroovyScript.BizType.GAO_POINT_RULE);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.POINT_RULE_CREATE)
@@ -7,6 +7,7 @@ import com.imyeyu.api.modules.gao.entity.GaoProductStockRecord;
 import com.imyeyu.api.modules.gao.service.GaoProductStockService;
 import com.imyeyu.api.modules.gao.service.GaoProductStockRecordService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockBatchRequest;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockChangeRequest;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockManualRevokeRequest;
 import com.imyeyu.api.modules.gao.vo.GaoProductStockPage;
@@ -23,6 +24,8 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import java.util.List;
 /// GAO 产品库存接口
 ///
 /// @author Codex
@@ -64,6 +67,16 @@ public class GaoProductStockController {
 		return stockService.detail(storeScopeService.resolveStoreId(storeId), skuId);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.PRODUCT_STOCK_READ)
 	@PostMapping("/batch-detail")
 	public List<GaoProductStock> batchDetail(@RequestBody GaoProductStockBatchRequest request) {
 		TimiException.required(request, "not found stock batch request");
 		request.setStoreId(storeScopeService.resolveStoreId(request.getStoreId()));
 		return stockService.batchDetail(request.getStoreId(), request.getSkuIdList());
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.PRODUCT_STOCK_CREATE)
@@ -3,8 +3,13 @@ package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.annotation.RequireCorePermission;
 import com.imyeyu.api.bean.CorePermissionCode;
 import com.imyeyu.api.bean.ModuleCode;
 import com.imyeyu.api.modules.gao.entity.GaoStore;
 import com.imyeyu.api.modules.gao.service.GaoStoreService;
 import com.imyeyu.api.modules.user.bean.AuthOwnerType;
 import com.imyeyu.api.modules.user.entity.Role;
 import com.imyeyu.api.modules.user.service.AuthorizationScopeService;
 import com.imyeyu.api.modules.user.service.PermissionService;
 import com.imyeyu.api.modules.user.service.RoleService;
 import com.imyeyu.api.modules.user.service.UserLoginService;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
@@ -26,6 +31,9 @@ public class GaoRoleController {
 	private final UserLoginService userLoginService;
 	private final AuthorizationScopeService authorizationScopeService;
 	private final GaoStoreService gaoStoreService;
 	private final PermissionService permissionService;
 	private final RoleService roleService;
 	@AOPLog
 	@RequestRateLimit
@@ -34,4 +42,40 @@ public class GaoRoleController {
 	public List<Role> availableList() {
 		return authorizationScopeService.listGrantableRole(userLoginService.getRequireLoginUserId(), ModuleCode.GAO);
 	}
 	/// 查询登录用户所属门店内可管理的角色
 	///
 	/// @return 门店角色列表
 	@AOPLog
 	@RequestRateLimit
 	@RequireCorePermission(CorePermissionCode.ROLE_READ)
 	@PostMapping("/management/list")
 	public List<Role> managementList() {
 		String loginUserId = userLoginService.getRequireLoginUserId();
 		GaoStore store = gaoStoreService.getByUserId(loginUserId);
 		if (store == null) {
 			return List.of();
 		}
 		List<Role> roleList = authorizationScopeService.listManageableRole(loginUserId, ModuleCode.GAO)
 				.stream()
 				.filter(role -> role.getOwnerType() == AuthOwnerType.STORE)
 				.filter(role -> store.getId().equals(role.getOwnerId()))
 				.toList();
 		roleList.forEach(this::fillRoleDetail);
 		return roleList;
 	}
 	/// 填充角色详情
 	///
 	/// @param role 角色
 	private void fillRoleDetail(Role role) {
 		role.setPermissionList(permissionService.listByRoleId(role.getId()));
 		role.setAllPermissionList(roleService.listPermissionByRoleId(role.getId()));
 		role.setChildRoleList(roleService.listChildByParentRoleId(role.getId()));
 		if (role.getParentRoleId() != null) {
 			role.setParentRole(roleService.get(role.getParentRoleId()));
 		}
 		role.setDelegationPermissionList(roleService.listDelegationPermissionByRoleId(role.getId()));
 	}
 }
@@ -1,5 +1,6 @@
 package com.imyeyu.api.modules.gao.controller;
 import com.imyeyu.api.bean.PermissionMatchMode;
 import com.imyeyu.api.modules.gao.annotation.RequireGaoPermission;
 import com.imyeyu.api.modules.gao.bean.GaoPermissionCode;
 import com.imyeyu.api.modules.gao.entity.GaoFundRecord;
@@ -8,6 +9,8 @@ import com.imyeyu.api.modules.gao.service.GaoOrderPaymentService;
 import com.imyeyu.api.modules.gao.service.GaoSalesOrderService;
 import com.imyeyu.api.modules.gao.service.GaoStoreScopeService;
 import com.imyeyu.api.modules.gao.vo.GaoDirectProductOrderCreateRequest;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerProductPage;
 import com.imyeyu.api.modules.gao.vo.GaoCustomerProductCustomerView;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentActionRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentNoRefundRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentReceiveRequest;
@@ -15,7 +18,10 @@ import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentRefundRequest;
 import com.imyeyu.api.modules.gao.vo.GaoOrderPaymentRevokeRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderCancelRequest;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderPage;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderReceivableStatView;
 import com.imyeyu.api.modules.gao.vo.GaoSalesOrderUpdateRequest;
 import com.imyeyu.api.modules.user.service.UserService;
 import com.imyeyu.java.TimiJava;
 import com.imyeyu.java.bean.timi.TimiException;
 import com.imyeyu.spring.annotation.AOPLog;
 import com.imyeyu.spring.annotation.RequestRateLimit;
@@ -39,6 +45,7 @@ public class GaoSalesOrderController {
 	private final GaoSalesOrderService service;
 	private final GaoOrderPaymentService paymentService;
 	private final GaoStoreScopeService storeScopeService;
 	private final UserService userService;
 	@AOPLog
 	@RequestRateLimit
@@ -50,12 +57,36 @@ public class GaoSalesOrderController {
 		return service.pageByQuery(page);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)
 	@PostMapping("/summary")
 	public GaoSalesOrderReceivableStatView summary(@RequestBody GaoSalesOrderPage page) {
 		TimiException.required(page, "not found sales order summary page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		return service.summary(page);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)
 	@PostMapping("/customer-product/list")
 	public PageResult<GaoCustomerProductCustomerView> customerProductList(@RequestBody GaoCustomerProductPage page) {
 		TimiException.required(page, "not found customer product page");
 		page.setStoreId(storeScopeService.resolveStoreId(page.getStoreId()));
 		return service.pageCustomerProduct(page);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.SALES_ORDER_READ)
 	@PostMapping("/detail")
 	public GaoSalesOrder detail(@RequestParam String id) {
-		return service.detail(id);
+		GaoSalesOrder result = service.detail(id);
 		if (TimiJava.isNotEmpty(result.getCancelOperatorUserId())) {
 			result.setCancelOperator(userService.get(result.getCancelOperatorUserId()));
 		}
 		return result;
 	}
 	@AOPLog
@@ -94,6 +125,14 @@ public class GaoSalesOrderController {
 		return paymentService.receive(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(value = { GaoPermissionCode.FUND_RECEIVE_CREATE, GaoPermissionCode.FUND_RECEIVE_VERIFY }, mode = PermissionMatchMode.ALL)
 	@PostMapping("/payment/receive-and-verify")
 	public GaoFundRecord receiveAndVerify(@RequestBody GaoOrderPaymentReceiveRequest request) {
 		return paymentService.receiveAndVerify(request);
 	}
 	@AOPLog
 	@RequestRateLimit
 	@RequireGaoPermission(GaoPermissionCode.FUND_RECEIVE_VERIFY)
@@ -112,7 +151,7 @@ public class GaoSalesOrderController {
 	@AOPLog
 	@RequestRateLimit
-	@RequireGaoPermission(GaoPermissionCode.FUND_RECEIVE_CREATE)
+	@RequireGaoPermission(value = {GaoPermissionCode.FUND_RECEIVE_CREATE, GaoPermissionCode.FUND_RECORD_READ}, mode = PermissionMatchMode.ANY)
 	@PostMapping("/payment/cancel")
 	public GaoFundRecord cancelPayment(@RequestBody GaoOrderPaymentActionRequest request) {
 		return paymentService.cancel(request);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
timi	982b1ee3e4	Merge pull request 'v1.0.56' (#68 ) from dev into master Reviewed-on: #68	2026-09-25 15:43:52 +00:00
Timi	b6f20c976d	v1.0.56 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-25 23:43:25 +08:00
Timi	369da9f997	add main agent DSL	2026-09-25 22:07:42 +08:00
Timi	cd8e552d21	support sku filter	2026-09-25 22:07:31 +08:00
timi	05e28c2c6d	Merge pull request 'v1.0.55' (#67 ) from dev into master Reviewed-on: #67	2026-09-23 15:17:56 +00:00
Timi	b30434777d	v1.0.55 CI / build-deploy (pull_request) Successful in 27s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-23 23:15:19 +08:00
Timi	4aafb17214	add point chart	2026-09-23 21:54:39 +08:00
timi	c18d0e8a9f	Merge pull request 'v1.0.54' (#66 ) from dev into master Reviewed-on: #66	2026-09-22 17:09:48 +00:00
Timi	134218b56a	v1.0.54 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-23 01:07:17 +08:00
Timi	5a07bfb7e3	add sku filter	2026-09-23 00:14:18 +08:00
Timi	1203ccfa4a	with skuId for only once sku	2026-09-22 17:53:45 +08:00
Timi	7adea85e1f	update order remind content	2026-09-22 16:52:18 +08:00
timi	1b221b13d1	Merge pull request 'v1.0.53' (#65 ) from dev into master Reviewed-on: #65	2026-09-21 17:32:02 +00:00
Timi	48eaf2356f	v1.0.53 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-22 01:31:15 +08:00
Timi	970952d9fa	clone fulfillment attach to stock out	2026-09-21 23:59:13 +08:00
timi	135996ce19	Merge pull request 'v1.0.52' (#64 ) from dev into master Reviewed-on: #64	2026-09-20 17:22:39 +00:00
Timi	e5bfb59a1c	v1.0.52 CI / build-deploy (pull_request) Successful in 27s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-21 01:18:35 +08:00
Timi	51c1d20d3c	more filter for sales order	2026-09-20 15:40:03 +08:00
timi	6b85cddede	Merge pull request 'v1.0.51' (#63 ) from dev into master Reviewed-on: #63	2026-09-18 17:27:14 +00:00
Timi	9256e08cfc	v1.0.51 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-19 01:26:29 +08:00
Timi	d0dcd0283e	add customer order summary	2026-09-19 01:26:03 +08:00
Timi	76c5495c32	add package filter for SalesOrderPage	2026-09-18 18:28:15 +08:00
timi	e486f850f2	Merge pull request 'v1.0.50' (#62 ) from dev into master Reviewed-on: #62	2026-09-17 17:52:23 +00:00
Timi	cee7dd2442	v1.0.50 CI / build-deploy (pull_request) Successful in 28s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-18 01:51:00 +08:00
Timi	8f2545f271	add customer followup	2026-09-18 01:47:54 +08:00
timi	76c2f3a5fd	Merge pull request 'v1.0.49' (#61 ) from dev into master Reviewed-on: #61	2026-09-16 17:34:23 +00:00
Timi	b5a7c0d46c	v1.0.49 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-17 01:31:21 +08:00
Timi	088afbe5c1	update customer in list	2026-09-17 01:31:02 +08:00
Timi	0d155ec5b2	update AIAgent	2026-09-16 15:15:36 +08:00
Timi	7d53d31c3f	add GaoProductStockBatchRequest	2026-09-16 15:15:19 +08:00
Timi	cd8bcae5be	auto verify for order fulfillment and payment	2026-09-16 13:06:39 +08:00
Timi	a2b6253d1d	add customerCount for list event record	2026-09-16 12:54:39 +08:00
timi	bb542e7510	Merge pull request 'v1.0.48' (#60 ) from dev into master Reviewed-on: #60	2026-09-15 17:39:14 +00:00
Timi	6ac84c11b2	v1.0.48 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-16 01:34:19 +08:00
Timi	1192bee431	add AIAgent	2026-09-16 01:09:55 +08:00
Timi	c77813af0d	remove ./http	2026-09-15 11:00:14 +08:00
timi	eba4461381	Merge pull request 'v1.0.47' (#59 ) from dev into master Reviewed-on: #59	2026-09-14 17:30:09 +00:00
Timi	aa7b83ed1e	v1.0.47 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-15 01:25:48 +08:00
Timi	ac310414fe	add point redemption	2026-09-15 01:25:32 +08:00
timi	f5ad238015	Merge pull request 'v1.0.46' (#58 ) from dev into master Reviewed-on: #58	2026-09-14 06:14:05 +00:00
Timi	8618a00e5d	v1.0.46 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-14 14:12:57 +08:00
Timi	5f97a1933e	add GAO_HELP type	2026-09-14 14:12:42 +08:00
timi	4bdb24e9ac	Merge pull request 'v1.0.45' (#57 ) from dev into master Reviewed-on: #57	2026-09-13 18:13:38 +00:00
Timi	398e1b8095	v1.0.45 CI / build-deploy (pull_request) Successful in 26s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-14 02:13:15 +08:00
Timi	086d2b42e2	add SalesOrderStraightThroughRequest paymentAmount	2026-09-14 00:47:59 +08:00
timi	425922fd04	Merge pull request 'v1.0.44' (#56 ) from dev into master Reviewed-on: #56	2026-09-12 17:42:51 +00:00
Timi	b24d6b3a01	v1.0.44 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-13 01:37:51 +08:00
Timi	c35132d06b	total_earned DESC order for point account	2026-09-13 01:37:41 +08:00
Timi	91072d6d50	auto complete order	2026-09-13 01:25:48 +08:00
timi	d65424e5bf	Merge pull request 'v1.0.43' (#55 ) from dev into master Reviewed-on: #55	2026-09-11 17:26:21 +00:00
Timi	f0b72b70e7	v1.0.43 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-12 01:24:03 +08:00
Timi	daa5a6aa5e	fix off product sku for keep fulfillment	2026-09-12 01:23:47 +08:00
timi	2a35793baf	Merge pull request 'v1.0.42' (#54 ) from dev into master Reviewed-on: #54	2026-09-11 16:16:04 +00:00
Timi	4a157e9578	v1.0.42 CI / build-deploy (pull_request) Successful in 24s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-12 00:11:21 +08:00
Timi	eabb4c6aa6	fix event record CONTINUOUS_DAYS rank	2026-09-12 00:11:07 +08:00
timi	d22df698b6	Merge pull request 'v1.0.41' (#53 ) from dev into master Reviewed-on: #53	2026-09-11 15:55:02 +00:00
Timi	cb6051cc41	v1.0.41 CI / build-deploy (pull_request) Successful in 59s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-11 23:53:06 +08:00
Timi	1d1009b121	add customer list for GaoCustomerDailyStateView	2026-09-11 23:52:43 +08:00
Timi	94f3fbb867	add customer age and disease chart	2026-09-11 20:24:09 +08:00
timi	1771bf9909	Merge pull request 'v1.0.40' (#52 ) from dev into master Reviewed-on: #52	2026-09-10 16:29:28 +00:00
Timi	fc4d55517b	v1.0.40 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-11 00:26:14 +08:00
Timi	ec72a99d74	response customer pinyin	2026-09-11 00:24:58 +08:00
Timi	a431db6e6e	fix article detail request method	2026-09-10 20:27:53 +08:00
Timi	9cfb31b015	support pinyin for product	2026-09-10 20:27:32 +08:00
timi	15d69f9361	Merge pull request 'v1.0.39' (#51 ) from dev into master Reviewed-on: #51	2026-09-10 06:10:30 +00:00
Timi	b000390a75	v1.0.39 CI / build-deploy (pull_request) Successful in 24s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-10 14:09:49 +08:00
Timi	1b9f92caf5	add setting map	2026-09-10 14:09:38 +08:00
Timi	7b08641acc	add customer order map	2026-09-10 14:09:30 +08:00
Timi	66c13062b2	fix notify fail	2026-09-10 12:47:29 +08:00
timi	2b4089ef59	Merge pull request 'v1.0.38' (#50 ) from dev into master Reviewed-on: #50	2026-09-09 17:33:25 +00:00
Timi	cdf8a426e9	v1.0.38 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-10 01:31:20 +08:00
Timi	a2d69fe721	support gift	2026-09-10 01:31:06 +08:00
Timi	19db357b44	update article CRUD	2026-09-10 01:30:50 +08:00
Timi	07ffef3e2a	add cancel operator	2026-09-09 17:14:29 +08:00
timi	20c3e1f422	Merge pull request 'v1.0.37' (#49 ) from dev into master Reviewed-on: #49	2026-09-09 06:21:55 +00:00
Timi	f93ec3cd4d	v1.0.37 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-09 14:21:18 +08:00
Timi	3cdac98832	add allowDecimalQuantity	2026-09-09 14:21:04 +08:00
Timi	c122c35376	refactor LoggerService.excute	2026-09-09 13:04:16 +08:00
timi	3b19d9e930	Merge pull request 'v1.0.36' (#48 ) from dev into master Reviewed-on: #48	2026-09-08 17:52:47 +00:00
Timi	2ea06fb5c0	v1.0.36 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-09 01:49:52 +08:00
Timi	00bb300755	support split fulfillment by base unit	2026-09-09 01:49:40 +08:00
Timi	ea44dd5c0e	update point rule groovy script	2026-09-09 01:08:45 +08:00
Timi	818207d6c9	fix FileController	2026-09-08 18:09:31 +08:00
Timi	af76eb43b8	update SystemSetting	2026-09-08 16:52:32 +08:00
timi	5fd11e9caf	Merge pull request 'v1.0.35' (#47 ) from dev into master Reviewed-on: #47	2026-09-07 17:06:28 +00:00
Timi	d920b8630d	v1.0.35 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-08 01:05:45 +08:00
timi	0b98dcdfe9	Merge pull request 'v1.0.34' (#46 ) from dev into master Reviewed-on: #46	2026-09-07 15:11:06 +00:00
Timi	1e62576d36	v1.0.34 CI / build-deploy (pull_request) Successful in 25s Details CI / notify-on-failure (pull_request) Skipped Details	2026-09-07 23:10:27 +08:00