Merge pull request #569 from xinnan-tech/add-tag

update:0.1.16版本

.dockerignore

@@ -0,0 +1,7 @@
+.git
+__pycache__
+*.pyc
+.env
+Dockerfile
+tmp/
+data/

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug 报告（Bug Report）
+about: 反馈项目中的缺陷或问题
+title: "[Bug] 简短描述问题"
+labels: bug
+assignees: ''
+---
+
+## 🐛 问题描述
+<!-- 清晰简洁地描述问题是什么 -->
+
+## 🔍 复现步骤
+<!-- 详细描述复现问题的步骤 -->
+1. 打开 '...'
+2. 点击 '...'
+3. 滚动到 '...'
+4. 看到错误
+
+## 🤔 预期行为
+<!-- 简要描述预期的正确行为 -->
+
+## 😯 截图
+<!-- 如果适用，添加问题的截图 -->
+
+## 🖥️ 环境信息
+- 操作系统: [例如 Windows 10]
+- 浏览器: [例如 Chrome 89]
+- 项目版本: [例如 1.0.0]
+- Python版本: [例如 3.9.13]
+- Jdk版本：[例如 java 21.0.5 2024-10-15 LTS]
+- Nodejs版本：[例如 v20.14.0]
+
+## 📋 其他信息
+<!-- 在此添加关于此问题的任何其他上下文信息 -->

.github/ISSUE_TEMPLATE/code_improvement.md

@@ -0,0 +1,19 @@
+---
+name: 代码优化建议（Code Improvement）
+about: 提出对现有代码的优化或改进建议
+title: "[Improvement] 简短描述改进内容"
+labels: refactor
+assignees: ''
+---
+
+## 💡 改进描述
+<!-- 描述需要改进的代码部分以及存在的问题 -->
+
+## 🌟 改进建议
+<!-- 提出具体的改进方案或思路 -->
+
+## 🛠️ 相关代码
+<!-- 如果可能，提供相关代码片段或链接 -->
+
+## 📋 其他信息
+<!-- 在此添加任何其他相关信息 -->

.github/ISSUE_TEMPLATE/documentation_improvement.md

@@ -0,0 +1,16 @@
+---
+name: 文档改进建议（Documentation Improvement）
+about: 提出对项目文档的改进或补充建议
+title: "[Docs] 简短描述改进内容"
+labels: documentation
+assignees: ''
+---
+
+## 📚 改进描述
+<!-- 描述需要改进的文档部分以及存在的问题 -->
+
+## ✨ 改进建议
+<!-- 提出具体的改进方案或内容 -->
+
+## 📋 其他信息
+<!-- 在此添加任何其他相关信息 -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: 功能请求（Feature Request）
+about: 提出新的功能或改进建议
+title: "[Feature] 简短描述功能"
+labels: enhancement
+assignees: ''
+---
+
+## 🚀 需求描述
+<!-- 清晰简洁地描述你希望发生什么 -->
+
+## 🎯 解决方案
+<!-- 描述你认为可行的解决方案或实现方式 -->
+
+## 📝 备选方案
+<!-- 描述你考虑过的替代方案或功能 -->
+
+## 📋 其他信息
+<!-- 在此添加关于需求的任何其他上下文信息 -->

.github/workflows/docker-image.yml

@@ -7,30 +7,31 @@ on:
 
 jobs:
   release:
-    name: Release Docker image
+    name: Release Docker images
     runs-on: ubuntu-latest
     permissions:
       packages: write
       contents: write
       id-token: write
       issues: write
-
     steps:
       - name: Check Disk Space
         run: |
           df -h
           docker system df
+
       - name: Clean up Docker resources
         run: |
           docker system prune -af
           docker builder prune -af
-      - name: Check out the repo
+
+      - name: Checkout code
         uses: actions/checkout@v4
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
-      - name: Log in to the GitHub Container Registry
+      - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
@@ -42,13 +43,26 @@ jobs:
         run: |
           echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
 
-      - name: Build and push Docker image
+      # 构建 xiaozhi-server 镜像
-        id: build_push
+      - name: Build and push xiaozhi-server
         uses: docker/build-push-action@v6
         with:
           context: .
+          file: Dockerfile-server
           push: true
           tags: |
-            ghcr.io/${{ github.repository }}:${{ env.VERSION }}
+            ghcr.io/${{ github.repository }}:server_${{ env.VERSION }}
-            ghcr.io/${{ github.repository }}:latest
+            ghcr.io/${{ github.repository }}:server_latest
+          platforms: linux/amd64,linux/arm64
+
+      # 构建 manager-api 镜像
+      - name: Build and push manager-web
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile-web
+          push: true
+          tags: |
+            ghcr.io/${{ github.repository }}:web_${{ env.VERSION }}
+            ghcr.io/${{ github.repository }}:web_latest
           platforms: linux/amd64,linux/arm64

.gitignore

@@ -141,13 +141,18 @@ music/
 # Cython debug symbols
 cython_debug/
 *.iml
-model.pt
 tmp
+.history
 .DS_Store
 main/xiaozhi-server/data
+main/xiaozhi-server/config/assets/wakeup_words.*
 main/manager-web/node_modules
 .config.yaml
 .secrets.yaml
 .private_config.yaml
 .env.development
 
+# model files
+main/xiaozhi-server/models/SenseVoiceSmall/model.pt
+main/xiaozhi-server/models/sherpa-onnx*
+my_wakeup_words.mp3

Dockerfile-server

@@ -5,15 +5,15 @@ WORKDIR /app
 
 COPY main/xiaozhi-server/requirements.txt .
 
-# 优化apt安装
+# 安装Python依赖
 RUN pip install --no-cache-dir -r requirements.txt
 
-# 第三阶段：生产镜像
+# 第二阶段：生产镜像
 FROM python:3.10-slim
 
 WORKDIR /opt/xiaozhi-esp32-server
 
-# 优化apt安装
+# 安装系统依赖
 RUN apt-get update && \
     apt-get install -y --no-install-recommends libopus0 ffmpeg && \
     apt-get clean && \
@@ -23,7 +23,7 @@ RUN apt-get update && \
 COPY --from=builder /usr/local/lib/python3.10/site-packages /usr/local/lib/python3.10/site-packages
 
 # 复制应用代码
-COPY main/xiaozhi-server/ .
+COPY main/xiaozhi-server .
 
 # 启动应用
 CMD ["python", "app.py"]

Dockerfile-web

@@ -0,0 +1,40 @@
+# 第一阶段：构建Vue前端
+FROM node:18 as web-builder
+WORKDIR /app
+COPY main/manager-web/package*.json ./
+RUN npm install
+COPY main/manager-web .
+RUN npm run build
+
+# 第二阶段：构建Java后端
+FROM maven:3-eclipse-temurin-21-alpine as api-builder
+WORKDIR /app
+COPY main/manager-api/pom.xml .
+COPY main/manager-api/src ./src
+RUN mvn clean package -Dmaven.test.skip=true
+
+# 第三阶段：构建最终镜像
+FROM eclipse-temurin:21-jdk-jammy
+
+# 安装Nginx并清理缓存
+RUN apt-get update && \
+    apt-get install -y nginx && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# 配置Nginx
+COPY docs/docker/nginx.conf /etc/nginx/conf.d/default.conf
+
+# 复制前端构建产物
+COPY --from=web-builder /app/dist /usr/share/nginx/html
+
+# 复制Java后端JAR包
+COPY --from=api-builder /app/target/xiaozhi-esp32-api.jar /app/xiaozhi-esp32-api.jar
+
+# 暴露端口
+EXPOSE 8002
+
+# 启动脚本
+COPY docs/docker/start.sh /start.sh
+RUN chmod +x /start.sh
+CMD ["/start.sh"]

README.md

@@ -51,12 +51,19 @@
         </a>
     </td>
     <td>
-        <a href="https://www.bilibili.com/video/av114036381327149" target="_blank">
+        <a href="https://www.bilibili.com/video/BV1pNXWYGEx1" target="_blank">
          <picture>
            <img alt="控制家电开关" src="docs/images/demo5.png" />
          </picture>
         </a>
     </td>
+    <td>
+        <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
+         <picture>
+           <img alt="成本最低配置" src="docs/images/demo4.png" />
+         </picture>
+        </a>
+    </td>
   </tr>
   <tr>
     <td>
@@ -74,13 +81,25 @@
         </a>
     </td>
     <td>
-        <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
+        <a href="https://www.bilibili.com/video/BV1Z8XuYZEAS" target="_blank">
          <picture>
-           <img alt="成本最低配置" src="docs/images/demo4.png" />
+           <img alt="天气插件" src="docs/images/demo8.png" />
          </picture>
         </a>
     </td>
     <td>
+        <a href="https://www.bilibili.com/video/BV178XuYfEpi" target="_blank">
+         <picture>
+           <img alt="IOT指令控制设备" src="docs/images/demo9.png" />
+         </picture>
+        </a>
+    </td>
+    <td>
+        <a href="https://www.bilibili.com/video/BV17LXWYvENb" target="_blank">
+         <picture>
+           <img alt="播报新闻" src="docs/images/demo0.png" />
+         </picture>
+        </a>
     </td>
   </tr>
 </table>
@@ -92,14 +111,18 @@
 - **硬件**：一套兼容 `xiaozhi-esp32`
   的硬件设备（具体型号请参考 [此处](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf)）。
 
-- **电脑或服务器**：至少 4 核 CPU、8G 内存的电脑。
+- **电脑或服务器**：建议 4 核 CPU、8G 内存的电脑。如果开启ASR也使用API，可运行在2核CPU、2G内存的服务器中。
 - **固件编译**：请将本后端服务的接口地址更新至 `xiaozhi-esp32` 项目中，再重新编译`xiaozhi-esp32`固件并烧录到设备上。
 
+![图片](docs/images/deploy.png)
+
 如果你没有esp32相关的硬件设备，但是非常想体验该项目，可以使用以下的项目让你的电脑、手机模拟成esp32设备。
 
 - [小智安卓端](https://github.com/TOM88812/xiaozhi-android-client)
 - [小智电脑端](https://github.com/Huang-junsen/py-xiaozhi)
 
+如果你是一名软件开发者，这里有一份[《致开发者的公开信》](docs/contributor_open_letter.md)，欢迎加入！
+
 ---
 
 ## 警告 ⚠️
@@ -129,55 +152,70 @@ server:
   基于 `xiaozhi-esp32` 协议，通过 WebSocket 实现数据交互。
 - **对话交互**  
   支持唤醒对话、手动对话及实时打断。长时间无对话时自动休眠
+- **意图识别**  
+  支持使用LLM意图识别、function call函数调用，减少硬编码意图判断
 - **多语言识别**  
   支持国语、粤语、英语、日语、韩语（默认使用 FunASR）。
 - **LLM 模块**  
   支持灵活切换 LLM 模块，默认使用 ChatGLMLLM，也可选用阿里百炼、DeepSeek、Ollama 等接口。
 - **TTS 模块**  
   支持 EdgeTTS（默认）、火山引擎豆包 TTS 等多种 TTS 接口，满足语音合成需求。
+- **记忆功能**  
+  支持超长记忆、本地总结记忆、无记忆三种模式，满足不同场景需求。
+- **IOT功能**  
+  支持管理注册设备IOT功能，支持基于对话上下文语境下的智能物联网控制。
 
 ### 正在开发 🚧
 
-- 对话记忆功能
 - 多种心情模式
 - 智控台webui
 
+想了解具体开发进度，[请点击这里](https://github.com/users/xinnan-tech/projects/3)
+
 ![图片](docs/images/webui.png)
 ---
 
 ## 本项目支持的平台/组件列表 📋
 
-### LLM
+### LLM 语言模型
 
-| 类型  |        平台名称        |         使用方式          |   收费模式   |                                备注                                 |
+| 类型  |        平台名称        |         使用方式          |    收费模式     |                                                           备注                                                            |
-|:---:|:------------------:|:---------------------:|:--------:|:-----------------------------------------------------------------:|
+|:---:|:------------------:|:---------------------:|:-----------:|:-----------------------------------------------------------------------------------------------------------------------:|
-| LLM |   阿里百炼 (AliLLM)    |      openai 接口调用      | 消耗 token |  [点击申请密钥](https://bailian.console.aliyun.com/?apiKey=1#/api-key)  |
+| LLM |   阿里百炼 (AliLLM)    |      openai 接口调用      |  消耗 token   |                             [点击申请密钥](https://bailian.console.aliyun.com/?apiKey=1#/api-key)                             |
-| LLM | 深度求索 (DeepSeekLLM) |      openai 接口调用      | 消耗 token |             [点击申请密钥](https://platform.deepseek.com/)              |
+| LLM |     DoubaoLLM      |      openai 接口调用      |  消耗 token   | [点击申请密钥](https://console.volcengine.com/ark/region:ark+cn-beijing/model/detail?Id=doubao-pro-32k&projectName=undefined) |
-| LLM |   智谱（ChatGLMLLM）   |      openai 接口调用      |    免费    | 虽然免费，仍需[点击申请密钥](https://bigmodel.cn/usercenter/proj-mgmt/apikeys) |
+| LLM | 深度求索 (DeepSeekLLM) |      openai 接口调用      |  消耗 token   |                                        [点击申请密钥](https://platform.deepseek.com/)                                         |
-| LLM |     OllamaLLM      |      ollama 接口调用      |  免费/自定义  |       需预先下载模型（`ollama pull`），服务地址：`http://localhost:11434`        |
+| LLM |   智谱（ChatGLMLLM）   |      openai 接口调用      |     免费      |                            虽然免费，仍需[点击申请密钥](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)                            |
-| LLM |      DifyLLM       |       dify 接口调用       | 消耗 token |                    本地化部署，注意配置提示词需在 Dify 控制台设置                     |
+| LLM |     OllamaLLM      |      ollama 接口调用      | 免费/消耗 token |                                  需预先下载模型（`ollama pull`），服务地址：`http://localhost:11434`                                   |
-| LLM |     GeminiLLM      |      gemini 接口调用      |    免费    |           [点击申请密钥](https://aistudio.google.com/apikey)            |
+| LLM |      DifyLLM       |       dify 接口调用       | 免费/消耗 token |                                               本地化部署，注意配置提示词需在 Dify 控制台设置                                                |
-| LLM |      CozeLLM       |       coze 接口调用       | 消耗 token |                     需提供 bot_id、user_id 及个人令牌                      |
+| LLM |     FastgptLLM     |     fastgpt 接口调用      | 免费/消耗 token |                                              本地化部署，注意配置提示词需在 Fastgpt 控制台设置                                              |
-| LLM |   Home Assistant   | homeassistant语音助手接口调用 |    免费    |                        需提供home assistant令牌                        |
+| LLM |     GeminiLLM      |      gemini 接口调用      |     免费      |                                      [点击申请密钥](https://aistudio.google.com/apikey)                                       |
+| LLM |      CozeLLM       |       coze 接口调用       |  消耗 token   |                                                需提供 bot_id、user_id 及个人令牌                                                 |
 
 实际上，任何支持 openai 接口调用的 LLM 均可接入使用。
 
 ---
 
-### TTS
+### TTS 语音合成
 
 | 类型  |          平台名称          | 使用方式 |   收费模式   |                                    备注                                     |
 |:---:|:----------------------:|:----:|:--------:|:-------------------------------------------------------------------------:|
 | TTS |        EdgeTTS         | 接口调用 |    免费    |                             默认 TTS，基于微软语音合成技术                             |
 | TTS | 火山引擎豆包 TTS (DoubaoTTS) | 接口调用 | 消耗 token | [点击创建密钥](https://console.volcengine.com/speech/service/8)；建议使用付费版本以获得更高并发 |
+| TTS |       AliyunTTS        | 接口调用 | 消耗 token |          [点击创建密钥](https://nls-portal.console.aliyun.com/applist)          |
 | TTS |  CosyVoiceSiliconflow  | 接口调用 | 消耗 token |                         需申请硅基流动 API 密钥；输出格式为 wav                          |
+| TTS |        TTS302AI        | 接口调用 | 消耗 token |                  [点击创建密钥](https://dash.302.ai/apis/list)                  |
 | TTS |       CozeCnTTS        | 接口调用 | 消耗 token |                        需提供 Coze API key；输出格式为 wav                         |
+| TTS |       GizwitsTTS       | 接口调用 | 消耗 token |                  [点击创建密钥](https://agentrouter.gizwitsapi.com)                  |
+| TTS |        ACGNTTS         | 接口调用 | 消耗 token |                        [联系网站管理员购买密钥](www.ttson.cn)                        |
+| TTS |       OpenAITTS        | 接口调用 | 消耗 token |                                 境外使用，境外购买                                 |
 | TTS |       FishSpeech       | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务；启动方法见配置文件内说明                          |
 | TTS |     GPT_SOVITS_V2      | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
+| TTS |     GPT_SOVITS_V3      | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
+| TTS |       MinimaxTTS       | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
 
 ---
 
-### VAD
+### VAD 语音活动检测
 
 | 类型  |   平台名称    | 使用方式 | 收费模式 | 备注 |
 |:---:|:---------:|:----:|:----:|:--:|
@@ -185,20 +223,32 @@ server:
 
 ---
 
-### ASR
+### ASR 语音识别
 
 | 类型  |   平台名称    | 使用方式 | 收费模式 | 备注 |
 |:---:|:---------:|:----:|:----:|:--:|
 | ASR |  FunASR   | 本地使用 |  免费  |    |
+| ASR | SherpaASR | 本地使用 |  免费  |    |
 | ASR | DoubaoASR | 接口调用 |  收费  |    |
 
+
 ---
 
-### Memory
+### Memory 记忆存储
 
-|   类型   |  平台名称  | 使用方式 | 收费模式 | 备注 |
+|   类型   |      平台名称       | 使用方式 |   收费模式    | 备注 |
-|:------:|:------:|:----:|:----:|:--:|
+|:------:|:---------------:|:----:|:---------:|:--:|
-| Memory | mem0ai | 接口调用 |  免费  |    |
+| Memory |     mem0ai      | 接口调用 | 1000次/月额度 |    |
+| Memory | mem_local_short | 本地总结 |    免费     |    |
+
+---
+
+### Intent 意图识别
+
+|   类型   |     平台名称      | 使用方式 |  收费模式   |          备注           |
+|:------:|:-------------:|:----:|:-------:|:---------------------:|
+| Intent |  intent_llm   | 接口调用 | 根据LLM收费 |    通过大模型识别意图，通用性强     |
+| Intent | function_call | 接口调用 | 根据LLM收费 | 通过大模型函数调用完成意图，速度快，效果好 |
 
 ---
 
@@ -208,14 +258,9 @@ server:
 
 本项目支持以下三种部署方式，您可根据实际需求选择。
 
-本项目的文档主要是`文字版本`的教程，如果你想要`视频版本`
-的教程，您可以学习一下[这个大佬的手把手教程](https://www.bilibili.com/video/BV1gePuejEvT)。
-
-如果你能把`文字版本的教程`和`视频版本的教程`结合起来一起看，可以让你更快上手。
-
 1. [Docker 快速部署](./docs/Deployment.md)
 
-适合快速体验的普通用户，不需过多环境配置。缺点是，拉取镜像有点慢。
+适合快速体验的普通用户，不需过多环境配置。缺点是，拉取镜像有点慢。视频教程可参考[美女大佬教你Docker部署](https://www.bilibili.com/video/BV1RNQnYDE5t)
 
 2. [借助 Docker 环境运行部署](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E5%80%9F%E5%8A%A9docker%E7%8E%AF%E5%A2%83%E8%BF%90%E8%A1%8C%E9%83%A8%E7%BD%B2)
 
@@ -225,45 +270,24 @@ server:
 
 适合熟悉`Conda` 环境或希望从零搭建运行环境的用户。
 
-对于对响应速度要求较高的场景，推荐使用本地源码运行方式以降低额外开销。
+对于对响应速度要求较高的场景，推荐使用本地源码运行方式以降低额外开销。视频教程可参考[帅哥大佬教你源码部署](https://www.bilibili.com/video/BV1GvQWYZEd2)
 
 ### 二、[固件编译](./docs/firmware-build.md)
 
 点这里查看[固件编译](./docs/firmware-build.md)的详细过程。
 
-编译成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。
+烧录成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。
 
 ---
 
 ## 常见问题 ❓
 
-### 1、TTS 经常失败，经常超时 ⏰
+### 1、为什么我说的话，小智识别出来很多韩文、日文、英文？🇰🇷
-
-建议：如果 `EdgeTTS` 经常失败，请先检查是否使用了代理（梯子）。如果使用了，请尝试关闭代理后再试；  
-如果用的是火山引擎的豆包 TTS，经常失败时建议使用付费版本，因为测试版本仅支持 2 个并发。
-
-### 2、我想通过小智控制电灯、空调、远程开关机等操作 💡
-
-建议：在配置文件中将 `LLM` 设置为 `HomeAssistant`，通过 调用`HomeAssistant`接口实现相关控制。
-
-### 3、我说话很慢，停顿时小智老是抢话 🗣️
-
-建议：在配置文件中找到如下部分，将 `min_silence_duration_ms` 的值调大（例如改为 `1000`）：
-
-```yaml
-VAD:
-  SileroVAD:
-    threshold: 0.5
-    model_dir: models/snakers4_silero-vad
-    min_silence_duration_ms: 700  # 如果说话停顿较长，可将此值调大
-```
-
-### 4、为什么我说的话，小智识别出来很多韩文、日文、英文？🇰🇷
 
 建议：检查一下`models/SenseVoiceSmall`是否已经有`model.pt`
 文件，如果没有就要下载，查看这里[下载语音识别模型文件](docs/Deployment.md#模型文件)
 
-### 5、为什么会出现“TTS 任务出错 文件不存在”？📁
+### 2、为什么会出现“TTS 任务出错 文件不存在”？📁
 
 建议：检查一下是否正确使用`conda` 安装了`libopus`和`ffmpeg`库。
 
@@ -274,7 +298,12 @@ conda install conda-forge::libopus
 conda install conda-forge::ffmpeg
 ```
 
-### 6、如何提高小智对话响应速度？ ⚡
+### 3、TTS 经常失败，经常超时 ⏰
+
+建议：如果 `EdgeTTS` 经常失败，请先检查是否使用了代理（梯子）。如果使用了，请尝试关闭代理后再试；  
+如果用的是火山引擎的豆包 TTS，经常失败时建议使用付费版本，因为测试版本仅支持 2 个并发。
+
+### 4、如何提高小智对话响应速度？ ⚡
 
 本项目默认配置为低成本方案，建议初学者先使用默认免费模型，解决“跑得动”的问题，再优化“跑得快”。  
 如需提升响应速度，可尝试更换各组件。以下为各组件的响应速度测试数据（仅供参考，不构成承诺）：
@@ -305,7 +334,6 @@ LLM 性能排行:
 |:-----------|:-----------|:--------|
 | AliLLM     | 0.547s     | 1.485s  |
 | ChatGLMLLM | 0.677s     | 3.057s  |
-| OllamaLLM  | 0.003s     | 0.003s  |
 
 TTS 性能排行:
 
@@ -332,6 +360,56 @@ TTS 性能排行:
 - LLM：`AliLLM`
 - TTS：`DoubaoTTS`
 
+### 5、我说话很慢，停顿时小智老是抢话 🗣️
+
+建议：在配置文件中找到如下部分，将 `min_silence_duration_ms` 的值调大（例如改为 `1000`）：
+
+```yaml
+VAD:
+  SileroVAD:
+    threshold: 0.5
+    model_dir: models/snakers4_silero-vad
+    min_silence_duration_ms: 700  # 如果说话停顿较长，可将此值调大
+```
+
+### 6、我想通过小智控制电灯、空调、远程开关机等操作 💡
+
+本项目，支持以工具调用的方式控制HomeAssistant设备
+
+1、首先选择一款支持function call支持的LLM，例如`ChatGLMLLM`。
+
+2、在配置文件中，将 `selected_module.Intent` 设置为 `function_call`。
+
+3、登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。
+
+在配置文件中，配置好你的home assistant的`devices`（被控制的设备）和`api_key`和`base_url`等信息。例如：
+
+``` yaml 
+plugins
+  home_assistant:
+    devices:
+      - 客厅,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1
+      - 卧室,台灯,switch.iot_cn_831898993_socn1_on_p_2_1
+    base_url: http://你的homeassistant地址:8123
+    api_key: 你的home assistant api访问令牌
+```
+
+最后，允许function_call 插件在配置文件中启用`hass_get_state`(必须)、`hass_set_state`(必须)、`hass_play_music`(不想用ha听音乐可以不启动)，例如：
+
+``` yaml 
+Intent:
+  ...
+  function_call:
+    type: nointent
+    functions:
+      - change_role
+      - get_weather
+      - get_news
+      - hass_get_state
+      - hass_set_state
+      - hass_play_music
+```
+
 ### 7、更多问题，可联系我们反馈 💬
 
 我们的联系方式放在[百度网盘中,点击前往](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，提取码是`223y`。
@@ -355,4 +433,4 @@ TTS 性能排行:
    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
  </picture>
-</a>
+</a>

README_en.md

@@ -165,6 +165,7 @@ In fact, any LLM that supports OpenAI API calls can be integrated.
 | Type |    Platform Name    | Usage Method | Pricing Model | Remarks |
 |:----:|:-------------------:|:------------:|:-------------:|:-------:|
 | ASR  | FunASR              | Local        | Free          |         |
+| ASR  | SherpaASR           | Local        | Free          |         |
 | ASR  | DoubaoASR           | API call     | Paid          |         |
 
 ---

docker-setup.sh

@@ -0,0 +1,105 @@
+#!/bin/sh
+# 本文件是用于一键自动下载本项目所需文件，自动创建好目录
+# 所需条件（否则无法使用）：
+# 1、请确保你的环境可以正常访问 GitHub 否则无法下载脚本
+#
+# 检测操作系统类型
+case "$(uname -s)" in
+    Linux*)     OS=Linux;;
+    Darwin*)    OS=Mac;;
+    CYGWIN*)    OS=Windows;;
+    MINGW*)     OS=Windows;;
+    MSYS*)      OS=Windows;;
+    *)          OS=UNKNOWN;;
+esac
+
+# 设置颜色（Windows CMD 不支持，但不影响使用）
+if [ "$OS" = "Windows" ]; then
+    GREEN=""
+    RED=""
+    NC=""
+else
+    GREEN='\033[0;32m'
+    RED='\033[0;31m'
+    NC='\033[0m'
+fi
+
+echo "${GREEN}开始安装小智服务端...${NC}"
+
+# 创建必要的目录
+echo "创建目录结构..."
+mkdir -p xiaozhi-server/data xiaozhi-server/models/SenseVoiceSmall
+cd xiaozhi-server || exit
+
+# 根据操作系统选择下载命令
+if [ "$OS" = "Windows" ]; then
+    DOWNLOAD_CMD="curl -L -o"
+    if ! command -v curl >/dev/null 2>&1; then
+        DOWNLOAD_CMD="powershell -Command Invoke-WebRequest -Uri"
+        DOWNLOAD_CMD_SUFFIX="-OutFile"
+    fi
+else
+    if command -v curl >/dev/null 2>&1; then
+        DOWNLOAD_CMD="curl -L -o"
+    elif command -v wget >/dev/null 2>&1; then
+        DOWNLOAD_CMD="wget -O"
+    else
+        echo "${RED}错误: 需要安装 curl 或 wget${NC}"
+        exit 1
+    fi
+fi
+
+# 下载语音识别模型
+echo "下载语音识别模型..."
+if [ "$DOWNLOAD_CMD" = "powershell -Command Invoke-WebRequest -Uri" ]; then
+    $DOWNLOAD_CMD "https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt" $DOWNLOAD_CMD_SUFFIX "models/SenseVoiceSmall/model.pt"
+else
+    $DOWNLOAD_CMD "models/SenseVoiceSmall/model.pt" "https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt"
+fi
+
+if [ $? -ne 0 ]; then
+    echo "${RED}模型下载失败。请手动从以下地址下载：${NC}"
+    echo "1. https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt"
+    echo "2. 百度网盘: https://pan.baidu.com/share/init?surl=QlgM58FHhYv1tFnUT_A8Sg (提取码: qvna)"
+    echo "下载后请将文件放置在 models/SenseVoiceSmall/model.pt"
+fi
+
+# 下载配置文件
+echo "下载配置文件..."
+if [ "$DOWNLOAD_CMD" = "powershell -Command Invoke-WebRequest -Uri" ]; then
+    $DOWNLOAD_CMD "https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/main/main/xiaozhi-server/docker-compose.yml" $DOWNLOAD_CMD_SUFFIX "docker-compose.yml"
+    $DOWNLOAD_CMD "https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/main/main/xiaozhi-server/config.yaml" $DOWNLOAD_CMD_SUFFIX "data/.config.yaml"
+else
+    $DOWNLOAD_CMD "docker-compose.yml" "https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/main/main/xiaozhi-server/docker-compose.yml"
+    $DOWNLOAD_CMD "data/.config.yaml" "https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/main/main/xiaozhi-server/config.yaml"
+fi
+
+# 检查文件是否存在
+echo "检查文件完整性..."
+FILES_TO_CHECK="docker-compose.yml data/.config.yaml models/SenseVoiceSmall/model.pt"
+ALL_FILES_EXIST=true
+
+for FILE in $FILES_TO_CHECK; do
+    if [ ! -f "$FILE" ]; then
+        echo "${RED}错误: $FILE 不存在${NC}"
+        ALL_FILES_EXIST=false
+    fi
+done
+
+if [ "$ALL_FILES_EXIST" = false ]; then
+    echo "${RED}某些文件下载失败，请检查上述错误信息并手动下载缺失的文件。${NC}"
+    exit 1
+fi
+
+echo "${GREEN}文件下载完成！${NC}"
+echo "请编辑 data/.config.yaml 文件配置你的API密钥。"
+echo "配置完成后，运行以下命令启动服务："
+echo "${GREEN}docker-compose up -d${NC}"
+echo "查看日志请运行："
+echo "${GREEN}docker logs -f xiaozhi-esp32-server${NC}"
+
+# 提示用户编辑配置文件
+echo "\n${RED}重要提示：${NC}"
+echo "1. 请确保编辑 data/.config.yaml 文件，配置必要的API密钥"
+echo "2. 特别是 ChatGLM 和 mem0ai 的密钥必须配置"
+echo "3. 配置完成后再启动 docker 服务"

docs/Deployment.md

@@ -1,3 +1,5 @@
+# 部署方案参考
+![图片](images/deploy.png)
 # 方式一：docker快速部署
 
 docker镜像已支持x86架构、arm64架构的CPU，支持在国产操作系统上运行。
@@ -6,7 +8,45 @@ docker镜像已支持x86架构、arm64架构的CPU，支持在国产操作系统
 
 如果您的电脑还没安装docker，可以按照这里的教程安装：[docker安装](https://www.runoob.com/docker/ubuntu-docker-install.html)
 
-## 2. 创建目录
+如果你已经安装好docker，你可以[1.1使用懒人脚本](#11-懒人脚本)自动帮你下载所需的文件和配置文件，你可以使用docker[1.2手动部署](#12-手动部署)。
+
+### 1.1 懒人脚本
+
+你可以使用以下命令一键下载并执行部署脚本：
+请确保你的环境可以正常访问 GitHub 否则无法下载脚本。
+```bash
+curl -L -o docker-setup.sh https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/main/docker-setup.sh
+```
+
+如果您的电脑是windows系统，请使用使用 Git Bash、WSL、PowerShell 或 CMD 运行以下命令：
+```bash
+# Git Bash 或 WSL
+sh docker-setup.sh
+# PowerShell 或 CMD
+.\docker-setup.sh
+```
+
+如果您的电脑是linux 或者 macos 系统，请使用终端运行以下命令：
+```bash
+chmod +x docker-setup.sh
+./docker-setup.sh
+```
+
+脚本会自动完成以下操作：
+> 1. 创建必要的目录结构
+> 2. 下载语音识别模型
+> 3. 下载配置文件
+> 4. 检查文件完整性
+>
+> 执行完成后，请按照提示配置 API 密钥。
+
+当你一切顺利完成以上操作后，继续操作[配置项目文件](#3-配置项目文件)
+
+### 1.2 手动部署
+
+如果懒人脚本无法正常运行，请按本章节1.2进行手动部署。
+
+#### 1.2.1 创建目录
 
 安装完后，你需要为这个项目找一个安放配置文件的目录，例如我们可以新建一个文件夹叫`xiaozhi-server`。
 
@@ -21,14 +61,18 @@ xiaozhi-server
      ├─ SenseVoiceSmall
 ```
 
-## 4. 下载语音识别模型文件
+#### 1.2.2 下载语音识别模型文件
 
 你需要下载语音识别的模型文件，因为本项目的默认语音识别用的是本地离线语音识别方案。可通过这个方式下载
 [跳转到下载语音识别模型文件](#模型文件)
 
 下载完后，回到本教程。
 
-## 3. 下载docker-compose.yaml
+#### 1.2.3 下载配置文件
+
+你需要下载两个配置文件：`docker-compose.yaml` 和 `config.yaml`。需要从项目仓库下载这两个文件。
+
+##### 1.2.3.1 下载 docker-compose.yaml
 
 用浏览器打开[这个链接](../main/xiaozhi-server/docker-compose.yml)。
 
@@ -37,7 +81,7 @@ xiaozhi-server
 
 下载完后，回到本教程继续往下。
 
-## 3. 下载配置文件
+##### 1.2.3.2 下载 config.yaml
 
 用浏览器打开[这个链接](../main/xiaozhi-server/config.yaml)。
 
@@ -58,14 +102,14 @@ xiaozhi-server
 
 如果你的文件目录结构也是上面的，就继续往下。如果不是，你就再仔细看看是不是漏操作了什么。
 
-## 4. 配置项目文件
+## 3. 配置项目文件
 
 接下里，程序还不能直接运行，你需要配置一下，你到底使用的是什么模型。你可以看这个教程：
 [跳转到配置项目文件](#配置项目)
 
 配置完项目文件后，回到本教程继续往下。
 
-## 5. 执行docker命令
+## 4. 执行docker命令
 
 打开命令行工具，使用`终端`或`命令行`工具 进入到你的`xiaozhi-server`，执行以下命令
 
@@ -81,22 +125,22 @@ docker logs -f xiaozhi-esp32-server
 
 这时，你就要留意日志信息，可以根据这个教程，判断是否成功了。[跳转到运行状态确认](#运行状态确认)
 
-## 6.版本升级操作
+## 5. 版本升级操作
 
 如果后期想升级版本，可以这么操作
 
-1、备份好`data`文件夹中的`.config.yaml`文件，一些关键的配置到时复制到新的`.config.yaml`文件里。
+5.1、备份好`data`文件夹中的`.config.yaml`文件，一些关键的配置到时复制到新的`.config.yaml`文件里。
 请注意是对关键密钥逐个复制，不要直接覆盖。因为新的`.config.yaml`文件可能有一些新的配置项，旧的`.config.yaml`文件不一定有。
 
-2、执行以下命令
+5.2、执行以下命令
 
 ```
 docker stop xiaozhi-esp32-server
 docker rm xiaozhi-esp32-server
-docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:latest
+docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:server_latest
 ```
 
-3、重新按docker方式部署
+5.3、重新按docker方式部署
 
 # 方式二：借助Docker环境运行部署
 
@@ -117,7 +161,7 @@ docker run -it --name xiaozhi-env --restart always --security-opt seccomp:unconf
   -p 8000:8000 \
   -p 8002:8002 \
   -v ./:/app \
-  kalicyh/poetry:v3.10_xiaozhi
+  kalicyh/python:xiaozhi
 ```
 
 然后就和正常开发一样了
@@ -127,29 +171,13 @@ docker run -it --name xiaozhi-env --restart always --security-opt seccomp:unconf
 在刚刚的打开的终端运行
 
 ```sh
-poetry install --no-root
+pip install -r requirements.txt
-```
-
-```sh
-apt-get update
-apt-get install -y --no-install-recommends libopus0 ffmpeg
-```
-
-速度慢可以尝试使用清华镜像
-
-```sh
-echo "deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bookworm main contrib non-free non-free-firmware" > /etc/apt/sources.list
-echo "deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bookworm-updates main contrib non-free non-free-firmware" >> /etc/apt/sources.list
-echo "deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bookworm-backports main contrib non-free non-free-firmware" >> /etc/apt/sources.list
-echo "deb https://mirrors.tuna.tsinghua.edu.cn/debian-security bookworm-security main contrib non-free non-free-firmware" >> /etc/apt/sources.list
-apt-get update
-apt-get install -y --no-install-recommends libopus0 ffmpeg
 ```
 
 ## 6.运行项目
 
 ```sh
-poetry run python app.py
+python app.py
 ```
 
 # 方式三：本地源码运行
@@ -233,20 +261,23 @@ python app.py
 如果你的`xiaozhi-server`目录没有`data`，你需要创建`data`目录。
 如果你的`data`下面没有`.config.yaml`文件，你可以把源码目录下的`config.yaml`文件复制一份，重命名为`.config.yaml`
 
-修改`xiaozhi-server`下`data`目录下的`.config.yaml`文件，配置本项目必须的两个配置。
+修改`xiaozhi-server`下`data`目录下的`.config.yaml`文件，配置本项目必须的一个配置。
 
 - 默认的LLM使用的是`ChatGLMLLM`，你需要配置密钥，因为他们的模型，虽然有免费的，但是仍要去[官网](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)注册密钥，才能启动。
-- 默认的记忆层`mem0ai`，你需要配置密钥，因为他们的API，虽然有免费额度，但是仍要去[官网](https://app.mem0.ai/dashboard/api-keys)注册密钥，才能启动。
 
 配置说明：这里是各个功能使用的默认组件，例如LLM默认使用`ChatGLMLLM`模型。如果需要切换模型，就是改对应的名称。
 本项目的默认配置仅是成本最低配置（`glm-4-flash`和`EdgeTTS`都是免费的），如果需要更优的更快的搭配，需要自己结合部署环境切换各组件的使用。
 
 ```
 selected_module:
-  ASR: FunASR
   VAD: SileroVAD
+  ASR: FunASR
   LLM: ChatGLMLLM
   TTS: EdgeTTS
+  # 默认不开启记忆，如需开启请看配置文件里的描述
+  Memory: nomem   
+  # 默认不开启意图识别，如需开启请看配置文件里的描述
+  Intent: nointent
 ```
 
 比如修改`LLM`使用的组件，就看本项目支持哪些`LLM` API接口，当前支持的是`openai`、`dify`。欢迎验证和支持更多LLM平台的接口。
@@ -265,8 +296,6 @@ LLM:
     ...
 ```
 
-有些服务，比如如果你使用`Dify`、`豆包的TTS`，是需要密钥的，记得在配置文件加上哦！
-
 ## 模型文件
 
 本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
@@ -294,4 +323,19 @@ LLM:
 
 这个信息很有用的，后面`编译esp32固件`需要用到。
 
-接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+
+
+以下是一些常见问题，供参考：
+
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+
+[2、为什么会出现“TTS 任务出错 文件不存在”？](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+
+[3、TTS 经常失败，经常超时](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+
+[4、如何提高小智对话响应速度？](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+
+[5、我说话很慢，停顿时小智老是抢话](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+
+[6、我想通过小智控制电灯、空调、远程开关机等操作](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)

docs/contributor_open_letter.md

@@ -0,0 +1,50 @@
+# 致开发者的公开信
+
+"春江水暖鸭先知，正是河豚欲上时！"
+
+亲爱的朋友，我是John，是一名普通公司里的Java程序员，今天，我怀着无比真挚的心情，向热爱AI技术与创新的你发出这封公开信。
+
+半年前我看到很多优秀的项目，比如`Dify`、`Chat2DB`等人工智能相关的项目，我在想，我要是能参与这些项目多好，可惜“报国无门，空打十年代码”。
+
+我是2025年初刷到虾哥团队的视频，我非常好奇他是怎么实现的，我想复刻他们的后端服务，打造一个低成本民用贾维斯。很可惜现在做的作品依然只是一个人工智障，它并发低、没有灵魂，响应很慢，bug很多。
+
+虾哥团队是我们学习的对象，我很想拥有像虾哥团队一样智能的小智后端服务。但是我也能理解虾哥不开源的决定。“一花独放不是春，百花齐放春满园”，人工智能遍地开花的时代，也许就在我们这代实现，我们可以用自己的双手，实现低成本民用贾维斯。我个人认为，他能实现的，我们也能实现，只是时间问题而已，我称之为“我们的取经之路”。
+
+那么这条取经之路，我们会遇到什么困难？我想应该不少于八十一难。这一路必然会出现各种妖怪，当然也有神仙暗中帮助我们，也有人加入取经队伍。
+
+以上内容，如果你觉得好笑。那我也觉得非常的幸运。我能够在你人生3万多天里博你笑五秒，也算是为你做了一次贡献。
+
+民用低成本贾维斯这个想法，会失败吗，我不知道，但是我们普通人的一生，这种失败不是很常见吗？
+
+未来，有一点是可以确定的，就一定会有人完全复刻虾哥团队的功能，实现民用低成本贾维斯。这个项目会是我们吗？
+
+期待与你携手前行，共创未来。
+
+John，2025.3.11，广州
+
+# 附 开发贡献指南
+## 项目目标
+
+1. **民用低成本贾维斯解决方案**  
+
+2. **智能联动周边硬件的解决方案**  
+
+## 加入我们
+
+我们热忱欢迎志同道合的朋友加入，共同为项目贡献力量。您可在[这个链接](https://github.com/users/xinnan-tech/projects/3)查看我们近期要实现的功能，功能列表中还没指派相关人员处理的，正是急需您的参与。参与方式如下：
+
+### 1、成为普通贡献者
+
+Fork 项目，提交 PR，由开发者审核后合入主分支。
+
+### 2、成为开发者
+
+当你累计提交 3 次有效 PR 后，可以联系群主申请成为开发者，群主将邀请你加入独立的开发者群，共同探讨项目未来。
+
+## 开发者开发流程
+
+1. **创建新分支**  
+   每个功能点请以新分支方式开发，分支名称应简洁明了，让人一眼看出所实现的功能，避免功能撞车。
+
+2. **提交 PR 审核**  
+   功能开发完成后，请在 GitHub 上提交 PR，由其他开发者审核，审核通过后合并入主分支。

docs/docker-build.md

@@ -8,41 +8,14 @@ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin
 ```
 2、编译docker镜像
 ```
-#进入xiaozhi-server目录
+#进入项目根目录
-cd main/xiaozhi-server/
+# 编译server
-# 普通编译
+docker build -t xiaozhi-esp32-server:server_latest -f ./Dockerfile-server .
-docker build -t xiaozhi-esp32-server:local -f ./Dockerfile-pip .
+# 编译web
-```
+docker build -t xiaozhi-esp32-server:web_latest -f ./Dockerfile-web .
-3、测试本地镜像
-```
-docker stop xiaozhi-esp32-server
-docker rm xiaozhi-esp32-server
-
-docker run -d --name xiaozhi-esp32-server --restart always -p 8000:8000 -v $(pwd)/data/.config.yaml:/opt/xiaozhi-esp32-server/config.yaml xiaozhi-esp32-server:local
-
-docker logs -f xiaozhi-esp32-server
 
+# 编译完成后，可以使用docker-compose启动项目
+# docker-compose.yml你需要修改成自己编译的镜像版本
+cd main/xiaozhi-server
+docker-compose up -d
 ```
-5、发布腾讯云镜像
-```
-# amd64
-docker tag xiaozhi-esp32-server:local ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-amd64
-docker push ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-amd64
-
-# arm64
-docker tag xiaozhi-esp32-server:local ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-arm64
-docker push ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-arm64
-
-# 推送最新版本
-docker manifest rm ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest
-docker manifest create ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-amd64 ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest-arm64 --amend
-docker manifest inspect ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest
-docker manifest push ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest
-
-```
-6、运行线上镜像
-```
-cd /Users/hrz/myworkspace/docker-java-env/thirddata/
-docker run -d --name xiaozhi-esp32-server --restart always -p 8000:8000 -v $(pwd)/config.yaml:/opt/xiaozhi-esp32-server/config.yaml ccr.ccs.tencentyun.com/xinnan/xiaozhi-esp32-server:latest
-docker logs -f xiaozhi-esp32-server
-```

docs/docker/nginx.conf

@@ -0,0 +1,26 @@
+server {
+    listen 8002;
+    server_name localhost;
+
+    # 静态资源服务（Vue项目）
+    location / {
+        root /usr/share/nginx/html;
+        try_files $uri $uri/ /index.html;
+    }
+
+    # API反向代理（Java项目）
+    location /xiaozhi-esp32-api/ {
+        proxy_pass http://127.0.0.1:8003;
+        proxy_set_header   Host   $host;
+        proxy_cookie_path /api/ /;
+        proxy_set_header   Referer $http_referer;
+        proxy_set_header   Cookie $http_cookie;
+
+        proxy_connect_timeout 10;
+        proxy_send_timeout 10;
+        proxy_read_timeout 10;
+
+        proxy_set_header   X-Real-IP  $remote_addr;
+        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+}

docs/docker/start.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# 启动Java后端（docker内监听8003端口）
+java -jar /app/xiaozhi-esp32-api.jar \
+  --server.port=8003 \
+  --spring.datasource.druid.url=${SPRING_DATASOURCE_DRUID_URL} \
+  --spring.datasource.druid.username=${SPRING_DATASOURCE_DRUID_USERNAME} \
+  --spring.datasource.druid.password=${SPRING_DATASOURCE_DRUID_PASSWORD} \
+  --spring.data.redis.host=${SPRING_DATA_REDIS_HOST} \
+  --spring.data.redis.port=${SPRING_DATA_REDIS_PORT} &
+
+# 启动Nginx（前台运行保持容器存活）
+nginx -g 'daemon off;'

docs/firmware-build.md

@@ -87,3 +87,19 @@ https://espressif.github.io/esp-launchpad/
 
 打开这个教程，[Flash工具/Web端烧录固件（无IDF开发环境）](https://ccnphfhqs21z.feishu.cn/wiki/Zpz4wXBtdimBrLk25WdcXzxcnNS)。
 翻到：`方式二：ESP-Launchpad 浏览器WEB端烧录`，从`3. 烧录固件/下载到开发板`开始，按照教程操作。
+
+烧录成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。
+
+以下是一些常见问题，供参考：
+
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+
+[2、为什么会出现“TTS 任务出错 文件不存在”？](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+
+[3、TTS 经常失败，经常超时](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+
+[4、如何提高小智对话响应速度？](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+
+[5、我说话很慢，停顿时小智老是抢话](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+
+[6、我想通过小智控制电灯、空调、远程开关机等操作](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)

main/README.md

@@ -3,7 +3,7 @@
 # 项目目录介绍
 当你看到这份文件的时候，这个这个项目还没完善好。我们还有很多东西要做。
 
-如果你会开发，我们非常欢迎您的加入。
+如果你是一名软件开发者，这里有一份[《致开发者的公开信》](../docs/contributor_open_letter.md)，欢迎归队！
 
 ```
 xiaozhi-esp32-server
@@ -18,6 +18,6 @@ xiaozhi-esp32-server
 
 # manager-web 、manager-api接口协议
 
-[manager前后端接口协议](https://app.apifox.com/invite/project?token=H_8qhgfjUeaAL0wybghgU)
+[manager前后端接口协议](https://app.apifox.com/invite/project?token=eXg2_tUv85q-gc3ZRowmn)
 
 [前端页面设计图](https://codesign.qq.com/app/s/526108506410828)

main/manager-api/pom.xml

@@ -23,9 +23,7 @@
         <mybatisplus.version>3.5.5</mybatisplus.version>
         <hutool.version>5.8.24</hutool.version>
         <jsoup.version>1.19.1</jsoup.version>
-        <jasypt.version>3.0.5</jasypt.version>
         <knife4j.version>4.6.0</knife4j.version>
-        <quartz.version>2.3.2</quartz.version>
         <shiro.version>2.0.2</shiro.version>
         <captcha.version>1.6.2</captcha.version>
         <guava.version>33.0.0-jre</guava.version>
@@ -34,21 +32,6 @@
     </properties>
 
     <dependencies>
-        <dependency>
-            <groupId>org.quartz-scheduler</groupId>
-            <artifactId>quartz</artifactId>
-            <version>${quartz.version}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>com.mchange</groupId>
-                    <artifactId>c3p0</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>com.zaxxer</groupId>
-                    <artifactId>HikariCP-java6</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
         <dependency>
             <groupId>org.apache.shiro</groupId>
             <artifactId>shiro-core</artifactId>
@@ -83,6 +66,7 @@
                 </exclusion>
             </exclusions>
         </dependency>
+        <!-- 验证码工具包 -->
         <dependency>
             <groupId>com.github.whvcse</groupId>
             <artifactId>easy-captcha</artifactId>

main/manager-api/src/main/java/xiaozhi/AdminApplication.java

@@ -8,6 +8,6 @@ public class AdminApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(AdminApplication.class, args);
-        System.out.println("http://localhost:8002/xiaozhi-esp32-api/doc.html");
+        System.out.println("http://localhost:8002/xiaozhi-esp32-api/api/v1/doc.html");
     }
 }

main/manager-api/src/main/java/xiaozhi/common/aspect/DataFilterAspect.java

@@ -1,99 +0,0 @@
-package xiaozhi.common.aspect;
-
-import cn.hutool.core.collection.CollUtil;
-import xiaozhi.common.annotation.DataFilter;
-import xiaozhi.common.constant.Constant;
-import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.exception.RenException;
-import xiaozhi.common.interceptor.DataScope;
-import xiaozhi.common.user.UserDetail;
-import xiaozhi.modules.security.user.SecurityUser;
-import xiaozhi.modules.sys.enums.SuperAdminEnum;
-import org.apache.commons.lang3.StringUtils;
-import org.aspectj.lang.JoinPoint;
-import org.aspectj.lang.annotation.Aspect;
-import org.aspectj.lang.annotation.Before;
-import org.aspectj.lang.annotation.Pointcut;
-import org.aspectj.lang.reflect.MethodSignature;
-import org.springframework.stereotype.Component;
-
-import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 数据过滤，切面处理类
- * Copyright (c) 人人开源 All rights reserved.
- * Website: https://www.renren.io
- */
-@Aspect
-@Component
-public class DataFilterAspect {
-
-    @Pointcut("@annotation(xiaozhi.common.annotation.DataFilter)")
-    public void dataFilterCut() {
-
-    }
-
-    @Before("dataFilterCut()")
-    public void dataFilter(JoinPoint point) {
-        Object params = point.getArgs()[0];
-        if (params != null && params instanceof Map) {
-            UserDetail user = SecurityUser.getUser();
-
-            //如果是超级管理员，则不进行数据过滤
-            if (user.getSuperAdmin() == SuperAdminEnum.YES.value()) {
-                return;
-            }
-
-            try {
-                //否则进行数据过滤
-                Map map = (Map) params;
-                String sqlFilter = getSqlFilter(user, point);
-                map.put(Constant.SQL_FILTER, new DataScope(sqlFilter));
-            } catch (Exception e) {
-
-            }
-
-            return;
-        }
-
-        throw new RenException(ErrorCode.DATA_SCOPE_PARAMS_ERROR);
-    }
-
-    /**
-     * 获取数据过滤的SQL
-     */
-    private String getSqlFilter(UserDetail user, JoinPoint point) throws Exception {
-        MethodSignature signature = (MethodSignature) point.getSignature();
-        Method method = point.getTarget().getClass().getDeclaredMethod(signature.getName(), signature.getParameterTypes());
-        DataFilter dataFilter = method.getAnnotation(DataFilter.class);
-
-        //获取表的别名
-        String tableAlias = dataFilter.tableAlias();
-        if (StringUtils.isNotBlank(tableAlias)) {
-            tableAlias += ".";
-        }
-
-        StringBuilder sqlFilter = new StringBuilder();
-        sqlFilter.append(" (");
-
-        //部门ID列表
-        List<Long> deptIdList = user.getDeptIdList();
-        if (CollUtil.isNotEmpty(deptIdList)) {
-            sqlFilter.append(tableAlias).append(dataFilter.deptId());
-
-            sqlFilter.append(" in(").append(StringUtils.join(deptIdList, ",")).append(")");
-        }
-
-        //查询本人数据
-        if (CollUtil.isNotEmpty(deptIdList)) {
-            sqlFilter.append(" or ");
-        }
-        sqlFilter.append(tableAlias).append(dataFilter.userId()).append("=").append(user.getId());
-
-        sqlFilter.append(")");
-
-        return sqlFilter.toString();
-    }
-}

main/manager-api/src/main/java/xiaozhi/common/aspect/RedisAspect.java

@@ -1,40 +1,40 @@
-package xiaozhi.common.aspect;
+package xiaozhi.common.aspect;
-
+
-import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.exception.RenException;
+import xiaozhi.common.exception.RenException;
-import lombok.extern.slf4j.Slf4j;
+import lombok.extern.slf4j.Slf4j;
-import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Around;
-import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Aspect;
-import org.springframework.beans.factory.annotation.Value;
+import org.springframework.beans.factory.annotation.Value;
-import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Component;
-
+
-/**
+/**
- * Redis切面处理类
+ * Redis切面处理类
- * Copyright (c) 人人开源 All rights reserved.
+ * Copyright (c) 人人开源 All rights reserved.
- * Website: https://www.renren.io
+ * Website: https://www.renren.io
- */
+ */
-@Slf4j
+@Slf4j
-@Aspect
+@Aspect
-@Component
+@Component
-public class RedisAspect {
+public class RedisAspect {
-    /**
+    /**
-     * 是否开启redis缓存  true开启   false关闭
+     * 是否开启redis缓存  true开启   false关闭
-     */
+     */
-    @Value("${renren.redis.open}")
+    @Value("${renren.redis.open}")
-    private boolean open;
+    private boolean open;
-
+
-    @Around("execution(* xiaozhi.common.redis.RedisUtils.*(..))")
+    @Around("execution(* xiaozhi.common.redis.RedisUtils.*(..))")
-    public Object around(ProceedingJoinPoint point) throws Throwable {
+    public Object around(ProceedingJoinPoint point) throws Throwable {
-        Object result = null;
+        Object result = null;
-        if (open) {
+        if (open) {
-            try {
+            try {
-                result = point.proceed();
+                result = point.proceed();
-            } catch (Exception e) {
+            } catch (Exception e) {
-                log.error("redis error", e);
+                log.error("redis error", e);
-                throw new RenException(ErrorCode.REDIS_ERROR);
+                throw new RenException(ErrorCode.REDIS_ERROR);
-            }
+            }
-        }
+        }
-        return result;
+        return result;
-    }
+    }
-}
+}

main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java

@@ -73,10 +73,8 @@ public interface Constant {
      * 排序方式
      */
     String ORDER = "order";
-    /**
+
-     * token header
+    String AUTHORIZATION = "Authorization";
-     */
-    String TOKEN_HEADER = "token";
 
     /**
      * 路径分割符

main/manager-api/src/main/java/xiaozhi/common/exception/ErrorCode.java

@@ -22,17 +22,25 @@ public interface ErrorCode {
     int CAPTCHA_ERROR = 10007;
     int SUB_MENU_EXIST = 10008;
     int PASSWORD_ERROR = 10009;
+
     int SUPERIOR_DEPT_ERROR = 10011;
     int SUPERIOR_MENU_ERROR = 10012;
     int DATA_SCOPE_PARAMS_ERROR = 10013;
     int DEPT_SUB_DELETE_ERROR = 10014;
     int DEPT_USER_DELETE_ERROR = 10015;
+
     int UPLOAD_FILE_EMPTY = 10019;
     int TOKEN_NOT_EMPTY = 10020;
     int TOKEN_INVALID = 10021;
     int ACCOUNT_LOCK = 10022;
+
     int OSS_UPLOAD_FILE_ERROR = 10024;
+
     int REDIS_ERROR = 10027;
     int JOB_ERROR = 10028;
     int INVALID_SYMBOL = 10029;
+    int PASSWORD_LENGTH_ERROR = 10030;
+    int PASSWORD_WEAK_ERROR = 10031;
+    int DEL_MYSELF_ERROR = 10032;
+    int DEVICE_CAPTCHA_ERROR = 10033;
 }

main/manager-api/src/main/java/xiaozhi/common/handler/FieldMetaObjectHandler.java

@@ -34,9 +34,6 @@ public class FieldMetaObjectHandler implements MetaObjectHandler {
         //创建时间
         strictInsertFill(metaObject, CREATE_DATE, Date.class, date);
 
-        //创建者所属部门
-        strictInsertFill(metaObject, DEPT_ID, Long.class, user.getDeptId());
-
         //更新者
         strictInsertFill(metaObject, UPDATER, Long.class, user.getId());
         //更新时间

main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java

@@ -21,60 +21,9 @@ public class RedisKeys {
     }
 
     /**
-     * 登录用户Key
+     * 未注册设备验证码Key
      */
-    public static String getSecurityUserKey(Long id) {
+    public static String getDeviceCaptchaKey(String captcha) {
-        return "sys:security:user:" + id;
+        return "sys:device:captcha:" + captcha;
     }
-
-    /**
-     * 系统日志Key
-     */
-    public static String getSysLogKey() {
-        return "sys:log";
-    }
-
-    /**
-     * 系统资源Key
-     */
-    public static String getSysResourceKey() {
-        return "sys:resource";
-    }
-
-    /**
-     * 用户菜单导航Key
-     */
-    public static String getUserMenuNavKey(Long userId) {
-        return "sys:user:nav:" + userId;
-    }
-
-    /**
-     * 用户权限标识Key
-     */
-    public static String getUserPermissionsKey(Long userId) {
-        return "sys:user:permissions:" + userId;
-    }
-
-    /**
-     * 用户登陆错误次数
-     *
-     * @param username
-     * @return
-     */
-    public static String getUserLoginErrorCountKey(String username) {
-        return "sys:user:login:error:" + username;
-    }
-
-    public static String getUserInfoKey(Long userId) {
-        return "sys:user:" + userId;
-    }
-
-    public static String getDataScopeListKey(Long userId) {
-        return "sys:user:data:scope:" + userId;
-    }
-
-    public static String getSysUserName(Long id) {
-        return "sys:user:name" + id;
-    }
-
 }

main/manager-api/src/main/java/xiaozhi/common/service/BaseService.java

@@ -1,108 +1,108 @@
-package xiaozhi.common.service;
+package xiaozhi.common.service;
-
+
-import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
-
+
-import java.io.Serializable;
+import java.io.Serializable;
-import java.util.Collection;
+import java.util.Collection;
-
+
-/**
+/**
- * 基础服务接口，所有Service接口都要继承
+ * 基础服务接口，所有Service接口都要继承
- * Copyright (c) 人人开源 All rights reserved.
+ * Copyright (c) 人人开源 All rights reserved.
- * Website: https://www.renren.io
+ * Website: https://www.renren.io
- */
+ */
-public interface BaseService<T> {
+public interface BaseService<T> {
-    Class<T> currentModelClass();
+    Class<T> currentModelClass();
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 插入一条记录（选择字段，策略插入）
+     * 插入一条记录（选择字段，策略插入）
-     * </p>
+     * </p>
-     *
+     *
-     * @param entity 实体对象
+     * @param entity 实体对象
-     */
+     */
-    boolean insert(T entity);
+    boolean insert(T entity);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 插入（批量），该方法不支持 Oracle、SQL Server
+     * 插入（批量），该方法不支持 Oracle、SQL Server
-     * </p>
+     * </p>
-     *
+     *
-     * @param entityList 实体对象集合
+     * @param entityList 实体对象集合
-     */
+     */
-    boolean insertBatch(Collection<T> entityList);
+    boolean insertBatch(Collection<T> entityList);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 插入（批量），该方法不支持 Oracle、SQL Server
+     * 插入（批量），该方法不支持 Oracle、SQL Server
-     * </p>
+     * </p>
-     *
+     *
-     * @param entityList 实体对象集合
+     * @param entityList 实体对象集合
-     * @param batchSize  插入批次数量
+     * @param batchSize  插入批次数量
-     */
+     */
-    boolean insertBatch(Collection<T> entityList, int batchSize);
+    boolean insertBatch(Collection<T> entityList, int batchSize);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据 ID 选择修改
+     * 根据 ID 选择修改
-     * </p>
+     * </p>
-     *
+     *
-     * @param entity 实体对象
+     * @param entity 实体对象
-     */
+     */
-    boolean updateById(T entity);
+    boolean updateById(T entity);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据 whereEntity 条件，更新记录
+     * 根据 whereEntity 条件，更新记录
-     * </p>
+     * </p>
-     *
+     *
-     * @param entity        实体对象
+     * @param entity        实体对象
-     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
+     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
-     */
+     */
-    boolean update(T entity, Wrapper<T> updateWrapper);
+    boolean update(T entity, Wrapper<T> updateWrapper);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据ID 批量更新
+     * 根据ID 批量更新
-     * </p>
+     * </p>
-     *
+     *
-     * @param entityList 实体对象集合
+     * @param entityList 实体对象集合
-     */
+     */
-    boolean updateBatchById(Collection<T> entityList);
+    boolean updateBatchById(Collection<T> entityList);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据ID 批量更新
+     * 根据ID 批量更新
-     * </p>
+     * </p>
-     *
+     *
-     * @param entityList 实体对象集合
+     * @param entityList 实体对象集合
-     * @param batchSize  更新批次数量
+     * @param batchSize  更新批次数量
-     */
+     */
-    boolean updateBatchById(Collection<T> entityList, int batchSize);
+    boolean updateBatchById(Collection<T> entityList, int batchSize);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据 ID 查询
+     * 根据 ID 查询
-     * </p>
+     * </p>
-     *
+     *
-     * @param id 主键ID
+     * @param id 主键ID
-     */
+     */
-    T selectById(Serializable id);
+    T selectById(Serializable id);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 根据 ID 删除
+     * 根据 ID 删除
-     * </p>
+     * </p>
-     *
+     *
-     * @param id 主键ID
+     * @param id 主键ID
-     */
+     */
-    boolean deleteById(Serializable id);
+    boolean deleteById(Serializable id);
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 删除（根据ID 批量删除）
+     * 删除（根据ID 批量删除）
-     * </p>
+     * </p>
-     *
+     *
-     * @param idList 主键ID列表
+     * @param idList 主键ID列表
-     */
+     */
-    boolean deleteBatchIds(Collection<? extends Serializable> idList);
+    boolean deleteBatchIds(Collection<? extends Serializable> idList);
 }

main/manager-api/src/main/java/xiaozhi/common/service/impl/BaseServiceImpl.java

@@ -1,214 +1,214 @@
-package xiaozhi.common.service.impl;
+package xiaozhi.common.service.impl;
-
+
-import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
-import com.baomidou.mybatisplus.core.enums.SqlMethod;
+import com.baomidou.mybatisplus.core.enums.SqlMethod;
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.metadata.IPage;
-import com.baomidou.mybatisplus.core.metadata.OrderItem;
+import com.baomidou.mybatisplus.core.metadata.OrderItem;
-import com.baomidou.mybatisplus.core.toolkit.Constants;
+import com.baomidou.mybatisplus.core.toolkit.Constants;
-import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
+import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
-import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
-import xiaozhi.common.constant.Constant;
+import xiaozhi.common.constant.Constant;
-import xiaozhi.common.page.PageData;
+import xiaozhi.common.page.PageData;
-import xiaozhi.common.service.BaseService;
+import xiaozhi.common.service.BaseService;
-import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.common.utils.ConvertUtils;
-import org.apache.ibatis.binding.MapperMethod;
+import org.apache.ibatis.binding.MapperMethod;
-import org.apache.ibatis.logging.Log;
+import org.apache.ibatis.logging.Log;
-import org.apache.ibatis.logging.LogFactory;
+import org.apache.ibatis.logging.LogFactory;
-import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSession;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.annotation.Transactional;
-
+
-import java.io.Serializable;
+import java.io.Serializable;
-import java.util.Collection;
+import java.util.Collection;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-import java.util.function.BiConsumer;
+import java.util.function.BiConsumer;
-
+
-/**
+/**
- * 基础服务类，所有Service都要继承
+ * 基础服务类，所有Service都要继承
- * Copyright (c) 人人开源 All rights reserved.
+ * Copyright (c) 人人开源 All rights reserved.
- * Website: https://www.renren.io
+ * Website: https://www.renren.io
- */
+ */
-public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements BaseService<T> {
+public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements BaseService<T> {
-    @Autowired
+    @Autowired
-    protected M baseDao;
+    protected M baseDao;
-    protected Log log = LogFactory.getLog(getClass());
+    protected Log log = LogFactory.getLog(getClass());
-
+
-    /**
+    /**
-     * 获取分页对象
+     * 获取分页对象
-     *
+     *
-     * @param params            分页查询参数
+     * @param params            分页查询参数
-     * @param defaultOrderField 默认排序字段
+     * @param defaultOrderField 默认排序字段
-     * @param isAsc             排序方式
+     * @param isAsc             排序方式
-     */
+     */
-    protected IPage<T> getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
+    protected IPage<T> getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
-        //分页参数
+        //分页参数
-        long curPage = 1;
+        long curPage = 1;
-        long limit = 10;
+        long limit = 10;
-
+
-        if (params.get(Constant.PAGE) != null) {
+        if (params.get(Constant.PAGE) != null) {
-            curPage = Long.parseLong((String) params.get(Constant.PAGE));
+            curPage = Long.parseLong((String) params.get(Constant.PAGE));
-        }
+        }
-        if (params.get(Constant.LIMIT) != null) {
+        if (params.get(Constant.LIMIT) != null) {
-            limit = Long.parseLong((String) params.get(Constant.LIMIT));
+            limit = Long.parseLong((String) params.get(Constant.LIMIT));
-        }
+        }
-
+
-        //分页对象
+        //分页对象
-        Page<T> page = new Page<>(curPage, limit);
+        Page<T> page = new Page<>(curPage, limit);
-
+
-        //分页参数
+        //分页参数
-        params.put(Constant.PAGE, page);
+        params.put(Constant.PAGE, page);
-
+
-        //排序字段
+        //排序字段
-        String orderField = (String) params.get(Constant.ORDER_FIELD);
+        String orderField = (String) params.get(Constant.ORDER_FIELD);
-        String order = (String) params.get(Constant.ORDER);
+        String order = (String) params.get(Constant.ORDER);
-
+
-        //前端字段排序
+        //前端字段排序
-        if (StringUtils.isNotBlank(orderField) && StringUtils.isNotBlank(order)) {
+        if (StringUtils.isNotBlank(orderField) && StringUtils.isNotBlank(order)) {
-            if (Constant.ASC.equalsIgnoreCase(order)) {
+            if (Constant.ASC.equalsIgnoreCase(order)) {
-                return page.addOrder(OrderItem.asc(orderField));
+                return page.addOrder(OrderItem.asc(orderField));
-            } else {
+            } else {
-                return page.addOrder(OrderItem.desc(orderField));
+                return page.addOrder(OrderItem.desc(orderField));
-            }
+            }
-        }
+        }
-
+
-        //没有排序字段，则不排序
+        //没有排序字段，则不排序
-        if (StringUtils.isBlank(defaultOrderField)) {
+        if (StringUtils.isBlank(defaultOrderField)) {
-            return page;
+            return page;
-        }
+        }
-
+
-        //默认排序
+        //默认排序
-        if (isAsc) {
+        if (isAsc) {
-            page.addOrder(OrderItem.asc(defaultOrderField));
+            page.addOrder(OrderItem.asc(defaultOrderField));
-        } else {
+        } else {
-            page.addOrder(OrderItem.desc(defaultOrderField));
+            page.addOrder(OrderItem.desc(defaultOrderField));
-        }
+        }
-
+
-        return page;
+        return page;
-    }
+    }
-
+
-    protected <T> PageData<T> getPageData(List<?> list, long total, Class<T> target) {
+    protected <T> PageData<T> getPageData(List<?> list, long total, Class<T> target) {
-        List<T> targetList = ConvertUtils.sourceToTarget(list, target);
+        List<T> targetList = ConvertUtils.sourceToTarget(list, target);
-
+
-        return new PageData<>(targetList, total);
+        return new PageData<>(targetList, total);
-    }
+    }
-
+
-    protected <T> PageData<T> getPageData(IPage page, Class<T> target) {
+    protected <T> PageData<T> getPageData(IPage page, Class<T> target) {
-        return getPageData(page.getRecords(), page.getTotal(), target);
+        return getPageData(page.getRecords(), page.getTotal(), target);
-    }
+    }
-
+
-    protected void paramsToLike(Map<String, Object> params, String... likes) {
+    protected void paramsToLike(Map<String, Object> params, String... likes) {
-        for (String like : likes) {
+        for (String like : likes) {
-            String val = (String) params.get(like);
+            String val = (String) params.get(like);
-            if (StringUtils.isNotBlank(val)) {
+            if (StringUtils.isNotBlank(val)) {
-                params.put(like, "%" + val + "%");
+                params.put(like, "%" + val + "%");
-            } else {
+            } else {
-                params.put(like, null);
+                params.put(like, null);
-            }
+            }
-        }
+        }
-    }
+    }
-
+
-    /**
+    /**
-     * <p>
+     * <p>
-     * 判断数据库操作是否成功
+     * 判断数据库操作是否成功
-     * </p>
+     * </p>
-     * <p>
+     * <p>
-     * 注意！！ 该方法为 Integer 判断，不可传入 int 基本类型
+     * 注意！！ 该方法为 Integer 判断，不可传入 int 基本类型
-     * </p>
+     * </p>
-     *
+     *
-     * @param result 数据库操作返回影响条数
+     * @param result 数据库操作返回影响条数
-     * @return boolean
+     * @return boolean
-     */
+     */
-    protected static boolean retBool(Integer result) {
+    protected static boolean retBool(Integer result) {
-        return SqlHelper.retBool(result);
+        return SqlHelper.retBool(result);
-    }
+    }
-
+
-    protected Class<M> currentMapperClass() {
+    protected Class<M> currentMapperClass() {
-        return (Class<M>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 0);
+        return (Class<M>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 0);
-    }
+    }
-
+
-    @Override
+    @Override
-    public Class<T> currentModelClass() {
+    public Class<T> currentModelClass() {
-        return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 1);
+        return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 1);
-    }
+    }
-
+
-    protected String getSqlStatement(SqlMethod sqlMethod) {
+    protected String getSqlStatement(SqlMethod sqlMethod) {
-        return SqlHelper.getSqlStatement(this.currentMapperClass(), sqlMethod);
+        return SqlHelper.getSqlStatement(this.currentMapperClass(), sqlMethod);
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean insert(T entity) {
+    public boolean insert(T entity) {
-        return BaseServiceImpl.retBool(baseDao.insert(entity));
+        return BaseServiceImpl.retBool(baseDao.insert(entity));
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean insertBatch(Collection<T> entityList) {
+    public boolean insertBatch(Collection<T> entityList) {
-        return insertBatch(entityList, 100);
+        return insertBatch(entityList, 100);
-    }
+    }
-
+
-    /**
+    /**
-     * 批量插入
+     * 批量插入
-     */
+     */
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean insertBatch(Collection<T> entityList, int batchSize) {
+    public boolean insertBatch(Collection<T> entityList, int batchSize) {
-        String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
+        String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
-        return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
+        return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
-    }
+    }
-
+
-    /**
+    /**
-     * 执行批量操作
+     * 执行批量操作
-     */
+     */
-    protected <E> boolean executeBatch(Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
+    protected <E> boolean executeBatch(Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
-        return SqlHelper.executeBatch(this.currentModelClass(), this.log, list, batchSize, consumer);
+        return SqlHelper.executeBatch(this.currentModelClass(), this.log, list, batchSize, consumer);
-    }
+    }
-
+
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean updateById(T entity) {
+    public boolean updateById(T entity) {
-        return BaseServiceImpl.retBool(baseDao.updateById(entity));
+        return BaseServiceImpl.retBool(baseDao.updateById(entity));
-    }
+    }
-
+
-    @Override
+    @Override
-    public boolean update(T entity, Wrapper<T> updateWrapper) {
+    public boolean update(T entity, Wrapper<T> updateWrapper) {
-        return BaseServiceImpl.retBool(baseDao.update(entity, updateWrapper));
+        return BaseServiceImpl.retBool(baseDao.update(entity, updateWrapper));
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean updateBatchById(Collection<T> entityList) {
+    public boolean updateBatchById(Collection<T> entityList) {
-        return updateBatchById(entityList, 30);
+        return updateBatchById(entityList, 30);
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public boolean updateBatchById(Collection<T> entityList, int batchSize) {
+    public boolean updateBatchById(Collection<T> entityList, int batchSize) {
-        String sqlStatement = getSqlStatement(SqlMethod.UPDATE_BY_ID);
+        String sqlStatement = getSqlStatement(SqlMethod.UPDATE_BY_ID);
-        return executeBatch(entityList, batchSize, (sqlSession, entity) -> {
+        return executeBatch(entityList, batchSize, (sqlSession, entity) -> {
-            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
+            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
-            param.put(Constants.ENTITY, entity);
+            param.put(Constants.ENTITY, entity);
-            sqlSession.update(sqlStatement, param);
+            sqlSession.update(sqlStatement, param);
-        });
+        });
-    }
+    }
-
+
-    @Override
+    @Override
-    public T selectById(Serializable id) {
+    public T selectById(Serializable id) {
-        return baseDao.selectById(id);
+        return baseDao.selectById(id);
-    }
+    }
-
+
-    @Override
+    @Override
-    public boolean deleteById(Serializable id) {
+    public boolean deleteById(Serializable id) {
-        return SqlHelper.retBool(baseDao.deleteById(id));
+        return SqlHelper.retBool(baseDao.deleteById(id));
-    }
+    }
-
+
-    @Override
+    @Override
-    public boolean deleteBatchIds(Collection<? extends Serializable> idList) {
+    public boolean deleteBatchIds(Collection<? extends Serializable> idList) {
-        return SqlHelper.retBool(baseDao.deleteBatchIds(idList));
+        return SqlHelper.retBool(baseDao.deleteBatchIds(idList));
-    }
+    }
 }

main/manager-api/src/main/java/xiaozhi/common/user/UserDetail.java

@@ -3,7 +3,6 @@ package xiaozhi.common.user;
 import lombok.Data;
 
 import java.io.Serializable;
-import java.util.List;
 
 /**
  * 登录用户信息
@@ -14,19 +13,7 @@ import java.util.List;
 public class UserDetail implements Serializable {
     private Long id;
     private String username;
-    private String realName;
-    private String headUrl;
-    private Integer gender;
-    private String email;
-    private String mobile;
-    private Long deptId;
-    private String password;
-    private Integer status;
     private Integer superAdmin;
     private String token;
-    /**
+    private Integer status;
-     * 部门数据权限
-     */
-    private List<Long> deptIdList;
-
 }

main/manager-api/src/main/java/xiaozhi/common/utils/HttpContextUtils.java

@@ -1,6 +1,5 @@
 package xiaozhi.common.utils;
 
-import xiaozhi.common.constant.Constant;
 import jakarta.servlet.http.HttpServletRequest;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.http.HttpHeaders;
@@ -8,6 +7,8 @@ import org.springframework.util.DigestUtils;
 import org.springframework.web.context.request.RequestAttributes;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.RenException;
 
 import java.util.Date;
 import java.util.Enumeration;
@@ -30,13 +31,14 @@ public class HttpContextUtils {
         return ((ServletRequestAttributes) requestAttributes).getRequest();
     }
 
-    public static String getToken() {
+    public static String getToken(String authorization) {
-        HttpServletRequest httpRequest = getHttpServletRequest();
+        String token;
-        String token = httpRequest.getHeader(Constant.TOKEN_HEADER);
+        if (StringUtils.isBlank(authorization) && authorization.contains("Bearer ")) {
-
+            throw new RenException(ErrorCode.UNAUTHORIZED);
-        //如果header中不存在token，则从参数中获取token
+        }
+        token = authorization.replace("Bearer ", "");
         if (StringUtils.isBlank(token)) {
-            token = httpRequest.getParameter(Constant.TOKEN_HEADER);
+            throw new RenException(ErrorCode.TOKEN_NOT_EMPTY);
         }
         return token;
     }

main/manager-api/src/main/java/xiaozhi/common/utils/Result.java

@@ -1,16 +1,10 @@
 package xiaozhi.common.utils;
 
-import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.page.PageData;
-import xiaozhi.modules.security.user.SecurityUser;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
-import org.apache.commons.lang3.StringUtils;
+import xiaozhi.common.exception.ErrorCode;
 
 import java.io.Serializable;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 /**
  * 响应数据
@@ -42,9 +36,6 @@ public class Result<T> implements Serializable {
         return this;
     }
 
-    public boolean success() {
-        return code == 0;
-    }
 
     public Result<T> error() {
         this.code = ErrorCode.INTERNAL_SERVER_ERROR;

main/manager-api/src/main/java/xiaozhi/modules/admin/contrloler/AdminController.java

@@ -0,0 +1,84 @@
+package xiaozhi.modules.admin.contrloler;
+
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.*;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.sys.dto.AdminPageUserDTO;
+import xiaozhi.modules.sys.service.SysUserService;
+import xiaozhi.modules.sys.vo.AdminPageUserVO;
+
+import java.util.Map;
+
+/**
+ * 管理员控制层
+ *
+ * @author zjy
+ * @since 2025-3-25
+ */
+@AllArgsConstructor
+@RestController
+@RequestMapping("/admin")
+@Tag(name = "管理员管理")
+public class AdminController {
+    private final SysUserService sysUserService;
+
+    @GetMapping("/users")
+    @Operation(summary = "分页查找用户")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({
+            @Parameter(name = "mobile", description = "用户手机号码", required = true),
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<PageData<AdminPageUserVO>> pageUser(
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        AdminPageUserDTO dto = new AdminPageUserDTO();
+        dto.setMobile((String) params.get("mobile"));
+        dto.setLimit((String) params.get(Constant.LIMIT));
+        dto.setPage((String) params.get("pages"));
+
+        ValidatorUtils.validateEntity(dto);
+        PageData<AdminPageUserVO> page = sysUserService.page(dto);
+        return new Result<PageData<AdminPageUserVO>>().ok(page);
+    }
+
+    @PutMapping("/users/{id}")
+    @Operation(summary = "重置密码")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<String> update(
+            @PathVariable Long id) {
+        String password = sysUserService.resetPassword(id);
+        return new Result<String>().ok(password);
+    }
+
+    @DeleteMapping("/users/{id}")
+    @Operation(summary = "用户删除")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> delete(@PathVariable Long id) {
+        sysUserService.delete(new Long[]{id});
+        return new Result<>();
+    }
+
+    @GetMapping("/device/all")
+    @Operation(summary = "分页查找设备")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({
+            @Parameter(name = "keywords", description = "用户手机号码", required = true),
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<Void> pageDevice(
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        //TODO 等设备功能模块写好
+        return new Result<Void>().error(600,"等设备功能模块写好");
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/controller/AgentController.java

@@ -0,0 +1,149 @@
+package xiaozhi.modules.agent.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.AllArgsConstructor;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.*;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.user.UserDetail;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.agent.dto.AgentCreateDTO;
+import xiaozhi.modules.agent.dto.AgentUpdateDTO;
+import xiaozhi.modules.agent.entity.AgentEntity;
+import xiaozhi.modules.agent.service.AgentService;
+import xiaozhi.modules.security.user.SecurityUser;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Tag(name = "智能体管理")
+@AllArgsConstructor
+@RestController
+@RequestMapping("/agent")
+public class AgentController {
+    private final AgentService agentService;
+    
+    @GetMapping("/list")
+    @Operation(summary = "获取用户智能体列表")
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<AgentEntity>> getUserAgents() {
+        UserDetail user = SecurityUser.getUser();
+        List<AgentEntity> agents = agentService.getUserAgents(user.getId());
+        return new Result<List<AgentEntity>>().ok(agents);
+    }
+    
+    @GetMapping("/all")
+    @Operation(summary = "智能体列表（管理员）")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<PageData<AgentEntity>> adminAgentList(
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        PageData<AgentEntity> page = agentService.adminAgentList(params);
+        return new Result<PageData<AgentEntity>>().ok(page);
+    }
+    
+    @GetMapping("/{id}")
+    @Operation(summary = "获取智能体详情")
+    @RequiresPermissions("sys:role:normal")
+    public Result<AgentEntity> getAgentById(@PathVariable("id") String id) {
+        AgentEntity agent = agentService.getAgentById(id);
+        return new Result<AgentEntity>().ok(agent);
+    }
+    
+    @PostMapping
+    @Operation(summary = "创建智能体")
+    @RequiresPermissions("sys:role:normal")
+    public Result<Void> save(@RequestBody @Valid AgentCreateDTO dto) {
+        AgentEntity entity = ConvertUtils.sourceToTarget(dto, AgentEntity.class);
+        
+        // 设置用户ID和创建者信息
+        UserDetail user = SecurityUser.getUser();
+        entity.setUserId(user.getId());
+        entity.setCreator(user.getId());
+        entity.setCreatedAt(new Date());
+        
+        // ID、智能体编码和排序会在Service层自动生成
+        agentService.insert(entity);
+        
+        return new Result<>();
+    }
+    
+    @PutMapping
+    @Operation(summary = "更新智能体")
+    @RequiresPermissions("sys:role:normal")
+    public Result<Void> update(@RequestBody @Valid AgentUpdateDTO dto) {
+        // 先查询现有实体
+        AgentEntity existingEntity = agentService.getAgentById(dto.getId());
+        if (existingEntity == null) {
+            return new Result<Void>().error("智能体不存在");
+        }
+        
+        // 只更新提供的非空字段
+        if (dto.getAgentName() != null) {
+            existingEntity.setAgentName(dto.getAgentName());
+        }
+        if (dto.getAgentCode() != null) {
+            existingEntity.setAgentCode(dto.getAgentCode());
+        }
+        if (dto.getAsrModelId() != null) {
+            existingEntity.setAsrModelId(dto.getAsrModelId());
+        }
+        if (dto.getVadModelId() != null) {
+            existingEntity.setVadModelId(dto.getVadModelId());
+        }
+        if (dto.getLlmModelId() != null) {
+            existingEntity.setLlmModelId(dto.getLlmModelId());
+        }
+        if (dto.getTtsModelId() != null) {
+            existingEntity.setTtsModelId(dto.getTtsModelId());
+        }
+        if (dto.getTtsVoiceId() != null) {
+            existingEntity.setTtsVoiceId(dto.getTtsVoiceId());
+        }
+        if (dto.getMemModelId() != null) {
+            existingEntity.setMemModelId(dto.getMemModelId());
+        }
+        if (dto.getIntentModelId() != null) {
+            existingEntity.setIntentModelId(dto.getIntentModelId());
+        }
+        if (dto.getSystemPrompt() != null) {
+            existingEntity.setSystemPrompt(dto.getSystemPrompt());
+        }
+        if (dto.getLangCode() != null) {
+            existingEntity.setLangCode(dto.getLangCode());
+        }
+        if (dto.getLanguage() != null) {
+            existingEntity.setLanguage(dto.getLanguage());
+        }
+        if (dto.getSort() != null) {
+            existingEntity.setSort(dto.getSort());
+        }
+        
+        // 设置更新者信息
+        UserDetail user = SecurityUser.getUser();
+        existingEntity.setUpdater(user.getId());
+        existingEntity.setUpdatedAt(new Date());
+        
+        agentService.updateById(existingEntity);
+        
+        return new Result<>();
+    }
+    
+    @DeleteMapping("/{id}")
+    @Operation(summary = "删除智能体")
+    @RequiresPermissions("sys:role:normal")
+    public Result<Void> delete(@PathVariable String id) {
+        agentService.deleteById(id);
+        return new Result<>();
+    }
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/dao/AgentDao.java

@@ -0,0 +1,10 @@
+package xiaozhi.modules.agent.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+import xiaozhi.common.dao.BaseDao;
+import xiaozhi.modules.agent.entity.AgentEntity;
+
+@Mapper
+public interface AgentDao extends BaseDao<AgentEntity> {
+    
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentCreateDTO.java

@@ -0,0 +1,51 @@
+package xiaozhi.modules.agent.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 智能体创建DTO
+ * 专用于新增智能体，不包含id、agentCode和sort字段，这些字段由系统自动生成/设置默认值
+ */
+@Data
+@Schema(description = "智能体创建对象")
+public class AgentCreateDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+    
+    @Schema(description = "智能体名称", example = "客服助手")
+    @NotBlank(message = "智能体名称不能为空")
+    private String agentName;
+    
+    @Schema(description = "语音识别模型标识", example = "asr_model_01")
+    private String asrModelId;
+    
+    @Schema(description = "语音活动检测标识", example = "vad_model_01")
+    private String vadModelId;
+    
+    @Schema(description = "大语言模型标识", example = "llm_model_01")
+    private String llmModelId;
+    
+    @Schema(description = "语音合成模型标识", example = "tts_model_01")
+    private String ttsModelId;
+    
+    @Schema(description = "音色标识", example = "voice_01")
+    private String ttsVoiceId;
+    
+    @Schema(description = "记忆模型标识", example = "mem_model_01")
+    private String memModelId;
+    
+    @Schema(description = "意图模型标识", example = "intent_model_01")
+    private String intentModelId;
+    
+    @Schema(description = "角色设定参数", example = "你是一个专业的客服助手，负责回答用户问题")
+    private String systemPrompt;
+    
+    @Schema(description = "语言编码", example = "zh_CN")
+    private String langCode;
+    
+    @Schema(description = "交互语种", example = "中文")
+    private String language;
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentUpdateDTO.java

@@ -0,0 +1,61 @@
+package xiaozhi.modules.agent.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 智能体更新DTO
+ * 专用于更新智能体，id字段是必需的，用于标识要更新的智能体
+ * 其他字段均为非必填，只更新提供的字段
+ */
+@Data
+@Schema(description = "智能体更新对象")
+public class AgentUpdateDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "智能体唯一标识", example = "a1b2c3d4e5f6", required = true)
+    @NotBlank(message = "智能体ID不能为空")
+    private String id;
+    
+    @Schema(description = "智能体编码", example = "AGT_1234567890", required = false)
+    private String agentCode;
+    
+    @Schema(description = "智能体名称", example = "客服助手", required = false)
+    private String agentName;
+    
+    @Schema(description = "语音识别模型标识", example = "asr_model_02", required = false)
+    private String asrModelId;
+    
+    @Schema(description = "语音活动检测标识", example = "vad_model_02", required = false)
+    private String vadModelId;
+    
+    @Schema(description = "大语言模型标识", example = "llm_model_02", required = false)
+    private String llmModelId;
+    
+    @Schema(description = "语音合成模型标识", example = "tts_model_02", required = false)
+    private String ttsModelId;
+    
+    @Schema(description = "音色标识", example = "voice_02", required = false)
+    private String ttsVoiceId;
+    
+    @Schema(description = "记忆模型标识", example = "mem_model_02", required = false)
+    private String memModelId;
+    
+    @Schema(description = "意图模型标识", example = "intent_model_02", required = false)
+    private String intentModelId;
+    
+    @Schema(description = "角色设定参数", example = "你是一个专业的客服助手，负责回答用户问题并提供帮助", required = false)
+    private String systemPrompt;
+    
+    @Schema(description = "语言编码", example = "zh_CN", required = false)
+    private String langCode;
+    
+    @Schema(description = "交互语种", example = "中文", required = false)
+    private String language;
+    
+    @Schema(description = "排序", example = "1", required = false)
+    private Integer sort;
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/entity/AgentEntity.java

@@ -0,0 +1,69 @@
+package xiaozhi.modules.agent.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+@TableName("ai_agent")
+@Schema(description = "智能体信息")
+public class AgentEntity {
+    @Schema(description = "智能体唯一标识")
+    private String id;
+    
+    @Schema(description = "所属用户ID")
+    private Long userId;
+    
+    @Schema(description = "智能体编码")
+    private String agentCode;
+    
+    @Schema(description = "智能体名称")
+    private String agentName;
+    
+    @Schema(description = "语音识别模型标识")
+    private String asrModelId;
+    
+    @Schema(description = "语音活动检测标识")
+    private String vadModelId;
+    
+    @Schema(description = "大语言模型标识")
+    private String llmModelId;
+    
+    @Schema(description = "语音合成模型标识")
+    private String ttsModelId;
+    
+    @Schema(description = "音色标识")
+    private String ttsVoiceId;
+    
+    @Schema(description = "记忆模型标识")
+    private String memModelId;
+    
+    @Schema(description = "意图模型标识")
+    private String intentModelId;
+    
+    @Schema(description = "角色设定参数")
+    private String systemPrompt;
+    
+    @Schema(description = "语言编码")
+    private String langCode;
+    
+    @Schema(description = "交互语种")
+    private String language;
+    
+    @Schema(description = "排序")
+    private Integer sort;
+    
+    @Schema(description = "创建者")
+    private Long creator;
+    
+    @Schema(description = "创建时间")
+    private Date createdAt;
+    
+    @Schema(description = "更新者")
+    private Long updater;
+    
+    @Schema(description = "更新时间")
+    private Date updatedAt;
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentService.java

@@ -0,0 +1,25 @@
+package xiaozhi.modules.agent.service;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.agent.entity.AgentEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface AgentService extends BaseService<AgentEntity> {
+    /**
+     * 根据用户ID获取智能体列表
+     */
+    List<AgentEntity> getUserAgents(Long userId);
+    
+    /**
+     * 管理员获取所有智能体列表（分页）
+     */
+    PageData<AgentEntity> adminAgentList(Map<String, Object> params);
+    
+    /**
+     * 获取智能体详情
+     */
+    AgentEntity getAgentById(String id);
+} 

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentServiceImpl.java

@@ -0,0 +1,64 @@
+package xiaozhi.modules.agent.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.modules.agent.dao.AgentDao;
+import xiaozhi.modules.agent.entity.AgentEntity;
+import xiaozhi.modules.agent.service.AgentService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@Service
+public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> implements AgentService {
+    private final AgentDao agentDao;
+    
+    public AgentServiceImpl(AgentDao agentDao) {
+        this.agentDao = agentDao;
+    }
+    
+    @Override
+    public List<AgentEntity> getUserAgents(Long userId) {
+        QueryWrapper<AgentEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("user_id", userId);
+        return agentDao.selectList(wrapper);
+    }
+    
+    @Override
+    public PageData<AgentEntity> adminAgentList(Map<String, Object> params) {
+        IPage<AgentEntity> page = agentDao.selectPage(
+                getPage(params, "sort", true),
+                new QueryWrapper<>()
+        );
+        return new PageData<>(page.getRecords(), page.getTotal());
+    }
+    
+    @Override
+    public AgentEntity getAgentById(String id) {
+        return agentDao.selectById(id);
+    }
+    
+    @Override
+    public boolean insert(AgentEntity entity) {
+        // 如果ID为空，自动生成一个UUID作为ID
+        if (entity.getId() == null || entity.getId().trim().isEmpty()) {
+            entity.setId(UUID.randomUUID().toString().replace("-", ""));
+        }
+        
+        // 如果智能体编码为空，自动生成一个带前缀的编码
+        if (entity.getAgentCode() == null || entity.getAgentCode().trim().isEmpty()) {
+            entity.setAgentCode("AGT_" + System.currentTimeMillis());
+        }
+        
+        // 如果排序字段为空，设置默认值0
+        if (entity.getSort() == null) {
+            entity.setSort(0);
+        }
+        
+        return super.insert(entity);
+    }
+} 

main/manager-api/src/main/java/xiaozhi/modules/device/controller/DeviceController.java

@@ -0,0 +1,82 @@
+package xiaozhi.modules.device.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.*;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.common.user.UserDetail;
+import xiaozhi.common.utils.JsonUtils;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.device.dto.DeviceHeaderDTO;
+import xiaozhi.modules.device.dto.DeviceUnBindDTO;
+import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.security.user.SecurityUser;
+
+import java.util.List;
+import java.util.Map;
+
+@Tag(name = "设备管理")
+@AllArgsConstructor
+@RestController
+@RequestMapping("/device")
+public class DeviceController {
+    private final DeviceService deviceService;
+    private final RedisUtils redisUtils;
+
+
+    @PostMapping("/bind/{deviceCode}")
+    @Operation(summary = "绑定设备")
+    @RequiresPermissions("sys:role:normal")
+    public Result<DeviceEntity> bindDevice(@PathVariable String deviceCode) {
+        UserDetail user = SecurityUser.getUser();
+
+        String deviceHeaders = (String) redisUtils.get(RedisKeys.getDeviceCaptchaKey(deviceCode));
+        if (StringUtils.isBlank(deviceHeaders)) {
+            return new Result<DeviceEntity>().error(ErrorCode.DEVICE_CAPTCHA_ERROR);
+        }
+        DeviceHeaderDTO deviceHeader = JsonUtils.parseObject(deviceHeaders.getBytes(), DeviceHeaderDTO.class);
+        DeviceEntity device = deviceService.bindDevice(user.getId(), deviceHeader);
+        return new Result<DeviceEntity>().ok(device);
+    }
+
+    @GetMapping("/bind")
+    @Operation(summary = "获取已绑定设备")
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<DeviceEntity>> getUserDevices() {
+        UserDetail user = SecurityUser.getUser();
+        List<DeviceEntity> devices = deviceService.getUserDevices(user.getId());
+        return new Result<List<DeviceEntity>>().ok(devices);
+    }
+
+    @PostMapping("/unbind")
+    @Operation(summary = "解绑设备")
+    @RequiresPermissions("sys:role:normal")
+    public Result unbindDevice(@RequestBody DeviceUnBindDTO unDeviveBind) {
+        UserDetail user = SecurityUser.getUser();
+        deviceService.unbindDevice(user.getId(), unDeviveBind.getDeviceId());
+        return new Result();
+    }
+
+    @GetMapping("/all")
+    @Operation(summary = "设备列表（管理员）")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<PageData<DeviceEntity>> adminDeviceList(
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        PageData<DeviceEntity> page = deviceService.adminDeviceList(params);
+        return new Result<PageData<DeviceEntity>>().ok(page);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dao/DeviceDao.java

@@ -0,0 +1,9 @@
+package xiaozhi.modules.device.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import xiaozhi.modules.device.entity.DeviceEntity;
+
+@Mapper
+public interface DeviceDao extends BaseMapper<DeviceEntity> {
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceHeaderDTO.java

@@ -0,0 +1,19 @@
+package xiaozhi.modules.device.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(description = "设备连接头信息")
+public class DeviceHeaderDTO {
+
+    @Schema(description = "设备ID")
+    private String deviceId;
+
+    @Schema(description = "协议版本号")
+    private Long protocolVersion;
+
+    @Schema(description = "认证信息")
+    private String authorization;
+
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceUnBindDTO.java

@@ -0,0 +1,19 @@
+package xiaozhi.modules.device.dto;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 设备解绑表单
+ */
+@Data
+@Schema(description = "设备解绑表单")
+public class DeviceUnBindDTO implements Serializable {
+
+    @Schema(description = "设备ID")
+    @NotBlank(message = "设备ID不能为空")
+    private Long deviceId;
+
+}

main/manager-api/src/main/java/xiaozhi/modules/device/entity/DeviceEntity.java

@@ -0,0 +1,54 @@
+package xiaozhi.modules.device.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+@TableName("ai_device")
+@Schema(description = "设备信息")
+public class DeviceEntity {
+    @Schema(description = "设备ID")
+    private Long id;
+
+    @Schema(description = "关联用户ID")
+    private Long userId;
+
+    @Schema(description = "MAC地址")
+    private String macAddress;
+
+    @Schema(description = "最后连接时间")
+    private Date lastConnectedAt;
+
+    @Schema(description = "自动更新开关(0关闭/1开启)")
+    private Integer autoUpdate;
+
+    @Schema(description = "设备硬件型号")
+    private String board;
+
+    @Schema(description = "设备别名")
+    private String alias;
+
+    @Schema(description = "智能体ID")
+    private String agentId;
+
+    @Schema(description = "固件版本号")
+    private String appVersion;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/device/service/DeviceService.java

@@ -0,0 +1,18 @@
+package xiaozhi.modules.device.service;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.modules.device.dto.DeviceHeaderDTO;
+import xiaozhi.modules.device.entity.DeviceEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface DeviceService {
+    DeviceEntity bindDevice(Long userId, DeviceHeaderDTO deviceHeader);
+    
+    List<DeviceEntity> getUserDevices(Long userId);
+    
+    void unbindDevice(Long userId, Long deviceId);
+    
+    PageData<DeviceEntity> adminDeviceList(Map<String, Object> params);
+}

main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java

@@ -0,0 +1,57 @@
+package xiaozhi.modules.device.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.modules.device.dao.DeviceDao;
+import xiaozhi.modules.device.dto.DeviceHeaderDTO;
+import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.service.DeviceService;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity> implements DeviceService {
+    private final DeviceDao deviceDao;
+
+    // 添加构造函数来初始化 deviceMapper
+    public DeviceServiceImpl(DeviceDao deviceDao) {
+        this.deviceDao = deviceDao;
+    }
+
+    @Override
+    public DeviceEntity bindDevice(Long userId, DeviceHeaderDTO deviceHeader) {
+        DeviceEntity device = new DeviceEntity();
+        device.setUserId(userId);
+        device.setMacAddress(deviceHeader.getDeviceId());
+        device.setCreateDate(new Date());
+        deviceDao.insert(device);
+        return device;
+    }
+
+    @Override
+    public List<DeviceEntity> getUserDevices(Long userId) {
+        QueryWrapper<DeviceEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("user_id", userId);
+        return deviceDao.selectList(wrapper);
+    }
+
+    @Override
+    public void unbindDevice(Long userId, Long deviceId) {
+        deviceDao.deleteById(deviceId);
+    }
+
+    @Override
+    public PageData<DeviceEntity> adminDeviceList(Map<String, Object> params) {
+        IPage<DeviceEntity> page = deviceDao.selectPage(
+                getPage(params, "sort", true),
+                new QueryWrapper<>()
+        );
+        return new PageData<>(page.getRecords(), page.getTotal());
+    }
+
+}

main/manager-api/src/main/java/xiaozhi/modules/model/controller/ModelConfigController.java~

@@ -0,0 +1,2 @@
+package xiaozhi.modules.model.controller;public class ModelConfigController {
+}

main/manager-api/src/main/java/xiaozhi/modules/model/controller/ModelController.java

@@ -0,0 +1,106 @@
+package xiaozhi.modules.model.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.*;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
+import xiaozhi.modules.model.dto.ModelConfigDTO;
+import xiaozhi.modules.model.dto.ModelProviderDTO;
+import xiaozhi.modules.model.service.ModelConfigService;
+import xiaozhi.modules.model.service.ModelProviderService;
+
+import java.util.List;
+
+@AllArgsConstructor
+@RestController
+@RequestMapping("/models")
+@Tag(name = "模型配置")
+public class ModelController {
+
+    private final ModelProviderService modelProviderService;
+
+    private final ModelConfigService modelConfigService;
+
+    @GetMapping("/models/names")
+    @Operation(summary = "获取所有模型名称")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<List<String>> getModelNames(@RequestParam String modelType,
+                                              @RequestParam(required = false) String modelName) {
+        List<String> modelNameList = modelConfigService.getModelCodeList(modelType, modelName);
+        return new Result<List<String>>().ok(modelNameList);
+    }
+
+    @GetMapping("/{modelType}/provideTypes")
+    @Operation(summary = "获取模型供应器列表")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<List<ModelProviderDTO>> getModelProviderList(@PathVariable String modelType) {
+        List<ModelProviderDTO> modelProviderDTOS = modelProviderService.getListByModelType(modelType);
+        return new Result<List<ModelProviderDTO>>().ok(modelProviderDTOS);
+    }
+
+    @GetMapping("/{modelType}/{provideCode}/fields")
+    @Operation(summary = "获取模型供应器字段")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<List<String>> getModelProviderFields(@PathVariable String modelType, @PathVariable String provideCode) {
+        List<String> fieldList = modelProviderService.getFieldList(modelType, provideCode);
+        return new Result<List<String>>().ok(fieldList);
+    }
+
+
+    @GetMapping("/models/list")
+    @Operation(summary = "获取模型配置列表")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<PageData<ModelConfigDTO>> getModelConfigList(@RequestParam String modelType,
+                                                               @RequestParam(required = false) String modelName,
+                                                               @RequestParam(required = false, defaultValue = "0") Integer page,
+                                                               @RequestParam(required = false,defaultValue = "10") Integer limit) {
+        PageData<ModelConfigDTO> pageList = modelConfigService.getPageList(modelType, modelName, page, limit);
+        return new Result<PageData<ModelConfigDTO>>().ok(pageList);
+    }
+
+
+    @PostMapping("/models/{modelType}/{provideCode}")
+    @Operation(summary = "新增模型配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<ModelConfigDTO> addModelConfig(@PathVariable String modelType,
+                                                 @PathVariable String provideCode,
+                                                 @RequestBody ModelConfigBodyDTO modelConfigBodyDTO) {
+        ModelConfigDTO modelConfigDTO = modelConfigService.add(modelType, provideCode, modelConfigBodyDTO);
+        return new Result<ModelConfigDTO>().ok(modelConfigDTO);
+    }
+
+
+    @PutMapping("/models/{modelType}/{provideCode}/{id}")
+    @Operation(summary = "编辑模型配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<ModelConfigDTO> editModelConfig(@PathVariable String modelType,
+                                                  @PathVariable String provideCode,
+                                                  @PathVariable String id,
+                                                  @RequestBody ModelConfigBodyDTO modelConfigBodyDTO) {
+        ModelConfigDTO modelConfigDTO = modelConfigService.edit(modelType, provideCode, id, modelConfigBodyDTO);
+        return new Result<ModelConfigDTO>().ok(modelConfigDTO);
+    }
+
+
+    @DeleteMapping("/models/{modelType}/{provideCode}/{id}")
+    @Operation(summary = "删除模型配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> deleteModelConfig(@PathVariable String modelType, @PathVariable String provideCode, @PathVariable String id) {
+        modelConfigService.delete(modelType, provideCode, id);
+        return new Result<>();
+    }
+
+    @GetMapping("/models/{modelName}/voices")
+    @Operation(summary = "获取模型音色")
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<String>> getVoiceList(@PathVariable String modelName,
+                                             @RequestParam(required = false) String voiceName) {
+
+        List<String> voiceList = modelConfigService.getVoiceList(modelName, voiceName);
+        return new Result<List<String>>().ok(voiceList);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dao/ModelConfigDao.java

@@ -0,0 +1,17 @@
+package xiaozhi.modules.model.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import xiaozhi.common.dao.BaseDao;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
+
+import java.util.List;
+
+@Mapper
+public interface ModelConfigDao extends BaseDao<ModelConfigEntity> {
+
+    /**
+     * get model_code list
+     */
+    List<String> getModelCodeList(@Param("modelType") String modelType, @Param("modelName") String modelName);
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dao/ModelProviderDao.java

@@ -0,0 +1,14 @@
+package xiaozhi.modules.model.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import xiaozhi.common.dao.BaseDao;
+import xiaozhi.modules.model.entity.ModelProviderEntity;
+
+import java.util.List;
+
+@Mapper
+public interface ModelProviderDao extends BaseDao<ModelProviderEntity> {
+
+    List<String> getFieldList(@Param("modelType") String modelType, @Param("provideCode") String provideCode);
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelConfigBodyDTO.java

@@ -0,0 +1,41 @@
+package xiaozhi.modules.model.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serial;
+
+@Data
+@Schema(description = "模型供应器/商")
+public class ModelConfigBodyDTO {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+//    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
+//    private String modelType;
+//
+    @Schema(description = "模型编码(如AliLLM、DoubaoTTS)")
+    private String modelCode;
+
+    @Schema(description = "模型名称")
+    private String modelName;
+
+    @Schema(description = "是否默认配置(0否 1是)")
+    private Integer isDefault;
+
+    @Schema(description = "是否启用")
+    private Integer isEnabled;
+
+    @Schema(description = "模型配置(JSON格式)")
+    private String configJson;
+
+    @Schema(description = "官方文档链接")
+    private String docLink;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private Integer sort;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelConfigDTO.java

@@ -0,0 +1,45 @@
+package xiaozhi.modules.model.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+
+@Data
+@Schema(description = "模型供应器/商")
+public class ModelConfigDTO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "主键")
+    private Long id;
+
+    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
+    private String modelType;
+
+    @Schema(description = "模型编码(如AliLLM、DoubaoTTS)")
+    private String modelCode;
+
+    @Schema(description = "模型名称")
+    private String modelName;
+
+    @Schema(description = "是否默认配置(0否 1是)")
+    private Integer isDefault;
+
+    @Schema(description = "是否启用")
+    private Integer isEnabled;
+
+    @Schema(description = "模型配置(JSON格式)")
+    private String configJson;
+
+    @Schema(description = "官方文档链接")
+    private String docLink;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private Integer sort;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelProviderDTO.java

@@ -0,0 +1,45 @@
+package xiaozhi.modules.model.dto;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+@Data
+@Schema(description = "模型供应器/商")
+public class ModelProviderDTO implements Serializable {
+//
+//    @Schema(description = "主键")
+//    private Long id;
+
+    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
+    private String modelType;
+
+    @Schema(description = "供应器类型")
+    private String providerCode;
+
+    @Schema(description = "供应器名称")
+    private String name;
+
+    @Schema(description = "供应器字段列表(JSON格式)")
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private String fields;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/entity/ModelConfigEntity.java

@@ -0,0 +1,62 @@
+package xiaozhi.modules.model.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.Date;
+
+
+@Data
+@TableName("ai_model_config")
+@Schema(description = "模型配置表")
+public class ModelConfigEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    @Schema(description = "主键")
+    private String id;
+
+    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
+    private String modelType;
+
+    @Schema(description = "模型编码(如AliLLM、DoubaoTTS)")
+    private String modelCode;
+
+    @Schema(description = "模型名称")
+    private String modelName;
+
+    @Schema(description = "是否默认配置(0否 1是)")
+    private Integer isDefault;
+
+    @Schema(description = "是否启用")
+    private Integer isEnabled;
+
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    @Schema(description = "模型配置(JSON格式)")
+    private String configJson;
+
+    @Schema(description = "官方文档链接")
+    private String docLink;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/entity/ModelProviderEntity.java

@@ -0,0 +1,49 @@
+package xiaozhi.modules.model.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.Date;
+
+@Data
+@TableName("ai_model_provider")
+@Schema(description = "模型供应器表")
+public class ModelProviderEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    @Schema(description = "主键")
+    private String id;
+
+    @Schema(description = "模型类型(Memory/ASR/VAD/LLM/TTS)")
+    private String modelType;
+
+    @Schema(description = "供应器类型，如 openai、")
+    private String providerCode;
+
+    @Schema(description = "供应器名称")
+    private String name;
+
+    @Schema(description = "供应器字段列表(JSON格式)")
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private String fields;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    private Date createDate;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/service/ModelConfigService.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.model.service;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
+import xiaozhi.modules.model.dto.ModelConfigDTO;
+
+import java.util.List;
+
+public interface ModelConfigService {
+
+    List<String> getModelCodeList(String modelType, String modelName);
+
+    PageData<ModelConfigDTO> getPageList(String modelType, String modelName, Integer page, Integer limit);
+
+    ModelConfigDTO add(String modelType, String provideCode, ModelConfigBodyDTO modelConfigBodyDTO);
+
+    ModelConfigDTO edit(String modelType, String provideCode, String id, ModelConfigBodyDTO modelConfigBodyDTO);
+
+    void delete(String modelType, String provideCode, String id);
+
+    List<String> getVoiceList(String modelName, String voiceName);
+}

main/manager-api/src/main/java/xiaozhi/modules/model/service/ModelProviderService.java

@@ -0,0 +1,23 @@
+package xiaozhi.modules.model.service;
+
+import xiaozhi.modules.model.dto.ModelProviderDTO;
+import xiaozhi.modules.model.entity.ModelProviderEntity;
+
+import java.util.List;
+
+public interface ModelProviderService {
+
+//    List<String> getModelNames(String modelType, String modelName);
+
+    List<ModelProviderDTO> getListByModelType(String modelType);
+
+    ModelProviderDTO add(ModelProviderEntity modelProviderEntity);
+
+    ModelProviderDTO edit(ModelProviderEntity modelProviderEntity);
+
+    void delete();
+
+    List<ModelProviderDTO> getList(String modelType, String provideCode);
+
+    List<String> getFieldList(String modelType, String provideCode);
+}

main/manager-api/src/main/java/xiaozhi/modules/model/service/impl/ModelConfigServiceImpl.java

@@ -0,0 +1,124 @@
+package xiaozhi.modules.model.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.RenException;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.model.dao.ModelConfigDao;
+import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
+import xiaozhi.modules.model.dto.ModelConfigDTO;
+import xiaozhi.modules.model.dto.ModelProviderDTO;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
+import xiaozhi.modules.model.service.ModelConfigService;
+import xiaozhi.modules.model.service.ModelProviderService;
+import xiaozhi.modules.timbre.service.TimbreService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@AllArgsConstructor
+public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, ModelConfigEntity> implements ModelConfigService {
+
+    private final ModelConfigDao modelConfigDao;
+    private final ModelProviderService modelProviderService;
+    private final TimbreService timbreService;
+
+    private static final Logger logger = LoggerFactory.getLogger(ModelConfigServiceImpl.class);
+
+    @Override
+    public List<String> getModelCodeList(String modelType, String modelName) {
+        return modelConfigDao.getModelCodeList(modelType, modelName);
+    }
+
+    @Override
+    public PageData<ModelConfigDTO> getPageList(String modelType, String modelName, Integer page, Integer limit) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put(Constant.PAGE, page);
+        params.put(Constant.LIMIT, limit);
+        IPage<ModelConfigEntity> modelConfigEntityIPage = modelConfigDao.selectPage(
+                getPage(params, "sort", true),
+                new QueryWrapper<ModelConfigEntity>()
+                        .eq("model_type", modelType)
+                        .like(StringUtils.isNotBlank(modelName), "model_name", modelName)
+        );
+        return getPageData(modelConfigEntityIPage, ModelConfigDTO.class);
+    }
+
+    @Override
+    public ModelConfigDTO add(String modelType, String provideCode, ModelConfigBodyDTO modelConfigBodyDTO) {
+        // 先验证有没有供应器
+        if (StringUtils.isBlank(modelType) || StringUtils.isBlank(provideCode)) {
+            throw new RenException("modelType和provideCode不能为空");
+        }
+        List<ModelProviderDTO> providerList = modelProviderService.getList(modelType, provideCode);
+        if (CollectionUtil.isEmpty(providerList)) {
+            throw new RenException("供应器不存在");
+        }
+
+        // 再保存供应器提供的模型
+        ModelConfigEntity modelConfigEntity = ConvertUtils.sourceToTarget(modelConfigBodyDTO, ModelConfigEntity.class);
+        modelConfigEntity.setModelType(modelType);
+        modelConfigDao.insert(modelConfigEntity);
+        return ConvertUtils.sourceToTarget(modelConfigEntity, ModelConfigDTO.class);
+    }
+
+    @Override
+    public ModelConfigDTO edit(String modelType, String provideCode, String id, ModelConfigBodyDTO modelConfigBodyDTO) {
+        // 先验证有没有供应器
+        if (StringUtils.isBlank(modelType) || StringUtils.isBlank(provideCode)) {
+            throw new RenException("modelType和provideCode不能为空");
+        }
+        List<ModelProviderDTO> providerList = modelProviderService.getList(modelType, provideCode);
+        if (CollectionUtil.isEmpty(providerList)) {
+            throw new RenException("供应器不存在");
+        }
+
+        // 再更新供应器提供的模型
+        ModelConfigEntity modelConfigEntity = ConvertUtils.sourceToTarget(modelConfigBodyDTO, ModelConfigEntity.class);
+        modelConfigEntity.setId(id);
+        modelConfigEntity.setModelType(modelType);
+        modelConfigDao.updateById(modelConfigEntity);
+        return ConvertUtils.sourceToTarget(modelConfigEntity, ModelConfigDTO.class);
+    }
+
+    @Override
+    public void delete(String modelType, String provideCode, String id) {
+        // 先验证有没有供应器
+        if (StringUtils.isBlank(modelType) || StringUtils.isBlank(provideCode)) {
+            throw new RenException("modelType和provideCode不能为空");
+        }
+        List<ModelProviderDTO> providerList = modelProviderService.getList(modelType, provideCode);
+        if (CollectionUtil.isEmpty(providerList)) {
+            throw new RenException("供应器不存在");
+        }
+
+        modelConfigDao.deleteById(Long.getLong(id));
+    }
+
+    @Override
+    public List<String> getVoiceList(String modelName, String voiceName) {
+        QueryWrapper<ModelConfigEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("model_name", StringUtils.isBlank(modelName) ? "" : modelName);
+        queryWrapper.eq("model_type", "TTS");
+        List<ModelConfigEntity> modelConfigEntities = modelConfigDao.selectList(queryWrapper);
+        if (CollectionUtil.isEmpty(modelConfigEntities)) {
+            logger.warn("没有找到模型配置信息");
+            return null;
+        }
+        ModelConfigEntity modelConfigEntity = modelConfigEntities.get(0);
+        String id = modelConfigEntity.getId();
+
+       return timbreService.getVoiceNames(id, voiceName);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/model/service/impl/ModelProviderServiceImpl.java

@@ -0,0 +1,59 @@
+package xiaozhi.modules.model.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.model.dao.ModelProviderDao;
+import xiaozhi.modules.model.dto.ModelProviderDTO;
+import xiaozhi.modules.model.entity.ModelProviderEntity;
+import xiaozhi.modules.model.service.ModelProviderService;
+
+import java.util.List;
+
+@Service
+@AllArgsConstructor
+public class ModelProviderServiceImpl extends BaseServiceImpl<ModelProviderDao, ModelProviderEntity> implements ModelProviderService {
+
+    private final ModelProviderDao modelProviderDao;
+
+    @Override
+    public List<ModelProviderDTO> getListByModelType(String modelType) {
+
+        QueryWrapper<ModelProviderEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("model_type", StringUtils.isBlank(modelType) ? "" : modelType);
+        List<ModelProviderEntity> providerEntities = modelProviderDao.selectList(queryWrapper);
+        return ConvertUtils.sourceToTarget(providerEntities, ModelProviderDTO.class);
+    }
+
+    @Override
+    public ModelProviderDTO add(ModelProviderEntity modelProviderEntity) {
+        return null;
+    }
+
+    @Override
+    public ModelProviderDTO edit(ModelProviderEntity modelProviderEntity) {
+        return null;
+    }
+
+    @Override
+    public void delete() {
+
+    }
+
+    @Override
+    public List<ModelProviderDTO> getList(String modelType, String provideCode) {
+        QueryWrapper<ModelProviderEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("model_type", StringUtils.isBlank(modelType) ? "" : modelType);
+        queryWrapper.eq("provide_code", StringUtils.isBlank(provideCode) ? "" : provideCode);
+        List<ModelProviderEntity> providerEntities = modelProviderDao.selectList(queryWrapper);
+        return ConvertUtils.sourceToTarget(providerEntities, ModelProviderDTO.class);
+    }
+
+    @Override
+    public List<String> getFieldList(String modelType, String provideCode) {
+        return modelProviderDao.getFieldList(modelType, provideCode);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java

@@ -58,17 +58,21 @@ public class ShiroConfig {
         filters.put("oauth2", new Oauth2Filter());
         shiroFilter.setFilters(filters);
 
+        //添加Shiro的内置过滤器
+        /*anon：无需认证就可以访问
+        authc：必须认证了才能让问
+        user：必须拥有，记住我功能，才能访问
+        perms：拥有对某个资源的权限才能访问
+        role：拥有某个角色权限才能访问*/
         Map<String, String> filterMap = new LinkedHashMap<>();
         filterMap.put("/webjars/**", "anon");
         filterMap.put("/druid/**", "anon");
-        filterMap.put("/login", "anon");
-        filterMap.put("/publicKey", "anon");
         filterMap.put("/v3/api-docs/**", "anon");
         filterMap.put("/doc.html", "anon");
-        filterMap.put("/sys/oss/download/**", "anon");
-        filterMap.put("/captcha", "anon");
         filterMap.put("/favicon.ico", "anon");
-        filterMap.put("/mobile/**", "anon");
+        filterMap.put("/user/captcha", "anon");
+        filterMap.put("/user/login", "anon");
+        filterMap.put("/user/register", "anon");
         filterMap.put("/**", "oauth2");
         shiroFilter.setFilterChainDefinitionMap(filterMap);
 

main/manager-api/src/main/java/xiaozhi/modules/security/controller/LoginController.java

@@ -2,41 +2,42 @@ package xiaozhi.modules.security.controller;
 
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.AllArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
+import org.slf4j.Logger;
-import org.springframework.web.bind.annotation.PostMapping;
+import org.slf4j.LoggerFactory;
-import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.*;
-import org.springframework.web.bind.annotation.RestController;
 import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.common.exception.RenException;
-import xiaozhi.common.utils.PropertiesUtils;
+import xiaozhi.common.page.TokenDTO;
+import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.AssertUtils;
 import xiaozhi.modules.security.dto.LoginDTO;
+import xiaozhi.modules.security.password.PasswordUtils;
 import xiaozhi.modules.security.service.CaptchaService;
 import xiaozhi.modules.security.service.SysUserTokenService;
-import xiaozhi.modules.sys.service.SysParamsService;
+import xiaozhi.modules.security.user.SecurityUser;
+import xiaozhi.modules.sys.dto.PasswordDTO;
+import xiaozhi.modules.sys.dto.SysUserDTO;
 import xiaozhi.modules.sys.service.SysUserService;
 
 import java.io.IOException;
 
 /**
- * 登录
+ * 登录控制层
  */
 @AllArgsConstructor
 @RestController
+@RequestMapping("/user")
 @Tag(name = "登录管理")
 public class LoginController {
     private final SysUserService sysUserService;
     private final SysUserTokenService sysUserTokenService;
     private final CaptchaService captchaService;
-    private final RedisUtils redisUtils;
-    private final SysParamsService sysParamsService;
-    private final PropertiesUtils propertiesUtils;
 
-    @GetMapping("captcha")
+
+    @GetMapping("/captcha")
     @Operation(summary = "验证码")
     public void captcha(HttpServletResponse response, String uuid) throws IOException {
         //uuid不能为空
@@ -46,10 +47,62 @@ public class LoginController {
         captchaService.create(response, uuid);
     }
 
-    @PostMapping("login")
+    @PostMapping("/login")
     @Operation(summary = "登录")
-    public Result login(HttpServletRequest request, @RequestBody LoginDTO login) {
+    public Result<TokenDTO> login(@RequestBody LoginDTO login) {
-        return sysUserTokenService.createToken(1L);
+        // 验证是否正确输入验证码
+        boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha());
+        if (!validate) {
+            throw new RenException("验证码错误，请重新获取");
+        }
+        // 按照用户名获取用户
+        SysUserDTO userDTO = sysUserService.getByUsername(login.getUsername());
+        // 判断用户是否存在
+        if (userDTO == null) {
+            throw new RenException("请检测用户和密码是否输入错误");
+        }
+        // 判断密码是否正确，不一样则进入if
+        if (!PasswordUtils.matches(login.getPassword(), userDTO.getPassword())) {
+            throw new RenException("请检测用户和密码是否输入错误");
+        }
+        return sysUserTokenService.createToken(userDTO.getId());
     }
 
+    @PostMapping("/register")
+    @Operation(summary = "注册")
+    public Result<Void> register(@RequestBody LoginDTO login) {
+        // 验证是否正确输入验证码
+        boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha());
+        if (!validate) {
+            throw new RenException("验证码错误，请重新获取");
+        }
+        // 按照用户名获取用户
+        SysUserDTO userDTO = sysUserService.getByUsername(login.getUsername());
+        if (userDTO != null) {
+            throw new RenException("此手机号码已经注册过");
+        }
+        userDTO = new SysUserDTO();
+        userDTO.setUsername(login.getUsername());
+        userDTO.setPassword(login.getPassword());
+        sysUserService.save(userDTO);
+        return new Result<>();
+
+    }
+
+    @GetMapping("/info")
+    @Operation(summary = "用户信息获取")
+    public Result<UserDetail> info() {
+        UserDetail user = SecurityUser.getUser();
+        Result<UserDetail> result = new Result<>();
+        result.setData(user);
+        return result;
+    }
+
+    @PutMapping("/change-password")
+    @Operation(summary = "修改用户密码")
+    public Result<?> changePassword(@RequestBody PasswordDTO passwordDTO) {
+        Long userId = SecurityUser.getUserId();
+        sysUserTokenService.changePassword(userId, passwordDTO);
+        return new Result<>();
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/security/dto/LoginDTO.java

@@ -13,7 +13,7 @@ import java.io.Serializable;
 @Schema(description = "登录表单")
 public class LoginDTO implements Serializable {
 
-    @Schema(description = "用户名", required = true)
+    @Schema(description = "手机号码")
     @NotBlank(message = "{sysuser.username.require}")
     private String username;
 
@@ -27,6 +27,6 @@ public class LoginDTO implements Serializable {
 
     @Schema(description = "唯一标识")
     @NotBlank(message = "{sysuser.uuid.require}")
-    private String uuid;
+    private String captchaId;
 
 }

main/manager-api/src/main/java/xiaozhi/modules/security/oauth2/Oauth2Filter.java

@@ -8,6 +8,8 @@ import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.authc.AuthenticationException;
 import org.apache.shiro.authc.AuthenticationToken;
 import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.bind.annotation.RequestMethod;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.ErrorCode;
@@ -24,12 +26,15 @@ import java.io.IOException;
  */
 public class Oauth2Filter extends AuthenticatingFilter {
 
+    private static final Logger logger = LoggerFactory.getLogger(Oauth2Filter.class);
+
     @Override
     protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) throws Exception {
         //获取请求token
         String token = getRequestToken((HttpServletRequest) request);
 
         if (StringUtils.isBlank(token)) {
+            logger.warn("createToken:token is empty");
             return null;
         }
 
@@ -49,7 +54,15 @@ public class Oauth2Filter extends AuthenticatingFilter {
     protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
         //获取请求token，如果token不存在，直接返回401
         String token = getRequestToken((HttpServletRequest) request);
+
+        // TODO 调试接口，临时取消登录限制，需要 token 参数的除外
+        if (true) {
+            return true;
+        }
+
         if (StringUtils.isBlank(token)) {
+            logger.warn("onAccessDenied:token is empty");
+
             HttpServletResponse httpResponse = (HttpServletResponse) response;
             httpResponse.setContentType("application/json;charset=utf-8");
             httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
@@ -73,13 +86,14 @@ public class Oauth2Filter extends AuthenticatingFilter {
         httpResponse.setHeader("Access-Control-Allow-Origin", HttpContextUtils.getOrigin());
         try {
             //处理登录失败的异常
+            logger.error("onLoginFailure:登录失败!", e);
             Throwable throwable = e.getCause() == null ? e : e.getCause();
             Result r = new Result().error(ErrorCode.UNAUTHORIZED, throwable.getMessage());
 
             String json = JsonUtils.toJsonString(r);
             httpResponse.getWriter().print(json);
         } catch (IOException e1) {
-
+            logger.error("onLoginFailure:登录失败! msg:{}", e1.getMessage(), e1);
         }
 
         return false;
@@ -89,12 +103,11 @@ public class Oauth2Filter extends AuthenticatingFilter {
      * 获取请求的token
      */
     private String getRequestToken(HttpServletRequest httpRequest) {
+        String token = null;
         //从header中获取token
-        String token = httpRequest.getHeader(Constant.TOKEN_HEADER);
+        String authorization = httpRequest.getHeader(Constant.AUTHORIZATION);
-
+        if (StringUtils.isNotBlank(authorization) && authorization.startsWith("Bearer ")) {
-        //如果header中不存在token，则从参数中获取token
+            token = authorization.replace("Bearer ", "");
-        if (StringUtils.isBlank(token)) {
-            token = httpRequest.getParameter(Constant.TOKEN_HEADER);
         }
         return token;
     }

main/manager-api/src/main/java/xiaozhi/modules/security/oauth2/Oauth2Realm.java

@@ -1,5 +1,15 @@
 package xiaozhi.modules.security.oauth2;
 
+import jakarta.annotation.Resource;
+import org.apache.shiro.authc.*;
+import org.apache.shiro.authz.AuthorizationInfo;
+import org.apache.shiro.authz.SimpleAuthorizationInfo;
+import org.apache.shiro.realm.AuthorizingRealm;
+import org.apache.shiro.subject.PrincipalCollection;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
 import xiaozhi.common.exception.ErrorCode;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
@@ -7,16 +17,9 @@ import xiaozhi.common.utils.MessageUtils;
 import xiaozhi.modules.security.entity.SysUserTokenEntity;
 import xiaozhi.modules.security.service.ShiroService;
 import xiaozhi.modules.sys.entity.SysUserEntity;
-import jakarta.annotation.Resource;
+import xiaozhi.modules.sys.enums.SuperAdminEnum;
-import org.apache.shiro.authc.*;
-import org.apache.shiro.authz.AuthorizationInfo;
-import org.apache.shiro.authz.SimpleAuthorizationInfo;
-import org.apache.shiro.realm.AuthorizingRealm;
-import org.apache.shiro.subject.PrincipalCollection;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Component;
 
-import java.util.List;
+import java.util.HashSet;
 import java.util.Set;
 
 /**
@@ -30,6 +33,8 @@ public class Oauth2Realm extends AuthorizingRealm {
     @Resource
     private ShiroService shiroService;
 
+    private static final Logger logger = LoggerFactory.getLogger(Oauth2Realm.class);
+
     @Override
     public boolean supports(AuthenticationToken token) {
         return token instanceof Oauth2Token;
@@ -43,7 +48,14 @@ public class Oauth2Realm extends AuthorizingRealm {
         UserDetail user = (UserDetail) principals.getPrimaryPrincipal();
 
         //用户权限列表
-        Set<String> permsSet = shiroService.getUserPermissions(user);
+        Set<String> permsSet = new HashSet<>();
+
+        if (user.getSuperAdmin() == SuperAdminEnum.YES.value()) {
+            permsSet.add("sys:role:superAdmin");
+            permsSet.add("sys:role:normal");
+        } else {
+            permsSet.add("sys:role:normal");
+        }
 
         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
         info.setStringPermissions(permsSet);
@@ -70,11 +82,14 @@ public class Oauth2Realm extends AuthorizingRealm {
         //转换成UserDetail对象
         UserDetail userDetail = ConvertUtils.sourceToTarget(userEntity, UserDetail.class);
 
-        //获取用户对应的部门数据权限
-        userDetail.setDeptIdList(null);
         userDetail.setToken(accessToken);
 
         //账号锁定
+        if (userDetail.getStatus() == null) {
+            logger.error("账号状态异常，status 不能为空");
+            throw new DisabledAccountException(MessageUtils.getMessage(ErrorCode.ACCOUNT_DISABLE));
+        }
+
         if (userDetail.getStatus() == 0) {
             throw new LockedAccountException(MessageUtils.getMessage(ErrorCode.ACCOUNT_LOCK));
         }

main/manager-api/src/main/java/xiaozhi/modules/security/service/ShiroService.java

@@ -1,22 +1,14 @@
 package xiaozhi.modules.security.service;
 
-import xiaozhi.common.user.UserDetail;
 import xiaozhi.modules.security.entity.SysUserTokenEntity;
 import xiaozhi.modules.sys.entity.SysUserEntity;
 
-import java.util.List;
-import java.util.Set;
-
 /**
  * shiro相关接口
  * Copyright (c) 人人开源 All rights reserved.
  * Website: https://www.renren.io
  */
 public interface ShiroService {
-    /**
-     * 获取用户权限列表
-     */
-    Set<String> getUserPermissions(UserDetail user);
 
     SysUserTokenEntity getByToken(String token);
 

main/manager-api/src/main/java/xiaozhi/modules/security/service/SysUserTokenService.java

@@ -1,11 +1,11 @@
 package xiaozhi.modules.security.service;
 
-import xiaozhi.common.page.PageData;
+import xiaozhi.common.page.TokenDTO;
 import xiaozhi.common.service.BaseService;
 import xiaozhi.common.utils.Result;
 import xiaozhi.modules.security.entity.SysUserTokenEntity;
-
+import xiaozhi.modules.sys.dto.PasswordDTO;
-import java.util.Map;
+import xiaozhi.modules.sys.dto.SysUserDTO;
 
 /**
  * 用户Token
@@ -19,7 +19,9 @@ public interface SysUserTokenService extends BaseService<SysUserTokenEntity> {
      *
      * @param userId 用户ID
      */
-    Result createToken(Long userId);
+    Result<TokenDTO> createToken(Long userId);
+
+    SysUserDTO getUserByToken(String token);
 
     /**
      * 退出
@@ -28,4 +30,12 @@ public interface SysUserTokenService extends BaseService<SysUserTokenEntity> {
      */
     void logout(Long userId);
 
+    /**
+     * 修改密码
+     *
+     * @param userId
+     * @param passwordDTO
+     */
+    void changePassword(Long userId, PasswordDTO passwordDTO);
+
 }

main/manager-api/src/main/java/xiaozhi/modules/security/service/impl/CaptchaServiceImpl.java

@@ -4,8 +4,11 @@ import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 import com.wf.captcha.SpecCaptcha;
 import com.wf.captcha.base.Captcha;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.modules.security.oauth2.Oauth2Realm;
 import xiaozhi.modules.security.service.CaptchaService;
 import jakarta.annotation.Resource;
 import jakarta.servlet.http.HttpServletResponse;
@@ -29,6 +32,7 @@ public class CaptchaServiceImpl implements CaptchaService {
      * Local Cache  5分钟过期
      */
     Cache<String, String> localCache = CacheBuilder.newBuilder().maximumSize(1000).expireAfterAccess(5, TimeUnit.MINUTES).build();
+    private static final Logger logger = LoggerFactory.getLogger(Oauth2Realm.class);
 
     @Override
     public void create(HttpServletResponse response, String uuid) throws IOException {

main/manager-api/src/main/java/xiaozhi/modules/security/service/impl/ShiroServiceImpl.java

@@ -19,22 +19,6 @@ public class ShiroServiceImpl implements ShiroService {
     private final SysUserDao sysUserDao;
     private final SysUserTokenDao sysUserTokenDao;
 
-    @Override
-    public Set<String> getUserPermissions(UserDetail user) {
-        //系统管理员，拥有最高权限
-        // TODO: 暂时写死，后续改成从数据库查询
-        List<String> permissionsList = new ArrayList<>();
-        //用户权限列表
-        Set<String> permsSet = new HashSet<>();
-        for (String permissions : permissionsList) {
-            if (StringUtils.isBlank(permissions)) {
-                continue;
-            }
-            permsSet.addAll(Arrays.asList(permissions.trim().split(",")));
-        }
-
-        return permsSet;
-    }
 
     @Override
     public SysUserTokenEntity getByToken(String token) {

main/manager-api/src/main/java/xiaozhi/modules/security/service/impl/SysUserTokenServiceImpl.java

@@ -1,6 +1,10 @@
 package xiaozhi.modules.security.service.impl;
 
 import cn.hutool.core.date.DateUtil;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.TokenDTO;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.HttpContextUtils;
@@ -9,19 +13,24 @@ import xiaozhi.modules.security.dao.SysUserTokenDao;
 import xiaozhi.modules.security.entity.SysUserTokenEntity;
 import xiaozhi.modules.security.oauth2.TokenGenerator;
 import xiaozhi.modules.security.service.SysUserTokenService;
-import org.springframework.stereotype.Service;
+import xiaozhi.modules.sys.dto.PasswordDTO;
+import xiaozhi.modules.sys.dto.SysUserDTO;
+import xiaozhi.modules.sys.service.SysUserService;
 
 import java.util.Date;
 
+@AllArgsConstructor
 @Service
 public class SysUserTokenServiceImpl extends BaseServiceImpl<SysUserTokenDao, SysUserTokenEntity> implements SysUserTokenService {
+
+    private final SysUserService sysUserService;
     /**
      * 12小时后过期
      */
     private final static int EXPIRE = 3600 * 12;
 
     @Override
-    public Result createToken(Long userId) {
+    public Result<TokenDTO> createToken(Long userId) {
         //用户token
         String token;
 
@@ -70,9 +79,36 @@ public class SysUserTokenServiceImpl extends BaseServiceImpl<SysUserTokenDao, Sy
         return new Result().ok(tokenDTO);
     }
 
+    @Override
+    public SysUserDTO getUserByToken(String token) {
+        SysUserTokenEntity userToken = baseDao.getByToken(token);
+        if (null == userToken) {
+            throw new RenException(ErrorCode.TOKEN_INVALID);
+        }
+
+        Date now = new Date();
+        if (userToken.getExpireDate().before(now)) {
+            throw new RenException(ErrorCode.UNAUTHORIZED);
+        }
+
+        SysUserDTO userDTO = sysUserService.getByUserId(userToken.getUserId());
+        userDTO.setPassword("");
+        return userDTO;
+    }
+
     @Override
     public void logout(Long userId) {
         Date expireDate = DateUtil.offsetMinute(new Date(), -1);
         baseDao.logout(userId, expireDate);
     }
+
+    @Override
+    public void changePassword(Long userId, PasswordDTO passwordDTO) {
+        // 修改密码
+        sysUserService.changePassword(userId, passwordDTO);
+
+        // 使 token 失效，后需要重新登录
+        Date expireDate = DateUtil.offsetMinute(new Date(), -1);
+        baseDao.logout(userId, expireDate);
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/security/user/SecurityUser.java

@@ -46,11 +46,4 @@ public class SecurityUser {
     public static Long getUserId() {
         return getUser().getId();
     }
-
-    /**
-     * 获取部门ID
-     */
-    public static Long getDeptId() {
-        return getUser().getDeptId();
-    }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysUserController.java

@@ -1,34 +1,9 @@
 package xiaozhi.modules.sys.controller;
 
-import xiaozhi.common.annotation.LogOperation;
-import xiaozhi.common.constant.Constant;
-import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.exception.RenException;
-import xiaozhi.common.page.PageData;
-import xiaozhi.common.user.UserDetail;
-import xiaozhi.common.utils.ConvertUtils;
-import xiaozhi.common.utils.Result;
-import xiaozhi.common.validator.AssertUtils;
-import xiaozhi.common.validator.ValidatorUtils;
-import xiaozhi.common.validator.group.AddGroup;
-import xiaozhi.common.validator.group.DefaultGroup;
-import xiaozhi.common.validator.group.UpdateGroup;
-import xiaozhi.modules.security.password.PasswordUtils;
-import xiaozhi.modules.security.user.SecurityUser;
-import xiaozhi.modules.sys.dto.PasswordDTO;
-import xiaozhi.modules.sys.dto.SysUserDTO;
-import xiaozhi.modules.sys.service.SysUserService;
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.Parameter;
-import io.swagger.v3.oas.annotations.Parameters;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.AllArgsConstructor;
-import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.RestController;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
 
 /**
  * 用户管理
@@ -38,119 +13,5 @@ import java.util.Map;
 @RequestMapping("/sys/user")
 @Tag(name = "用户管理")
 public class SysUserController {
-    private final SysUserService sysUserService;
 
-    @GetMapping("page")
-    @Operation(summary = "分页")
-    @Parameters({
-            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
-            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
-            @Parameter(name = Constant.ORDER_FIELD, description = "排序字段"),
-            @Parameter(name = Constant.ORDER, description = "排序方式，可选值(asc、desc)"),
-            @Parameter(name = "username", description = "用户名"),
-            @Parameter(name = "gender", description = "性别"),
-            @Parameter(name = "deptId", description = "部门ID")
-    })
-    @RequiresPermissions("sys:user:page")
-    public Result<PageData<SysUserDTO>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
-        PageData<SysUserDTO> page = sysUserService.page(params);
-
-        return new Result<PageData<SysUserDTO>>().ok(page);
-    }
-
-    @GetMapping("{id}")
-    @Operation(summary = "信息")
-    @RequiresPermissions("sys:user:info")
-    public Result<SysUserDTO> get(@PathVariable("id") Long id) {
-        SysUserDTO data = sysUserService.get(id);
-        return new Result<SysUserDTO>().ok(data);
-    }
-
-    @GetMapping("info")
-    @Operation(summary = "登录用户信息")
-    public Result<SysUserDTO> info() {
-        SysUserDTO data = ConvertUtils.sourceToTarget(SecurityUser.getUser(), SysUserDTO.class);
-        return new Result<SysUserDTO>().ok(data);
-    }
-
-    @PutMapping("password")
-    @Operation(summary = "修改密码")
-    @LogOperation("修改密码")
-    public Result password(@RequestBody PasswordDTO dto) {
-        //效验数据
-        ValidatorUtils.validateEntity(dto);
-        String newPassword = dto.getNewPassword();
-        String password = dto.getPassword();
-
-        //密码的强度
-        if (newPassword == null || newPassword.length() < 8) {
-            return new Result().error(ErrorCode.PASSWORD_LENGTH_ERROR);
-        }
-        if (!sysUserService.isStrongPassword(newPassword)) {
-            return new Result().error(ErrorCode.PASSWORD_WEAK_ERROR);
-        }
-        UserDetail user = SecurityUser.getUser();
-        //原密码不正确
-        if (!PasswordUtils.matches(dto.getPassword(), user.getPassword())) {
-            return new Result().error(ErrorCode.PASSWORD_ERROR);
-        }
-
-        sysUserService.updatePassword(user.getId(), dto.getNewPassword());
-
-        return new Result();
-    }
-
-    @PostMapping
-    @Operation(summary = "保存")
-    @LogOperation("保存")
-    @RequiresPermissions("sys:user:save")
-    public Result save(@RequestBody SysUserDTO dto) {
-        //效验数据
-        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);
-
-        sysUserService.save(dto);
-
-        return new Result();
-    }
-
-    @PutMapping
-    @Operation(summary = "修改")
-    @LogOperation("修改")
-    @RequiresPermissions("sys:user:update")
-    public Result update(@RequestBody SysUserDTO dto) {
-        //效验数据
-        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);
-
-        sysUserService.update(dto);
-
-        return new Result();
-    }
-
-    @PutMapping("app")
-    @Operation(summary = "修改")
-    @LogOperation("修改")
-    @RequiresPermissions("sys:user:update")
-    public Result updateUserInfo(@RequestBody SysUserDTO dto) {
-        sysUserService.updateUserInfo(dto);
-
-        return new Result();
-    }
-
-    @DeleteMapping
-    @Operation(summary = "删除")
-    @LogOperation("删除")
-    @RequiresPermissions("sys:user:delete")
-    public Result delete(@RequestBody Long[] ids) {
-        //效验数据
-        AssertUtils.isArrayEmpty(ids, "id");
-
-        List<Long> idList = Arrays.asList(ids);
-        if (idList.contains(SecurityUser.getUserId())) {
-            throw new RenException(ErrorCode.DEL_MYSELF_ERROR);
-        }
-
-        sysUserService.deleteBatchIds(idList);
-
-        return new Result();
-    }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dao/SysUserDao.java

@@ -1,12 +1,8 @@
 package xiaozhi.modules.sys.dao;
 
+import org.apache.ibatis.annotations.Mapper;
 import xiaozhi.common.dao.BaseDao;
 import xiaozhi.modules.sys.entity.SysUserEntity;
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
-import java.util.Map;
 
 /**
  * 系统用户
@@ -14,21 +10,4 @@ import java.util.Map;
 @Mapper
 public interface SysUserDao extends BaseDao<SysUserEntity> {
 
-    List<SysUserEntity> getList(Map<String, Object> params);
-
-    SysUserEntity getById(Long id);
-
-    SysUserEntity getByUsername(String username);
-
-    int updatePassword(@Param("id") Long id, @Param("newPassword") String newPassword);
-
-    /**
-     * 根据部门ID，查询用户数
-     */
-    int getCountByDeptId(Long deptId);
-
-    /**
-     * 根据部门ID,查询用户ID列表
-     */
-    List<Long> getUserIdListByDeptId(List<Long> deptIdList);
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/AdminPageUserDTO.java

@@ -0,0 +1,25 @@
+package xiaozhi.modules.sys.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 管理员分页用户的参数DTO
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+@Schema(description = "音色分页参数")
+public class AdminPageUserDTO {
+
+
+    @Schema(description = "手机号码")
+    private String mobile;
+
+    @Schema(description = "页数")
+    private String page;
+
+    @Schema(description = "显示列数")
+    private String limit;
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/SysDictDataDTO.java

@@ -1,59 +1,59 @@
-package xiaozhi.modules.sys.dto;
+package xiaozhi.modules.sys.dto;
-
+
-import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonProperty;
-import xiaozhi.common.utils.DateUtils;
+import xiaozhi.common.utils.DateUtils;
-import xiaozhi.common.validator.group.AddGroup;
+import xiaozhi.common.validator.group.AddGroup;
-import xiaozhi.common.validator.group.DefaultGroup;
+import xiaozhi.common.validator.group.DefaultGroup;
-import xiaozhi.common.validator.group.UpdateGroup;
+import xiaozhi.common.validator.group.UpdateGroup;
-import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Null;
+import jakarta.validation.constraints.Null;
-import lombok.Data;
+import lombok.Data;
-
+
-import java.io.Serializable;
+import java.io.Serializable;
-import java.util.Date;
+import java.util.Date;
-
+
-/**
+/**
- * 字典数据
+ * 字典数据
- */
+ */
-@Data
+@Data
-@Schema(description = "字典数据")
+@Schema(description = "字典数据")
-public class SysDictDataDTO implements Serializable {
+public class SysDictDataDTO implements Serializable {
-
+
-
+
-    @Schema(description = "id")
+    @Schema(description = "id")
-    @Null(message = "{id.null}", groups = AddGroup.class)
+    @Null(message = "{id.null}", groups = AddGroup.class)
-    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
+    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
-    private Long id;
+    private Long id;
-
+
-    @Schema(description = "字典类型ID")
+    @Schema(description = "字典类型ID")
-    @NotNull(message = "{sysdict.type.require}", groups = DefaultGroup.class)
+    @NotNull(message = "{sysdict.type.require}", groups = DefaultGroup.class)
-    private Long dictTypeId;
+    private Long dictTypeId;
-
+
-    @Schema(description = "字典标签")
+    @Schema(description = "字典标签")
-    @NotBlank(message = "{sysdict.label.require}", groups = DefaultGroup.class)
+    @NotBlank(message = "{sysdict.label.require}", groups = DefaultGroup.class)
-    private String dictLabel;
+    private String dictLabel;
-
+
-    @Schema(description = "字典值")
+    @Schema(description = "字典值")
-    private String dictValue;
+    private String dictValue;
-
+
-    @Schema(description = "备注")
+    @Schema(description = "备注")
-    private String remark;
+    private String remark;
-
+
-    @Schema(description = "排序")
+    @Schema(description = "排序")
-    @Min(value = 0, message = "{sort.number}", groups = DefaultGroup.class)
+    @Min(value = 0, message = "{sort.number}", groups = DefaultGroup.class)
-    private Integer sort;
+    private Integer sort;
-
+
-    @Schema(description = "创建时间")
+    @Schema(description = "创建时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
-    private Date createDate;
+    private Date createDate;
-
+
-    @Schema(description = "更新时间")
+    @Schema(description = "更新时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
-    private Date updateDate;
+    private Date updateDate;
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/SysDictTypeDTO.java

@@ -1,55 +1,55 @@
-package xiaozhi.modules.sys.dto;
+package xiaozhi.modules.sys.dto;
-
+
-import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonProperty;
-import xiaozhi.common.utils.DateUtils;
+import xiaozhi.common.utils.DateUtils;
-import xiaozhi.common.validator.group.AddGroup;
+import xiaozhi.common.validator.group.AddGroup;
-import xiaozhi.common.validator.group.DefaultGroup;
+import xiaozhi.common.validator.group.DefaultGroup;
-import xiaozhi.common.validator.group.UpdateGroup;
+import xiaozhi.common.validator.group.UpdateGroup;
-import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Null;
+import jakarta.validation.constraints.Null;
-import lombok.Data;
+import lombok.Data;
-
+
-import java.io.Serializable;
+import java.io.Serializable;
-import java.util.Date;
+import java.util.Date;
-
+
-/**
+/**
- * 字典类型
+ * 字典类型
- */
+ */
-@Data
+@Data
-@Schema(description = "字典类型")
+@Schema(description = "字典类型")
-public class SysDictTypeDTO implements Serializable {
+public class SysDictTypeDTO implements Serializable {
-
+
-
+
-    @Schema(description = "id")
+    @Schema(description = "id")
-    @Null(message = "{id.null}", groups = AddGroup.class)
+    @Null(message = "{id.null}", groups = AddGroup.class)
-    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
+    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
-    private Long id;
+    private Long id;
-
+
-    @Schema(description = "字典类型")
+    @Schema(description = "字典类型")
-    @NotBlank(message = "{sysdict.type.require}", groups = DefaultGroup.class)
+    @NotBlank(message = "{sysdict.type.require}", groups = DefaultGroup.class)
-    private String dictType;
+    private String dictType;
-
+
-    @Schema(description = "字典名称")
+    @Schema(description = "字典名称")
-    @NotBlank(message = "{sysdict.name.require}", groups = DefaultGroup.class)
+    @NotBlank(message = "{sysdict.name.require}", groups = DefaultGroup.class)
-    private String dictName;
+    private String dictName;
-
+
-    @Schema(description = "备注")
+    @Schema(description = "备注")
-    private String remark;
+    private String remark;
-
+
-    @Schema(description = "排序")
+    @Schema(description = "排序")
-    @Min(value = 0, message = "{sort.number}", groups = DefaultGroup.class)
+    @Min(value = 0, message = "{sort.number}", groups = DefaultGroup.class)
-    private Integer sort;
+    private Integer sort;
-
+
-    @Schema(description = "创建时间")
+    @Schema(description = "创建时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
-    private Date createDate;
+    private Date createDate;
-
+
-    @Schema(description = "更新时间")
+    @Schema(description = "更新时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    private Date updateDate;
+    private Date updateDate;
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/dto/SysParamsDTO.java

@@ -1,52 +1,52 @@
-package xiaozhi.modules.sys.dto;
+package xiaozhi.modules.sys.dto;
-
+
-import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonFormat;
-import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonProperty;
-import xiaozhi.common.utils.DateUtils;
+import xiaozhi.common.utils.DateUtils;
-import xiaozhi.common.validator.group.AddGroup;
+import xiaozhi.common.validator.group.AddGroup;
-import xiaozhi.common.validator.group.DefaultGroup;
+import xiaozhi.common.validator.group.DefaultGroup;
-import xiaozhi.common.validator.group.UpdateGroup;
+import xiaozhi.common.validator.group.UpdateGroup;
-import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Null;
+import jakarta.validation.constraints.Null;
-import lombok.Data;
+import lombok.Data;
-
+
-import java.io.Serializable;
+import java.io.Serializable;
-import java.util.Date;
+import java.util.Date;
-
+
-/**
+/**
- * 参数管理
+ * 参数管理
- */
+ */
-@Data
+@Data
-@Schema(description = "参数管理")
+@Schema(description = "参数管理")
-public class SysParamsDTO implements Serializable {
+public class SysParamsDTO implements Serializable {
-
+
-
+
-    @Schema(description = "id")
+    @Schema(description = "id")
-    @Null(message = "{id.null}", groups = AddGroup.class)
+    @Null(message = "{id.null}", groups = AddGroup.class)
-    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
+    @NotNull(message = "{id.require}", groups = UpdateGroup.class)
-    private Long id;
+    private Long id;
-
+
-    @Schema(description = "参数编码")
+    @Schema(description = "参数编码")
-    @NotBlank(message = "{sysparams.paramcode.require}", groups = DefaultGroup.class)
+    @NotBlank(message = "{sysparams.paramcode.require}", groups = DefaultGroup.class)
-    private String paramCode;
+    private String paramCode;
-
+
-    @Schema(description = "参数值")
+    @Schema(description = "参数值")
-    @NotBlank(message = "{sysparams.paramvalue.require}", groups = DefaultGroup.class)
+    @NotBlank(message = "{sysparams.paramvalue.require}", groups = DefaultGroup.class)
-    private String paramValue;
+    private String paramValue;
-
+
-    @Schema(description = "备注")
+    @Schema(description = "备注")
-    private String remark;
+    private String remark;
-
+
-    @Schema(description = "创建时间")
+    @Schema(description = "创建时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
-    private Date createDate;
+    private Date createDate;
-
+
-    @Schema(description = "更新时间")
+    @Schema(description = "更新时间")
-    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
+    @JsonProperty(access = JsonProperty.Access.READ_ONLY)
-    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
+    @JsonFormat(pattern = DateUtils.DATE_TIME_PATTERN)
-    private Date updateDate;
+    private Date updateDate;
-
+
-}
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/entity/SysUserEntity.java

@@ -3,9 +3,9 @@ package xiaozhi.modules.sys.entity;
 import com.baomidou.mybatisplus.annotation.FieldFill;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
-import xiaozhi.common.entity.BaseEntity;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import xiaozhi.common.entity.BaseEntity;
 
 import java.util.Date;
 
@@ -24,30 +24,6 @@ public class SysUserEntity extends BaseEntity {
      * 密码
      */
     private String password;
-    /**
-     * 姓名
-     */
-    private String realName;
-    /**
-     * 头像
-     */
-    private String headUrl;
-    /**
-     * 性别   0：男   1：女    2：保密
-     */
-    private Integer gender;
-    /**
-     * 邮箱
-     */
-    private String email;
-    /**
-     * 手机号
-     */
-    private String mobile;
-    /**
-     * 部门ID
-     */
-    private Long deptId;
     /**
      * 超级管理员   0：否   1：是
      */
@@ -66,10 +42,5 @@ public class SysUserEntity extends BaseEntity {
      */
     @TableField(fill = FieldFill.INSERT_UPDATE)
     private Date updateDate;
-    /**
-     * 部门名称
-     */
-    @TableField(exist = false)
-    private String deptName;
 
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/SysDictTypeService.java

@@ -1,26 +1,30 @@
-package xiaozhi.modules.sys.service;
+package xiaozhi.modules.sys.service;
-
+
-import xiaozhi.common.page.PageData;
+import xiaozhi.common.page.PageData;
-import xiaozhi.common.service.BaseService;
+import xiaozhi.common.service.BaseService;
-import xiaozhi.modules.sys.dto.SysDictTypeDTO;
+import xiaozhi.modules.sys.dto.SysDictTypeDTO;
-import xiaozhi.modules.sys.entity.DictType;
+import xiaozhi.modules.sys.entity.DictType;
-import xiaozhi.modules.sys.entity.SysDictTypeEntity;
+import xiaozhi.modules.sys.entity.SysDictTypeEntity;
-
+
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-
+
-/**
+/**
- * 数据字典
+ * 数据字典
- */
+ */
-public interface SysDictTypeService extends BaseService<SysDictTypeEntity> {
+public interface SysDictTypeService extends BaseService<SysDictTypeEntity> {
-
+
-    PageData<SysDictTypeDTO> page(Map<String, Object> params);
+    PageData<SysDictTypeDTO> page(Map<String, Object> params);
-
+
-    SysDictTypeDTO get(Long id);
+    SysDictTypeDTO get(Long id);
-
+
-    void save(SysDictTypeDTO dto);
+    void save(SysDictTypeDTO dto);
-
+
-    void update(SysDictTypeDTO dto);
+    void update(SysDictTypeDTO dto);
-
+
-    void delete(Long[] ids);
+    void delete(Long[] ids);
+
+    List<DictType> getAllList();
+
+    List<DictType> getDictTypeList();
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/SysUserService.java

@@ -2,11 +2,11 @@ package xiaozhi.modules.sys.service;
 
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.sys.dto.AdminPageUserDTO;
+import xiaozhi.modules.sys.dto.PasswordDTO;
 import xiaozhi.modules.sys.dto.SysUserDTO;
 import xiaozhi.modules.sys.entity.SysUserEntity;
-
+import xiaozhi.modules.sys.vo.AdminPageUserVO;
-import java.util.List;
-import java.util.Map;
 
 
 /**
@@ -14,54 +14,38 @@ import java.util.Map;
  */
 public interface SysUserService extends BaseService<SysUserEntity> {
 
-    PageData<SysUserDTO> page(Map<String, Object> params);
-
-    List<SysUserDTO> list(Map<String, Object> params);
-
-    SysUserDTO get(Long id);
-
     SysUserDTO getByUsername(String username);
 
+    SysUserDTO getByUserId(Long userId);
+
     void save(SysUserDTO dto);
 
-    void update(SysUserDTO dto);
-
-    void updateUserInfo(SysUserDTO dto);
-
     void delete(Long[] ids);
 
     /**
-     * 修改密码
+     * 验证是否允许修改密码更改
-     *
+     * @param userId 用户id
-     * @param id          用户ID
+     * @param passwordDTO 验证密码的参数
-     * @param newPassword 新密码
      */
-    void updatePassword(Long id, String newPassword);
+    void changePassword(Long userId, PasswordDTO passwordDTO);
 
     /**
-     * 根据部门ID，查询用户数
+     * 直接修改密码，不需要验证
+     * @param userId 用户id
+     * @param password 密码
      */
-    int getCountByDeptId(Long deptId);
+    void changePasswordDirectly(Long userId, String password);
 
     /**
-     * 根据部门ID,查询用户Id列表
+     * 重置密码
+     * @param userId 用户id
+     * @return 随机生成符合规范的密码
      */
-    List<Long> getUserIdListByDeptId(List<Long> deptIdList);
+    String resetPassword(Long userId);
-
     /**
-     * 删除用户缓存
+     * 管理员分页用户信息
-     *
+     * @param dto 分页查找参数
-     * @param userId
+     * @return 用户列表分页数据
      */
-    void deleteUserCache(Long userId);
+    PageData<AdminPageUserVO> page(AdminPageUserDTO dto);
-
-    /**
-     * 验证密码强度
-     *
-     * @param newPassword
-     * @return
-     */
-    boolean isStrongPassword(String newPassword);
-
-    String getName(Long creator);
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/TokenService.java

@@ -0,0 +1,11 @@
+package xiaozhi.modules.sys.service;
+
+public interface TokenService {
+    /**
+     * 生成token
+     *
+     * @param userId
+     * @return
+     */
+    String createToken(long userId);
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysDictTypeServiceImpl.java

@@ -1,102 +1,102 @@
-package xiaozhi.modules.sys.service.impl;
+package xiaozhi.modules.sys.service.impl;
-
+
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.metadata.IPage;
-import lombok.AllArgsConstructor;
+import lombok.AllArgsConstructor;
-import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.StringUtils;
-import org.springframework.stereotype.Service;
+import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.annotation.Transactional;
-import xiaozhi.common.page.PageData;
+import xiaozhi.common.page.PageData;
-import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.common.service.impl.BaseServiceImpl;
-import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.common.utils.ConvertUtils;
-import xiaozhi.modules.sys.dao.SysDictDataDao;
+import xiaozhi.modules.sys.dao.SysDictDataDao;
-import xiaozhi.modules.sys.dao.SysDictTypeDao;
+import xiaozhi.modules.sys.dao.SysDictTypeDao;
-import xiaozhi.modules.sys.dto.SysDictTypeDTO;
+import xiaozhi.modules.sys.dto.SysDictTypeDTO;
-import xiaozhi.modules.sys.entity.DictData;
+import xiaozhi.modules.sys.entity.DictData;
-import xiaozhi.modules.sys.entity.DictType;
+import xiaozhi.modules.sys.entity.DictType;
-import xiaozhi.modules.sys.entity.SysDictTypeEntity;
+import xiaozhi.modules.sys.entity.SysDictTypeEntity;
-import xiaozhi.modules.sys.service.SysDictTypeService;
+import xiaozhi.modules.sys.service.SysDictTypeService;
-
+
-import java.util.Arrays;
+import java.util.Arrays;
-import java.util.List;
+import java.util.List;
-import java.util.Map;
+import java.util.Map;
-
+
-/**
+/**
- * 字典类型
+ * 字典类型
- */
+ */
-@AllArgsConstructor
+@AllArgsConstructor
-@Service
+@Service
-public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysDictTypeEntity> implements SysDictTypeService {
+public class SysDictTypeServiceImpl extends BaseServiceImpl<SysDictTypeDao, SysDictTypeEntity> implements SysDictTypeService {
-    private final SysDictDataDao sysDictDataDao;
+    private final SysDictDataDao sysDictDataDao;
-
+
-    @Override
+    @Override
-    public PageData<SysDictTypeDTO> page(Map<String, Object> params) {
+    public PageData<SysDictTypeDTO> page(Map<String, Object> params) {
-        IPage<SysDictTypeEntity> page = baseDao.selectPage(
+        IPage<SysDictTypeEntity> page = baseDao.selectPage(
-                getPage(params, "sort", true),
+                getPage(params, "sort", true),
-                getWrapper(params)
+                getWrapper(params)
-        );
+        );
-
+
-        return getPageData(page, SysDictTypeDTO.class);
+        return getPageData(page, SysDictTypeDTO.class);
-    }
+    }
-
+
-    private QueryWrapper<SysDictTypeEntity> getWrapper(Map<String, Object> params) {
+    private QueryWrapper<SysDictTypeEntity> getWrapper(Map<String, Object> params) {
-        String dictType = (String) params.get("dictType");
+        String dictType = (String) params.get("dictType");
-        String dictName = (String) params.get("dictName");
+        String dictName = (String) params.get("dictName");
-
+
-        QueryWrapper<SysDictTypeEntity> wrapper = new QueryWrapper<>();
+        QueryWrapper<SysDictTypeEntity> wrapper = new QueryWrapper<>();
-        wrapper.like(StringUtils.isNotBlank(dictType), "dict_type", dictType);
+        wrapper.like(StringUtils.isNotBlank(dictType), "dict_type", dictType);
-        wrapper.like(StringUtils.isNotBlank(dictName), "dict_name", dictName);
+        wrapper.like(StringUtils.isNotBlank(dictName), "dict_name", dictName);
-
+
-        return wrapper;
+        return wrapper;
-    }
+    }
-
+
-    @Override
+    @Override
-    public SysDictTypeDTO get(Long id) {
+    public SysDictTypeDTO get(Long id) {
-        SysDictTypeEntity entity = baseDao.selectById(id);
+        SysDictTypeEntity entity = baseDao.selectById(id);
-
+
-        return ConvertUtils.sourceToTarget(entity, SysDictTypeDTO.class);
+        return ConvertUtils.sourceToTarget(entity, SysDictTypeDTO.class);
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public void save(SysDictTypeDTO dto) {
+    public void save(SysDictTypeDTO dto) {
-        SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
+        SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
-
+
-        insert(entity);
+        insert(entity);
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public void update(SysDictTypeDTO dto) {
+    public void update(SysDictTypeDTO dto) {
-        SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
+        SysDictTypeEntity entity = ConvertUtils.sourceToTarget(dto, SysDictTypeEntity.class);
-
+
-        updateById(entity);
+        updateById(entity);
-    }
+    }
-
+
-    @Override
+    @Override
-    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
-    public void delete(Long[] ids) {
+    public void delete(Long[] ids) {
-        //删除
+        //删除
-        deleteBatchIds(Arrays.asList(ids));
+        deleteBatchIds(Arrays.asList(ids));
-    }
+    }
-
+
-    @Override
+    @Override
-    public List<DictType> getAllList() {
+    public List<DictType> getAllList() {
-        List<DictType> typeList = baseDao.getDictTypeList();
+        List<DictType> typeList = baseDao.getDictTypeList();
-        List<DictData> dataList = sysDictDataDao.getDictDataList();
+        List<DictData> dataList = sysDictDataDao.getDictDataList();
-        for (DictType type : typeList) {
+        for (DictType type : typeList) {
-            for (DictData data : dataList) {
+            for (DictData data : dataList) {
-                if (type.getId().equals(data.getDictTypeId())) {
+                if (type.getId().equals(data.getDictTypeId())) {
-                    type.getDataList().add(data);
+                    type.getDataList().add(data);
-                }
+                }
-            }
+            }
-        }
+        }
-        return typeList;
+        return typeList;
-    }
+    }
-
+
-    @Override
+    @Override
-    public List<DictType> getDictTypeList() {
+    public List<DictType> getDictTypeList() {
-        return baseDao.getDictTypeList();
+        return baseDao.getDictTypeList();
-    }
+    }
-
+
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/SysUserServiceImpl.java

@@ -1,29 +1,28 @@
 package xiaozhi.modules.sys.service.impl;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
-import xiaozhi.common.exception.ErrorCode;
-import xiaozhi.common.exception.RenException;
-import xiaozhi.common.page.PageData;
-import xiaozhi.common.redis.RedisKeys;
-import xiaozhi.common.redis.RedisUtils;
-import xiaozhi.common.service.impl.BaseServiceImpl;
-import xiaozhi.common.user.UserDetail;
-import xiaozhi.common.utils.ConvertUtils;
-import xiaozhi.modules.security.password.PasswordUtils;
-import xiaozhi.modules.security.user.SecurityUser;
-import xiaozhi.modules.sys.dao.SysUserDao;
-import xiaozhi.modules.sys.dto.SysUserDTO;
-import xiaozhi.modules.sys.entity.SysUserEntity;
-import xiaozhi.modules.sys.enums.SuperAdminEnum;
-import xiaozhi.modules.sys.service.SysUserService;
 import lombok.AllArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.RenException;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.security.password.PasswordUtils;
+import xiaozhi.modules.sys.dao.SysUserDao;
+import xiaozhi.modules.sys.dto.AdminPageUserDTO;
+import xiaozhi.modules.sys.dto.PasswordDTO;
+import xiaozhi.modules.sys.dto.SysUserDTO;
+import xiaozhi.modules.sys.entity.SysUserEntity;
+import xiaozhi.modules.sys.enums.SuperAdminEnum;
+import xiaozhi.modules.sys.service.SysUserService;
+import xiaozhi.modules.sys.vo.AdminPageUserVO;
 
-import java.util.Arrays;
+import java.util.*;
-import java.util.List;
-import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -34,43 +33,27 @@ import java.util.regex.Pattern;
 @AllArgsConstructor
 @Service
 public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntity> implements SysUserService {
-    private final RedisUtils redisUtils;
+    private final SysUserDao sysUserDao;
-
-    @Override
-    public PageData<SysUserDTO> page(Map<String, Object> params) {
-        //转换成like
-        paramsToLike(params, "username");
-
-        //分页
-        IPage<SysUserEntity> page = getPage(params, "t1.create_date", false);
-
-        //查询
-        List<SysUserEntity> list = baseDao.getList(params);
-
-        return getPageData(list, page.getTotal(), SysUserDTO.class);
-    }
-
-    @Override
-    public List<SysUserDTO> list(Map<String, Object> params) {
-
-        List<SysUserEntity> entityList = baseDao.getList(params);
-
-        return ConvertUtils.sourceToTarget(entityList, SysUserDTO.class);
-    }
-
-    @Override
-    public SysUserDTO get(Long id) {
-        SysUserEntity entity = baseDao.getById(id);
-
-        return ConvertUtils.sourceToTarget(entity, SysUserDTO.class);
-    }
 
     @Override
     public SysUserDTO getByUsername(String username) {
-        SysUserEntity entity = baseDao.getByUsername(username);
+        QueryWrapper<SysUserEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("username", username);
+        List<SysUserEntity> users = sysUserDao.selectList(queryWrapper);
+        if (users == null || users.isEmpty()) {
+            return null;
+        }
+        SysUserEntity entity = users.getFirst();
         return ConvertUtils.sourceToTarget(entity, SysUserDTO.class);
     }
 
+    @Override
+    public SysUserDTO getByUserId(Long userId) {
+        SysUserEntity sysUserEntity = sysUserDao.selectById(userId);
+
+        return ConvertUtils.sourceToTarget(sysUserEntity, SysUserDTO.class);
+    }
+
     @Override
     @Transactional(rollbackFor = Exception.class)
     public void save(SysUserDTO dto) {
@@ -86,42 +69,15 @@ public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntit
         entity.setPassword(password);
 
         //保存用户
-        entity.setSuperAdmin(SuperAdminEnum.NO.value());
+        Long userCount = getUserCount();
-        insert(entity);
+        if (userCount == 0) {
-    }
+            entity.setSuperAdmin(SuperAdminEnum.YES.value());
-
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public void update(SysUserDTO dto) {
-        SysUserEntity entity = ConvertUtils.sourceToTarget(dto, SysUserEntity.class);
-
-        //密码加密
-        if (StringUtils.isBlank(dto.getPassword())) {
-            entity.setPassword(null);
         } else {
-            //密码强度
+            entity.setSuperAdmin(SuperAdminEnum.NO.value());
-            if (!isStrongPassword(entity.getPassword())) {
-                throw new RenException(ErrorCode.PASSWORD_WEAK_ERROR);
-            }
-            String password = PasswordUtils.encode(entity.getPassword());
-            entity.setPassword(password);
         }
+        entity.setStatus(1);
 
-        //更新用户
+        insert(entity);
-        updateById(entity);
-    }
-
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public void updateUserInfo(SysUserDTO dto) {
-        SysUserEntity entity = selectById(dto.getId());
-        entity.setHeadUrl(dto.getHeadUrl());
-        entity.setRealName(dto.getRealName());
-        entity.setGender(dto.getGender());
-        entity.setMobile(dto.getMobile());
-        entity.setEmail(dto.getEmail());
-
-        updateById(entity);
     }
 
     @Override
@@ -129,36 +85,81 @@ public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntit
     public void delete(Long[] ids) {
         //删除用户
         baseDao.deleteBatchIds(Arrays.asList(ids));
+        //TODO 除了要删除用户还要删除用户关联的设备，对话，智能体。等此3个功能完善在添加
     }
 
     @Override
     @Transactional(rollbackFor = Exception.class)
-    public void updatePassword(Long id, String newPassword) {
+    public void changePassword(Long userId, PasswordDTO passwordDTO) {
-        newPassword = PasswordUtils.encode(newPassword);
+        SysUserEntity sysUserEntity = sysUserDao.selectById(userId);
 
-        baseDao.updatePassword(id, newPassword);
+        if (null == sysUserEntity) {
+            throw new RenException(ErrorCode.TOKEN_INVALID);
+        }
+
+        // 判断旧密码是否正确
+        if (!PasswordUtils.matches(passwordDTO.getPassword(), sysUserEntity.getPassword())) {
+            throw new RenException("旧密码输入错误");
+        }
+
+        //新密码强度
+        if (!isStrongPassword(passwordDTO.getNewPassword())) {
+            throw new RenException(ErrorCode.PASSWORD_WEAK_ERROR);
+        }
+
+        //密码加密
+        String password = PasswordUtils.encode(passwordDTO.getNewPassword());
+        sysUserEntity.setPassword(password);
+
+        updateById(sysUserEntity);
+    }
+
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void changePasswordDirectly(Long userId, String password) {
+        SysUserEntity sysUserEntity = new SysUserEntity();
+        sysUserEntity.setId(userId);
+        sysUserEntity.setPassword(PasswordUtils.encode(password));
+        updateById(sysUserEntity);
     }
 
     @Override
-    public int getCountByDeptId(Long deptId) {
+    @Transactional(rollbackFor = Exception.class)
-        return baseDao.getCountByDeptId(deptId);
+    public String resetPassword(Long userId) {
+        String password = generatePassword();
+        changePasswordDirectly(userId,password);
+        return password;
+    }
+
+    private Long getUserCount() {
+        QueryWrapper<SysUserEntity> queryWrapper = new QueryWrapper<>();
+        return baseDao.selectCount(queryWrapper);
     }
 
     @Override
-    public List<Long> getUserIdListByDeptId(List<Long> deptIdList) {
+    public PageData<AdminPageUserVO> page(AdminPageUserDTO dto) {
-        return baseDao.getUserIdListByDeptId(deptIdList);
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put(Constant.PAGE, dto.getPage());
+        params.put(Constant.LIMIT,dto.getLimit());
+        IPage<SysUserEntity> page = baseDao.selectPage(
+                getPage(params, "id", true),
+                //定义查询条件
+                new QueryWrapper<SysUserEntity>()
+                        //必须按照手机号码查找
+                        .eq(StringUtils.isNotBlank(dto.getMobile()),"username",dto.getMobile()));
+        List<AdminPageUserVO> list = page.getRecords().stream().map(user -> {
+            AdminPageUserVO adminPageUserVO = new AdminPageUserVO();
+            adminPageUserVO.setUserid(user.getId().toString());
+            adminPageUserVO.setMobile(user.getUsername());
+            //TODO 2. 等设备功能写好，获取对应数据
+            adminPageUserVO.setDeviceCount("0");
+            return adminPageUserVO;
+        }).toList();
+        return new PageData<>(list, page.getTotal());
     }
 
-    @Override
+    private boolean isStrongPassword(String password) {
-    public void deleteUserCache(Long userId) {
-        // 删除缓存
-        redisUtils.delete(RedisKeys.getUserInfoKey(userId));
-        redisUtils.delete(RedisKeys.getDataScopeListKey(userId));
-        redisUtils.delete(RedisKeys.getSysUserName(userId));
-    }
-
-    @Override
-    public boolean isStrongPassword(String password) {
         // 弱密码的正则表达式
         String weakPasswordRegex = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).+$";
         Pattern pattern = Pattern.compile(weakPasswordRegex);
@@ -166,16 +167,18 @@ public class SysUserServiceImpl extends BaseServiceImpl<SysUserDao, SysUserEntit
         return matcher.matches();
     }
 
-    @Override
+    private static final String CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
-    public String getName(Long id) {
+    private static final Random random = new Random();
-        String name = (String) redisUtils.get(RedisKeys.getSysUserName(id));
+    /**
-        if (StringUtils.isBlank(name)) {
+     * 生成随机密码
-            SysUserEntity sysUserEntity = selectById(id);
+     * @return 随机生成的密码
-            if (sysUserEntity != null) {
+     */
-                redisUtils.set(RedisKeys.getSysUserName(id), sysUserEntity.getUsername());
+    private String generatePassword(){
-                return sysUserEntity.getUsername();
+        StringBuilder password = new StringBuilder();
-            }
+        for (int i = 0; i < 10; i++) {
+            int randomIndex = random.nextInt(CHARACTERS.length());
+            password.append(CHARACTERS.charAt(randomIndex));
         }
-        return name;
+        return password.toString();
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/service/impl/TokenServiceImpl.java

@@ -0,0 +1,31 @@
+package xiaozhi.modules.sys.service.impl;
+
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.modules.security.oauth2.TokenGenerator;
+import xiaozhi.modules.sys.service.TokenService;
+
+import java.util.Date;
+
+@AllArgsConstructor
+@Service
+public class TokenServiceImpl implements TokenService {
+    private final RedisUtils redisUtils;
+    /**
+     * 3小时无操作过期
+     */
+    private final static int EXPIRE = 60 * 60 * 3;
+
+    @Override
+    public String createToken(long userId) {
+        //生成一个token
+        String token = TokenGenerator.generateValue();
+
+        //当前时间
+        Date now = new Date();
+        //过期时间
+        Date expireTime = new Date(now.getTime() + EXPIRE * 1000);
+        return token;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/sys/vo/AdminPageUserVO.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.sys.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * 管理员分页展示用户的VO
+ * @ zjy
+ * @since 2025-3-25
+ */
+@Data
+public class AdminPageUserVO {
+
+    @Schema(description = "设备数量")
+    private String deviceCount;
+
+    @Schema(description = "手机号码")
+    private String mobile;
+
+    @Schema(description = "用户id")
+    private String userid;
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/controller/TimbreController.java

@@ -0,0 +1,85 @@
+package xiaozhi.modules.timbre.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.*;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.timbre.dto.TimbreDataDTO;
+import xiaozhi.modules.timbre.dto.TimbrePageDTO;
+import xiaozhi.modules.timbre.service.TimbreService;
+import xiaozhi.modules.timbre.vo.TimbreDetailsVO;
+
+import java.util.Map;
+
+/**
+ * 音色控制层
+ *
+ * @author zjy
+ * @since 2025-3-21
+ */
+@AllArgsConstructor
+@RestController
+@RequestMapping("/ttsVoice")
+@Tag(name = "音色管理")
+public class TimbreController {
+    private final TimbreService timbreService;
+
+    @GetMapping
+    @Operation(summary = "分页查找")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({
+            @Parameter(name = "ttsModelId", description = "对应 TTS 模型主键", required = true),
+            @Parameter(name = "name", description = "音色名称"),
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<PageData<TimbreDetailsVO>> page(
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        TimbrePageDTO dto = new TimbrePageDTO();
+        dto.setTtsModelId((String) params.get("ttsModelId"));
+        dto.setName((String) params.get("name"));
+        dto.setLimit((String) params.get(Constant.LIMIT));
+        dto.setPage((String) params.get(Constant.PAGE));
+
+        ValidatorUtils.validateEntity(dto);
+        PageData<TimbreDetailsVO> page = timbreService.page(dto);
+        return new Result<PageData<TimbreDetailsVO>>().ok(page);
+    }
+
+    @PostMapping
+    @Operation(summary = "音色保存")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> save(@RequestBody TimbreDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        timbreService.save(dto);
+        return new Result<>();
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "音色修改")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> update(
+            @PathVariable Long id,
+            @RequestBody TimbreDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        timbreService.update(id, dto);
+        return new Result<>();
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "音色删除")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> delete(@PathVariable Long id) {
+        timbreService.delete(new Long[]{id});
+        return new Result<>();
+    }
+
+
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/dao/TimbreDao.java

@@ -0,0 +1,14 @@
+package xiaozhi.modules.timbre.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import xiaozhi.modules.timbre.entity.TimbreEntity;
+
+/**
+ * 音色持久层定义
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Mapper
+public interface TimbreDao extends BaseMapper<TimbreEntity> {
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbreDataDTO.java

@@ -0,0 +1,45 @@
+package xiaozhi.modules.timbre.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+
+/**
+ * 音色表数据DTO
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+@Schema(description = "音色表信息")
+public class TimbreDataDTO {
+
+    @Schema(description = "语言")
+    @NotBlank(message = "{timbre.languages.require}")
+    private String languages;
+
+    @Schema(description = "音色名称")
+    @NotBlank(message = "{timbre.name.require}")
+    private String name;
+
+    @Schema(description = "备注")
+    @NotBlank(message = "{timbre.remark.require}")
+    private String remark;
+
+    @Schema(description = "排序")
+    @Min(value = 0, message = "{sort.number}")
+    private long sort;
+
+    @Schema(description = "对应 TTS 模型主键")
+    @NotBlank(message = "{timbre.ttsModelId.require}")
+    private String ttsModelId;
+
+    @Schema(description = "音色编码")
+    @NotBlank(message = "{timbre.ttsVoice.require}")
+    private String ttsVoice;
+
+    @Schema(description = "音频播放地址")
+    @NotBlank(message = "{timbre.voiceDemo.require}")
+    private String voiceDemo;
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/dto/TimbrePageDTO.java

@@ -0,0 +1,28 @@
+package xiaozhi.modules.timbre.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+/**
+ * 音色分页参数DTO
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+@Schema(description = "音色分页参数")
+public class TimbrePageDTO {
+
+    @Schema(description = "对应 TTS 模型主键")
+    @NotBlank(message = "{timbre.ttsModelId.require}")
+    private String ttsModelId;
+
+    @Schema(description = "音色名称")
+    private String name;
+
+    @Schema(description = "页数")
+    private String page;
+
+    @Schema(description = "显示列数")
+    private String limit;
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/entity/TimbreEntity.java

@@ -0,0 +1,48 @@
+package xiaozhi.modules.timbre.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import xiaozhi.common.entity.BaseEntity;
+
+import java.util.Date;
+
+/**
+ * 音色表实体类
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("ai_tts_voice")
+@Schema(description = "音色信息")
+public class TimbreEntity extends BaseEntity {
+
+    @Schema(description = "语言")
+    private String languages;
+
+    @Schema(description = "音色名称")
+    private String name;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private long sort;
+
+    @Schema(description = "对应 TTS 模型主键")
+    private String ttsModelId;
+
+    @Schema(description = "音色编码")
+    private String ttsVoice;
+
+    @Schema(description = "音频播放地址")
+    private String voiceDemo;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updateDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/service/TimbreService.java

@@ -0,0 +1,53 @@
+package xiaozhi.modules.timbre.service;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.timbre.dto.TimbreDataDTO;
+import xiaozhi.modules.timbre.dto.TimbrePageDTO;
+import xiaozhi.modules.timbre.entity.TimbreEntity;
+import xiaozhi.modules.timbre.vo.TimbreDetailsVO;
+
+import java.util.List;
+
+
+/**
+ * 音色的业务层的定义
+ * @author zjy
+ * @since 2025-3-21
+ */
+public interface TimbreService extends BaseService<TimbreEntity> {
+    /**
+     * 分页获取音色指定tts的下的音色
+     * @param dto 分页查找参数
+     * @return 音色列表分页数据
+     */
+    PageData<TimbreDetailsVO> page(TimbrePageDTO dto);
+
+    /**
+     * 获取音色指定id的详情信息
+     * @param timbreId 音色表id
+     * @return 音色信息
+     */
+    TimbreDetailsVO get(Long timbreId);
+
+    /**
+     * 保存音色信息
+     * @param dto 需要保存数据
+     */
+    void save(TimbreDataDTO dto);
+
+    /**
+     * 保存音色信息
+     * @param timbreId 需要修改的id
+     * @param dto 需要修改的数据
+     */
+    void update(Long timbreId,TimbreDataDTO dto);
+
+    /**
+     * 批量删除音色
+     * @param ids 需要被删除的音色id列表
+     */
+    void delete(Long[] ids);
+
+    List<String> getVoiceNames(String ttsModelId, String voiceName);
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/service/impl/TimbreServiceImpl.java

@@ -0,0 +1,105 @@
+package xiaozhi.modules.timbre.service.impl;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.AllArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.timbre.dao.TimbreDao;
+import xiaozhi.modules.timbre.dto.TimbreDataDTO;
+import xiaozhi.modules.timbre.dto.TimbrePageDTO;
+import xiaozhi.modules.timbre.entity.TimbreEntity;
+import xiaozhi.modules.timbre.service.TimbreService;
+import xiaozhi.modules.timbre.vo.TimbreDetailsVO;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 音色的业务层的实现
+ * @author zjy
+ * @since 2025-3-21
+ */
+@AllArgsConstructor
+@Service
+public class TimbreServiceImpl extends BaseServiceImpl<TimbreDao, TimbreEntity> implements TimbreService {
+
+    private final TimbreDao timbreDao;
+
+    @Override
+    public PageData<TimbreDetailsVO> page(TimbrePageDTO dto) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put(Constant.PAGE, dto.getPage());
+        params.put(Constant.LIMIT,dto.getLimit());
+        IPage<TimbreEntity> page = baseDao.selectPage(
+                getPage(params, "sort", true),
+                //定义查询条件
+                new QueryWrapper<TimbreEntity>()
+                        //必须按照ttsID查找
+                        .eq("tts_model_id",dto.getTtsModelId())
+                        //如果有音色名字，按照音色名模糊查找
+                        .like(StringUtils.isNotBlank(dto.getName()),"name",dto.getName())
+        );
+
+        return getPageData(page, TimbreDetailsVO.class);
+    }
+
+    @Override
+    public TimbreDetailsVO get(Long timbreId) {
+        TimbreEntity entity = baseDao.selectById(timbreId);
+        return ConvertUtils.sourceToTarget(entity, TimbreDetailsVO.class);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void save(TimbreDataDTO dto) {
+        isTtsModelId(dto.getTtsModelId());
+        TimbreEntity timbreEntity = ConvertUtils.sourceToTarget(dto, TimbreEntity.class);
+        baseDao.insert(timbreEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void update(Long timbreId, TimbreDataDTO dto) {
+        isTtsModelId(dto.getTtsModelId());
+        TimbreEntity timbreEntity = ConvertUtils.sourceToTarget(dto, TimbreEntity.class);
+        timbreEntity.setId(timbreId);
+        baseDao.updateById(timbreEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Long[] ids) {
+        baseDao.deleteBatchIds(Arrays.asList(ids));
+    }
+
+    @Override
+    public List<String> getVoiceNames(String ttsModelId, String voiceName) {
+        QueryWrapper<TimbreEntity> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("ttsModelId", StringUtils.isBlank(ttsModelId) ? "" : ttsModelId);
+        if (StringUtils.isNotBlank(voiceName)) {
+            queryWrapper.like("name", voiceName);
+        }
+        List<TimbreEntity> timbreEntities = timbreDao.selectList(queryWrapper);
+        if (CollectionUtil.isEmpty(timbreEntities)) {
+            return null;
+        }
+
+        return timbreEntities.stream().map(TimbreEntity::getName).toList();
+    }
+
+    /**
+     * 处理是不是tts模型的id
+     */
+    private void isTtsModelId(String ttsModelId){
+        //等模型配置那边写好调用方法判断
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/timbre/vo/TimbreDetailsVO.java

@@ -0,0 +1,39 @@
+package xiaozhi.modules.timbre.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 音色详情展示VO
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+public class TimbreDetailsVO implements Serializable {
+    @Schema(description = "音色id")
+    private Long id;
+
+    @Schema(description = "语言")
+    private String languages;
+
+    @Schema(description = "音色名称")
+    private String name;
+
+    @Schema(description = "备注")
+    private String remark;
+
+    @Schema(description = "排序")
+    private long sort;
+
+    @Schema(description = "对应 TTS 模型主键")
+    private String ttsModelId;
+
+    @Schema(description = "音色编码")
+    private String ttsVoice;
+
+    @Schema(description = "音频播放地址")
+    private String voiceDemo;
+
+}