feat(stock):添加板块概念数据查询功能

- 扩展SearchStockByIndicators工具描述，增加更多股票筛选示例
- 新增SearchBk函数用于查询板块/概念/指数整体数据
- 实现SearchBk在OpenAI API中的调用逻辑
- 更新股票数据标题为"工具筛选出的相关股票数据"
- 添加SearchBk API接口实现
- 更新测试用例验证板块查询功能

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,54 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+# Bug 报告
+
+## 基本信息
+### Bug 描述
+<请用简洁明了的语言概括 Bug 的核心问题，例如：“登录页面输入错误密码后无提示信息”>
+
+### 软件版本信息
+<说明你所使用的软件版本，在关于界面中可以找到>
+
+### 运行操作系统和环境
+- **操作系统**：<例如 Windows 10、macOS 12.6、Ubuntu 22.04 等>
+- **浏览器（如果是网页应用）**：<如 Chrome 108、Firefox 107 等，同时说明浏览器的版本和是否使用了特殊的插件>
+- **其他相关环境信息**：<例如运行项目的服务器配置、数据库版本等>
+
+## Bug 描述
+### 预期行为
+<详细描述你认为在正常情况下系统应该呈现的行为。例如：“当用户在登录页面输入错误密码时，页面应弹出提示框显示‘密码错误，请重新输入’”>
+
+### 实际行为
+<准确描述实际发生的情况。可以包括错误信息、页面显示异常、功能无法正常使用等具体表现。例如：“当输入错误密码后，页面没有任何提示，也没有重新聚焦到密码输入框，登录按钮依然可点击”>
+
+### 复现步骤
+<提供详细的步骤，让开发者能够按照这些步骤重现 Bug。步骤要尽量清晰、具体，例如：
+1. 打开项目的登录页面（URL：[具体登录页面 URL]）。
+2. 在用户名输入框输入已注册的用户名。
+3. 在密码输入框输入错误的密码。
+4. 点击登录按钮。>
+
+### 频率
+<说明 Bug 出现的频率，例如“每次都会出现”“偶尔出现（约 10% 的概率）”等>
+
+## 相关信息
+### 错误日志
+<如果有错误日志或控制台输出信息，请提供完整的内容。可以使用代码块来展示，例如：>
+
+
+
+### 截图或视频
+<如果 Bug 涉及页面显示问题或操作流程异常，附上相关的截图或录屏视频会非常有帮助。可以直接上传截图文件，或者提供视频的链接>
+
+### 可能的原因分析（可选）
+<如果你对 Bug 产生的原因有一些初步的猜测或分析，可以在这里简要说明。这有助于开发者更快地定位问题，但不是必需的>
+
+## 补充说明
+<如果有其他与 Bug 相关但不属于上述分类的信息，可以在这里进行补充，例如之前是否进行过特定的配置更改、是否与其他功能存在关联等>

.github/ISSUE_TEMPLATE/custom.md

@@ -0,0 +1,10 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/pull_request_template.md

@@ -0,0 +1,48 @@
+# Pull Request 信息
+
+## 本次 PR 概述
+请简要描述这个 Pull Request 做了什么改动。例如：
+- 修复了某个特定功能的 bug
+- 实现了一个新的功能特性
+- 对代码进行了优化，提升了性能
+
+## 相关问题
+如果这个 PR 是为了解决某个 Issue，请在此处关联对应的 Issue 编号，格式为 `Fixes #<issue-number>`。例如：
+Fixes #123
+
+## 改动内容详细说明
+### 代码修改
+- 列出主要修改的文件和修改点。例如：
+    - `app_linux.go`：
+        - 修改了函数 `GetStockList` 的逻辑，从使用 `for` 循环改为 `sum` 函数，提升了计算效率。
+    - `app_test.go`：
+        - 新增了针对 `GetStockList` 函数的单元测试，确保修改后的逻辑正确。
+
+### 新增功能
+如果有新增功能，请详细描述该功能的使用方法和特点。例如：
+- 新增了一个用户认证模块，支持使用用户名和密码进行登录。使用方法如下：
+    - 调用 `authenticate_user(username, password)` 函数进行认证。
+    - 若认证成功，返回 `True`；否则返回 `False`。
+
+### 删除内容
+如果有删除的代码或文件，请说明删除的原因。例如：
+- 删除了 `app_test.go` 文件，因为该模块的功能已经被新的模块替代，不再需要。
+
+## 测试情况
+### 单元测试
+- 列出运行的单元测试以及测试结果。例如：
+    - 运行了 `app_test.go` 进行单元测试，所有测试用例均通过。
+    - 测试覆盖率达到了 90%。
+
+### 集成测试
+如果进行了集成测试，请描述测试环境和测试结果。例如：
+- 在本地开发环境（Wails CLI v2.10.1 node v18.19.1 ）中进行了集成测试，功能正常。
+- 在 CI/CD 环境中也进行了测试，所有步骤均通过。
+
+## 注意事项
+- 提醒其他开发者在审查代码时需要注意的地方。例如：
+    - 本次修改涉及到数据库表结构的变更，请确保在部署前进行数据库迁移。
+    - 新增的功能依赖于第三方库 `requests`，请确保在环境中安装该库。
+
+## 其他补充说明
+- 可以在这里提供任何其他需要说明的信息，例如设计文档的链接、相关讨论的记录等。

.github/workflows/main.yml

@@ -4,11 +4,14 @@ on:
   push:
     tags:
     # Match any new tag
-      - '*'
+      - '*-release'
+      - '*-dev'
 
 env:
   # Necessary for most environments as build failure can occur due to OOM issues
   NODE_OPTIONS: "--max-old-space-size=4096"
+  OFFICIAL_STATEMENT: ${{ vars.OFFICIAL_STATEMENT }}
+  BUILD_KEY: ${{ vars.BUILD_KEY }}
 
 jobs:
   build:
@@ -17,9 +20,21 @@ jobs:
       fail-fast: false
       matrix:
         build:
-          - name: 'go-stock'
+          - name: 'go-stock-windows-amd64.exe'
             platform:  'windows/amd64'
             os: 'windows-latest'
+#          - name: 'go-stock-linux-amd64'
+#            platform: 'linux/amd64'
+#            os: 'ubuntu-latest'
+          - name: 'go-stock-darwin-universal'
+            platform: 'darwin/universal'
+            os: 'macos-latest'
+          - name: 'go-stock-darwin-intel'
+            platform: 'darwin'
+            os: 'macos-latest'
+          - name: 'go-stock-darwin-arm64'
+            platform: 'darwin/arm64'
+            os: 'macos-latest'
 
     runs-on: ${{ matrix.build.os }}
     steps:
@@ -28,11 +43,22 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Build wails
-        uses: dAppServer/wails-build-action@v2.2
+      - name: Get commit message
+        id: get_commit_message
+        run: |
+          $commit_message = & git log -1 --pretty=format:"%s"
+          echo "::set-output name=commit_message::$commit_message"
+
+      - name: Build wails x go-stock
+        uses: ArvinLovegood/wails-build-action@v3.6
         id: build
         with:
           build-name: ${{ matrix.build.name }}
           build-platform: ${{ matrix.build.platform }}
           package: true
-          go-version: '1.23'
+          go-version: '1.25'
+          build-tags: ${{ github.ref_name }}
+          build-commit-message: ${{ steps.get_commit_message.outputs.commit_message }}
+          build-statement: ${{ env.OFFICIAL_STATEMENT }}
+          build-key: ${{ env.BUILD_KEY }}
+          node-version: '20.x'

.gitignore

@@ -106,7 +106,8 @@ dist
 .DS_Store
 
 .idea/
-data/*.db
-./build/*.exe
-./build/bin/go-stock-dev.exe
-./build/bin/go-stock.exe
+/data/*.db
+/build/*.exe
+/build/bin/*
+frontend/package.json.md5
+/build/us.json

CODE_OF_CONDUCT.md

@@ -0,0 +1,217 @@
+
+# Contributor Covenant 行为准则
+
+## 我们的承诺
+
+我们作为项目的成员、贡献者和领导者，承诺为每一个人营造一个无骚扰的社区参与环境，无论年龄、体型、可见或不可见的残疾状况、种族、身体特征、性别认同与表达、经验水平、教育背景、社会经济地位、国籍、个人外貌、种族、宗教信仰或性取向如何。
+
+我们承诺以有助于建立一个开放、友好、多元、包容和健康的社区的方式行事和互动。
+
+## 我们的准则
+
+有助于为我们的社区营造积极环境的行为示例包括：
+
+- 对他人展现出同理心和善意
+- 尊重不同的意见、观点和经验
+- 给予并欣然接受建设性的反馈
+- 对自己的错误负责，向受影响的人道歉，并从经验中学习
+- 不仅关注个人利益，更着眼于整个社区的利益
+
+不可接受的行为示例包括：
+
+- 使用性暗示的语言或图像，以及任何形式的性关注或挑逗
+- 恶意挑衅、侮辱性或贬低性的评论，以及个人或政治攻击
+- 公开或私下的骚扰行为
+- 在未经明确许可的情况下公布他人的私人信息，如实际地址或电子邮件地址
+- 在专业环境中被合理认为不适当的其他行为
+
+## 执行责任
+
+社区领导者有责任阐明和执行我们可接受行为的标准，并将针对任何他们认为不适当、具有威胁性、冒犯性或有害的行为采取适当和公平的纠正措施。
+
+社区领导者有权且有责任移除、编辑或拒绝不符合本行为准则的评论、提交的代码、代码修改、维基编辑、问题报告和其他贡献，并在适当时说明进行管理决策的原因。
+
+## 适用范围
+
+本行为准则适用于所有社区空间，并且当个人在公共场合正式代表社区时也同样适用。代表我们社区的示例包括使用官方电子邮件地址、通过官方社交媒体账户发布内容，或在线上或线下活动中担任指定代表。
+
+## 执行
+
+若发生滥用、骚扰或其他不可接受的行为，可向负责执行的社区领导者报告，邮箱地址为 [sparkmemory@163.com]。所有投诉都将得到及时、公正的审查和调查。
+
+所有社区领导者都有义务尊重任何事件报告者的隐私和安全。
+
+### 执行指南
+
+社区领导者将遵循以下社区影响指南来确定对任何他们认为违反本行为准则的行为的后果：
+
+#### 1. 纠正
+
+**社区影响**：使用不适当的语言或其他被认为在社区中不专业或不受欢迎的行为。
+
+**后果**：社区领导者发出私下的书面警告，阐明违规行为的性质，并解释为什么该行为不适当。可能会要求公开道歉。
+
+#### 2. 警告
+
+**社区影响**：通过单次事件或一系列行为构成的违规。
+
+**后果**：发出警告并说明持续此类行为的后果。在指定的时间段内，禁止与相关人员进行互动，包括主动与执行本行为准则的人员进行互动。这包括避免在社区空间以及社交媒体等外部渠道进行互动。违反这些规定可能会导致临时或永久禁令。
+
+#### 3. 临时禁令
+
+**社区影响**：严重违反社区标准，包括持续的不当行为。
+
+**后果**：在指定的时间段内，禁止与社区进行任何形式的互动或公开交流。在此期间，禁止与相关人员进行任何公开或私下的互动，包括主动与执行本行为准则的人员进行互动。违反这些规定可能会导致永久禁令。
+
+#### 4. 永久禁令
+
+**社区影响**：表现出违反社区标准的行为模式，包括持续的不当行为、骚扰个人，或对某类人群进行攻击或贬低。
+
+**后果**：永久禁止在社区内进行任何形式的公开互动。
+
+## 版权声明
+
+本行为准则改编自 [Contributor Covenant][主页] 2.1 版本，可在 [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1] 查看。
+
+社区影响指南的灵感来自 [Mozilla 的行为准则执行阶梯][Mozilla CoC]。
+
+有关本行为准则常见问题的解答，请参阅常见问题解答页面 [https://www.contributor-covenant.org/faq][FAQ]。该准则有多种语言的翻译版本，可在 [https://www.contributor-covenant.org/translations][翻译] 查看。
+
+[主页]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[翻译]: https://www.contributor-covenant.org/translations
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at [sparkmemory@163.com].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+### Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+#### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+#### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+#### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+#### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available
+at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
+

CONTRIBUTING.md

@@ -0,0 +1,79 @@
+# Contributing to [go-stock]
+
+感谢你对 [go-stock] 项目的兴趣并愿意贡献代码！本指南将帮助你了解如何为这个项目做出贡献。
+
+## 行为准则
+
+在参与这个项目时，请遵守我们的 [行为准则](./CODE_OF_CONDUCT.md)。我们致力于为所有贡献者提供一个友好、包容和尊重的环境。
+
+## 贡献类型
+
+### 报告问题
+如果你发现了一个 bug、有功能请求或者对项目有任何建议，请在项目的 [GitHub Issues](https://github.com/ArvinLovegood/go-stock/issues) 中创建一个新的 issue。在创建 issue 时，请提供尽可能多的信息，包括：
+- **问题描述**：清晰地描述你遇到的问题或建议的功能。
+- **重现步骤**：如果是 bug，请提供重现该问题的具体步骤。
+- **环境信息**：例如操作系统、编程语言版本等。
+- **相关日志或错误信息**：如果有的话，请附上相关的日志或错误信息。
+
+### 提交代码
+我们欢迎各种类型的代码贡献，包括修复 bug、添加新功能、改进文档等。请按照以下步骤提交你的代码：
+
+#### 1.  Fork 项目
+在 GitHub 上点击项目页面的 “Fork” 按钮，将项目复制到你自己的 GitHub 账户下。
+
+#### 2. 克隆项目到本地
+使用以下命令将你 fork 的项目克隆到本地：
+```bash
+git clone https://github.com/ArvinLovegood/go-stock.git
+cd go-stock
+```
+
+#### 3. 创建新分支
+在开始编写代码之前，创建一个新的分支来包含你的更改。建议使用一个描述性的分支名称，例如 `fix-bug-123` 或 `add-new-feature`。
+```bash
+git checkout -b 新分支名称
+```
+
+#### 4. 编写代码
+在新分支上进行你的代码更改。请确保你的代码遵循项目的编码风格和规范。
+
+#### 5. 测试代码
+在提交代码之前，请确保你的更改通过了项目的测试。如果项目没有测试，请考虑添加适当的测试。
+
+#### 6. 提交更改
+将你的更改提交到本地仓库，并提供一个清晰、简洁的提交信息。
+```bash
+git add.
+git commit -m "描述你的更改，例如：修复了 #123 号 bug"
+```
+
+#### 7. 同步上游仓库
+在推送代码之前，确保你的分支与上游仓库（原始项目）保持同步。
+```bash
+git remote add upstream https://github.com/ArvinLovegood/go-stock.git
+git fetch upstream
+git rebase upstream/main
+```
+
+#### 8. 推送更改
+将你的更改推送到你 fork 的 GitHub 仓库。
+```bash
+git push origin 新分支名称
+```
+
+#### 9. 创建 Pull Request
+在 GitHub 上，导航到你 fork 的项目页面，点击 “New pull request” 按钮。选择你刚刚推送的分支，并提供一个清晰的描述，说明你的更改内容和目的。然后提交 pull request。
+
+### 改进文档
+良好的文档对于项目的成功至关重要。如果你发现文档中有错误、不清楚的地方或者有可以改进的地方，请提交一个 issue 或者直接修改文档并提交 pull request。
+
+## 代码风格和规范
+请遵循项目的代码风格和规范。如果项目中没有明确的规范，请参考以下通用准则：
+- **代码格式**：使用一致的缩进、空格和换行符。
+- **注释**：添加适当的注释来解释代码的功能和逻辑。
+- **命名规范**：使用有意义的变量名、函数名和类名。
+
+## 许可证
+通过贡献代码，你同意你的贡献将根据项目的 [许可证](./LICENSE) 进行分发。
+
+再次感谢你对项目的贡献！如果你有任何问题或需要帮助，请随时在 issue 中提问。

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [2025] [sparkmemory@163.com]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,41 +1,186 @@
-# README
+# go-stock : 基于大语言模型的AI赋能股票分析工具
+## ![go-stock](./build/appicon.png)
+![GitHub Release](https://img.shields.io/github/v/release/ArvinLovegood/go-stock?link=https%3A%2F%2Fgithub.com%2FArvinLovegood%2Fgo-stock%2Freleases&link=https%3A%2F%2Fgithub.com%2FArvinLovegood%2Fgo-stock%2Freleases)
+[![GitHub Repo stars](https://img.shields.io/github/stars/ArvinLovegood/go-stock?link=https%3A%2F%2Fgithub.com%2FArvinLovegood%2Fgo-stock)](https://github.com/ArvinLovegood/go-stock)
+[![star](https://gitee.com/arvinlovegood_admin/go-stock/badge/star.svg?theme=dark)](https://gitee.com/arvinlovegood_admin/go-stock)
 
-![Wails and NaiveUI](./build/appicon.png)
+[//]: # ([![star](https://gitcode.com/ArvinLovegood/go-stock/star/badge.svg)](https://gitcode.com/ArvinLovegood/go-stock))
+
+### 🌟公众号
+![扫码_搜索联合传播样式-白色版.png](build/screenshot/%E6%89%AB%E7%A0%81_%E6%90%9C%E7%B4%A2%E8%81%94%E5%90%88%E4%BC%A0%E6%92%AD%E6%A0%B7%E5%BC%8F-%E7%99%BD%E8%89%B2%E7%89%88.png)
+
+### 📈 交流群
+
+[//]: # (- QQ交流群2：[点击链接加入群聊【go-stock交流群2】：892666282](https://qm.qq.com/q/5mYiy6Yxh0))
+- QQ交流群：[点击链接加入群聊【go-stock交流群】：491605333(定期清理，随缘入群)](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=0YQ8qD3exahsD4YLNhzQTWe5ssstWC89&authKey=usOMMRFtIQDC%2FYcatHYapcxQbJ7PwXPHK9OypTXWzNjAq%2FRVvQu9bj2lRgb%2BSZ3p&noverify=0&group_code=491605333)
+
+###  ✨ 简介
+- 本项目基于Wails和NaiveUI开发，结合AI大模型构建的股票分析工具。
+- 目前已支持A股，港股，美股，未来计划加入基金，ETF等支持。
+- 支持市场整体/个股情绪分析，K线技术指标分析等功能。
+- 本项目仅供娱乐，不喜勿喷，AI分析股票结果仅供学习研究，投资有风险，请谨慎使用。
+- 开发环境主要基于Windows10+，其他平台未测试或功能受限。
+
+### 📦 立即体验
+[//]: # (- 安装版：[go-stock-amd64-installer.exe](https://github.com/ArvinLovegood/go-stock/releases))
+- 绿色版：[go-stock-windows-amd64.exe](https://github.com/ArvinLovegood/go-stock/releases)
+- MACOS绿色版：[go-stock-darwin-universal](https://github.com/ArvinLovegood/go-stock/releases)
+
+[//]: # (- MACOS安装版：[go-stock-darwin-universal.pkg](https://github.com/ArvinLovegood/go-stock/releases))
 
 
-## Snapshot
-![img_1.png](build/screenshot/img_1.png)
-### 成本仓位设置
-![img.png](build/screenshot/img.png)
+### 💬 支持大模型/平台
+| 模型 | 状态 | 备注                                                                                                                                                                                                                                                                |
+| --- | --- |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [OpenAI](https://platform.openai.com/) | ✅ | 可接入任何 OpenAI 接口格式模型                                                                                                                                                                                                                                               |
+| [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台                                                                                                                                                                                                                                                         |
+| [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台                                                                                                                                                                                                                                                         |
+| [AnythingLLM](https://anythingllm.com/) | ✅ | 本地知识库                                                                                                                                                                                                                                                             |
+| [DeepSeek](https://www.deepseek.com/) | ✅ | deepseek-reasoner,deepseek-chat                                                                                                                                                                                                                                   |
+| [大模型聚合平台](https://cloud.siliconflow.cn/i/foufCerk) | ✅ | 如：[硅基流动](https://cloud.siliconflow.cn/i/foufCerk)，[火山方舟](https://www.volcengine.com/experience/ark?utm_term=202502dsinvite&ac=DSASUQY5&rc=IJSE43PZ) |
+
+### <span style="color: #568DF4;">各位亲爱的朋友们，如果您对这个项目感兴趣，请先给我一个<i style="color: #EA2626;">star</i>吧，谢谢！</span>💕
+[//]: # (- 优云智算（by UCloud）：万卡规模4090免费用10小时，新人注册另增50万tokens，海量热门源项目镜像一键部署，[注册链接]&#40;https://www.compshare.cn/image-community?ytag=GPU_YY-gh_gostock&#41;)
+- 火山方舟：新用户每个模型注册即送50万tokens，[注册链接](https://www.volcengine.com/experience/ark?utm_term=202502dsinvite&ac=DSASUQY5&rc=IJSE43PZ)
+- 硅基流动(siliconflow)，注册即送2000万Tokens，[注册链接](https://cloud.siliconflow.cn/i/foufCerk)
+- Tushare大数据开放社区,免费提供各类金融数据,助力行业和量化研究(注意：Tushare只需要120积分即可，注册完成个人资料补充即可得120积分！！！)，[注册链接](https://tushare.pro/register?reg=701944)
+- 软件快速迭代开发中,请大家优先测试和使用最新发布的版本。
+- 欢迎大家提出宝贵的建议，欢迎提issue,PR。当然更欢迎[赞助我](#都划到这了如果我的项目对您有帮助请赞助我吧)。💕
+
+
+### 支持开源💕计划
+| 赞助计划	                           | 赞助等级	          | 权益说明                                                   |
+|:--------------------------------|----------------|:-------------------------------------------------------|
+| 每月 0 RMB	                       | vip0	          | 🌟 全部功能,软件自动更新(从GitHub下载),自行解决github平台网络问题。            |
+| 每月赞助 18.8 RMB<br>每年赞助 120 RMB		 | vip1	          | 💕 全部功能,软件自动更新(从CDN下载),更新快速便捷。AI配置指导，提示词参考等            |
+| 每月赞助 28.8 RMB<br>每年赞助 240 RMB		 | vip2	          | 💕 💕 vip1全部功能,启动时自动同步最近24小时市场资讯(包括外媒简讯)               |
+| 每月赞助 X RMB			                   | vipX	          | 🧩 更多计划，视go-stock开源项目发展情况而定...(承接GitHub项目README广告推广💖) |
+
+## 🧩 重大功能开发计划
+| 功能说明            | 状态 | 备注                                                                                                       |
+|-----------------|----|----------------------------------------------------------------------------------------------------------|
+| 股票分析知识库         | 🚧 | 未来计划                                                                                                     |
+| Ai智能选股          | ✅ | Ai智能选股功能(市场行情-》AI总结/AI智能体功能)                                                                             |
+| ETF支持           | 🚧 | ETF数据支持 (目前可以查看净值和估值)                                                                                    |
+| 美股支持            | ✅  | 美股数据支持                                                                                                   |
+| 港股支持            | ✅  | 港股数据支持                                                                                                   |
+| 多轮对话            | ✅  | AI分析后可继续对话提问                                                                                             |
+| 自定义AI分析提问模板     | ✅  | 可配置的提问模板 [v2025.2.12.7-alpha](https://github.com/ArvinLovegood/go-stock/releases/tag/v2025.2.12.7-alpha) |
+| 不再强制依赖Chrome浏览器 | ✅  | 默认使用edge浏览器抓取新闻资讯                                                                                        |
+
+## 👀 更新日志
+### 2025.12.16 新增AI思考模式与热门选股策略功能
+### 2025.11.21 新增带频率权重的情感分析功能
+### 2025.10.30 添加AI智能体功能开关(默认关闭，因为使用体验不理想)，移除页面水印
+### 2025.09.27 添加机构/券商的研究报告AI工具函数
+### 2025.08.09 添加AI智能体聊天功能
+### 2025.07.08 实现软件自动更新功能
+### 2025.07.07 卡片添加迷你分时图
+### 2025.07.05 MacOs支持
+### 2025.07.01 AI分析集成工具函数，AI分析将更加智能
+### 2025.06.30 添加指标选股功能
+### 2025.06.27 添加财经日历和重大事件时间轴功能
+### 2025.06.25 添加热门股票、事件和话题功能
+### 2025.06.18 更新内置股票基础数据,软件内实时市场资讯信息提醒，添加行业研究功能
+### 2025.06.15 添加公司公告信息搜索/查看功能
+### 2025.06.15 添加个股研报到弹出菜单
+### 2025.06.13 添加个股研报功能
+### 2025.06.12 添加龙虎榜功能，新增行业排名分类
+### 2025.05.30 优化股票分时图显示
+### 2025.05.20 修复财联社电报获取问题
+### 2025.05.16 优化资金趋势图表组件
+### 2025.05.15 重构应用加载和数据初始化逻辑，添加股票资金趋势功能，资金趋势图表增加主力当日净流入数据并优化展示效果
+### 2025.05.14 添加个股资金流向功能，排行榜增加股票行情K线图弹窗
+### 2025.05.13 添加行业排名功能
+### 2025.05.09 添加A股盘口数据解析和展示功能
+### 2025.05.07 优化分时图的展示
+### 2025.04.29 补全港股/美股基础数据，优化港股股价延迟问题，优化初始化逻辑
+### 2025.04.25 市场资讯支持AI分析和总结：让AI帮你读市场！
+### 2025.04.24 新增市场行情模块：即时掌握全球市场行情资讯/动态，从此再也不用偷摸去各大财经网站啦。go-stock一键帮你搞定！
+### 2025.04.22 优化K线图展示，支持拉伸放大，看得更舒服啦！
+### 2025.04.21 港股，美股K线数据获取优化
+### 2025.04.01 优化部分设置选项，避免重启软件
+### 2025.03.31 优化数据爬取
+### 2025.03.30 AI自动定时分析功能
+### 2025.03.29 多提示词模板管理，AI分析时支持选择不同提示词模板
+### 2025.03.28 AI分析结果保存为markdown文件时，支持保存位置目录选择
+### 2025.03.15 自定义爬虫使用的浏览器路径配置
+### 2025.03.14 优化编译构建，大幅减少编译后的程序文件大小
+### 2025.03.09 基金估值和净值监控查看
+### 2025.03.06 项目社区分享功能
+### 2025.02.28 美股数据支持
+### 2025.02.23 弹幕功能，盯盘不再孤单，无聊划个水！😎
+### 2025.02.22 港股数据支持(目前有延迟)
+
+### 2025.02.16 AI分析后可继续对话提问
+- [v2025.2.16.1-alpha](https://github.com/ArvinLovegood/go-stock/releases/tag/v2025.2.16.1-alpha)
+
+### 2025.02.12 可配置的提问模板
+- [v2025.2.12.7-alpha](https://github.com/ArvinLovegood/go-stock/releases/tag/v2025.2.12.7-alpha)
+
+
+## 🦄 重大更新
+### BIG NEWS !!! 重大更新！！！
+- 2025.11.21 新增带频率权重的情感分析功能
+![img_1.png](build/screenshot/img15.png)
+- 2025.04.25 市场资讯支持AI分析和总结：让AI帮你读市场！
+![img.png](img.png)
+- 2025.04.24 新增市场行情模块：即时掌握全球市场行情资讯/动态，从此再也不用偷摸去各大财经网站啦。go-stock一键帮你搞定！
+![img.png](build/screenshot/img13.png)
+![img_13.png](build/screenshot/img_13.png)
+- ![img_14.png](build/screenshot/img_14.png)
+- 2025.01.17 新增AI大模型分析股票功能
+  ![img_5.png](build/screenshot/img.png)
+## 📸 功能截图
+![img_1.png](build/screenshot/img_6.png)
+### 设置
+![img_12.png](build/screenshot/img_4.png)
+### 成本设置
+![img.png](build/screenshot/img_7.png)
 ### 日K
-![img_2.png](build/screenshot/img_2.png)
+![img_12.png](build/screenshot/img_12.png)
 ### 分时
-![img_3.png](build/screenshot/img_3.png)
+![img_3.png](build/screenshot/img_9.png)
+### 钉钉报警通知
+![img_4.png](build/screenshot/img_5.png)
+### AI分析股票
+![img_5.png](build/screenshot/img.png)
+### 版本信息提示
+![img_11.png](build/screenshot/img_11.png)
+
+## 💕 感谢以下项目
+- [NaiveUI](https://www.naiveui.com/)
+- [Wails](https://wails.io/)
+- [Vue](https://vuejs.org/)
+- [Vite](https://vitejs.dev/)
+- [Tushare](https://tushare.pro/register?reg=701944)
+
+## 😘 赞助我
+### 都划到这了，如果我的项目对您有帮助，请赞助我吧！😊😊😊
+| 支付宝 | 微信  |
+|-----|-----| 
+| ![alipay.jpg](build/screenshot/alipay.jpg)  | ![wxpay.jpg](build/screenshot/wxpay.jpg) |
 
 
-## About
+## ⭐ Star History
+[![Star History Chart](https://api.star-history.com/svg?repos=ArvinLovegood/go-stock&type=Date)](https://star-history.com/#ArvinLovegood/go-stock&Date)
+## 🤖 状态
+![Alt](https://repobeats.axiom.co/api/embed/40b07d415a42c2264a18c4fe1b6f182ff1470687.svg "Repobeats analytics image")
 
-A China stock data viewer build by  [Wails](https://wails.io/) with [NavieUI](https://www.naiveui.com/).
-A股数据可视化工具，基于Wails和NaiveUI。
+## 🐳 关于技术支持申明
+- 本软件基于开源技术构建，使用Wails、NaiveUI、Vue、AI大模型等开源项目。 技术上如有问题，可以先向对应的开源社区请求帮助。
+- 开源不易，本人精力和时间有限，如需一对一技术支持，请先赞助。联系QQ(备注 技术支持)：506808970
 
-## Prerequisites
-INSTALL [GO](https://golang.org) AND [Wails](https://wails.io/)
+[//]: # (<img src="./build/wx.jpg" width="301px" height="402px" alt="ArvinLovegood">)
 
-## Running the Application in Developer Mode
-The easiest way is to use the Wails CLI: `wails dev`
 
-This should hot refresh when making changes the Frontend and rebuild when making changes in the Go.
+| 技术支持方式                          | 赞助(元) | 
+|:--------------------------------|:-----:|
+| 加 QQ：506808970                  | 100/次 |
+| 长期技术支持（不限次数，新功能优先体验等）           | 5000  |                  
 
-## Building the Application for Production
- 
-You can build you Application with: `wails build`
 
 
 ## License
 [Apache License 2.0](LICENSE)
 
-## Credits
-[NaiveUI](https://www.naiveui.com/)
-[Wails](https://wails.io/)
-[Vue](https://vuejs.org/)
-[Vite](https://vitejs.dev/)

SECURITY.md

@@ -0,0 +1,56 @@
+# 安全策略
+
+## 1. 受支持的版本
+
+以下是 [go-stock] 项目当前接受安全更新支持的版本：
+
+| 版本号 | 是否支持 |
+| ------- | ------------------ |
+| [v年.月.日.版本号] | :white_check_mark: |
+| [v较旧的年.月.日.版本号] | :x: |
+
+请注意，通常只有最新的主要或次要版本会积极维护安全更新，较旧版本可能不会收到安全补丁。
+
+## 2. 报告安全漏洞
+
+### 2.1 报告方式
+我们非常重视安全漏洞问题。如果您在我们的项目中发现了安全漏洞，请通过以下方式向我们报告：
+
+- **私下披露**：请发送电子邮件至 [sparkmemory@163.com]。在邮件中，请包含以下详细信息：
+    - 对漏洞的详细描述，包括如何复现该漏洞。
+    - 受影响的项目版本。
+    - 该漏洞可能造成的任何影响或风险。
+    - 如果可能，请提供建议的修复或缓解策略。
+
+### 2.2 响应时间线
+- **首次确认**：我们将在收到报告后的 [7] 个工作日内确认收到您的报告。
+- **调查与进度更新**：我们将对报告的漏洞进行全面调查，并在 [7] 个工作日内向您提供调查进度更新。
+- **补丁发布**：一旦修复方案开发完成，我们将尽快发布补丁。发布补丁的时间可能会因漏洞的复杂程度而有所不同。
+
+### 2.3 保密承诺
+我们深知安全漏洞报告保密的重要性。我们将对所有报告内容严格保密，未经您的许可，不会披露您的身份或漏洞的具体细节，除非法律有相关要求。
+
+## 3. 安全更新与沟通
+
+### 3.1 补丁发布
+当发现并修复安全漏洞后，我们会为受支持的项目版本发布补丁。补丁将在项目的官方 GitHub 仓库上提供。
+
+### 3.2 安全公告
+我们会在项目的 GitHub 安全公告页面发布安全公告。这些公告将详细说明漏洞情况、受影响的版本以及缓解或修复问题的步骤。
+
+### 3.3 沟通渠道
+- **GitHub**：所有关于安全更新和公告的官方通知将发布在项目的 GitHub 仓库上。
+- **电子邮件**：如果您订阅了项目的安全通知，您将收到有关重要安全更新的电子邮件通知。
+
+## 4. 第三方依赖
+我们会定期审查和更新项目中使用的第三方依赖，以确保其安全性。然而，第三方组件的安全性也依赖于其各自的维护者。如果您发现与第三方依赖相关的安全问题，请同时向相应的维护者报告并告知我们。
+
+## 5. 安全最佳实践
+我们鼓励项目的所有贡献者和用户遵循以下安全最佳实践：
+- 及时更新开发和生产环境，安装最新的安全补丁。
+- 使用强大的身份验证和授权机制。
+- 避免在代码中硬编码凭证信息。
+- 定期审查代码，排查潜在的安全漏洞。
+
+## 6. 联系信息
+如果您对 [go-stock] 项目的安全策略有任何疑问或担忧，请通过 [sparkmemory@163.com] 联系我们。 

app_common.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"go-stock/backend/agent"
+	"go-stock/backend/data"
+	"go-stock/backend/models"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// @Author spark
+// @Date 2025/6/8 20:45
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func (a *App) LongTigerRank(date string) *[]models.LongTigerRankData {
+	return data.NewMarketNewsApi().LongTiger(date)
+}
+
+func (a *App) StockResearchReport(stockCode string) []any {
+	return data.NewMarketNewsApi().StockResearchReport(stockCode, 7)
+}
+func (a *App) StockNotice(stockCode string) []any {
+	return data.NewMarketNewsApi().StockNotice(stockCode)
+}
+
+func (a *App) IndustryResearchReport(industryCode string) []any {
+	return data.NewMarketNewsApi().IndustryResearchReport(industryCode, 7)
+}
+func (a *App) EMDictCode(code string) []any {
+	return data.NewMarketNewsApi().EMDictCode(code, a.cache)
+}
+
+func (a *App) AnalyzeSentiment(text string) models.SentimentResult {
+	return data.AnalyzeSentiment(text)
+}
+
+func (a *App) HotStock(marketType string) *[]models.HotItem {
+	return data.NewMarketNewsApi().XUEQIUHotStock(100, marketType)
+}
+
+func (a *App) HotEvent(size int) *[]models.HotEvent {
+	if size <= 0 {
+		size = 10
+	}
+	return data.NewMarketNewsApi().HotEvent(size)
+}
+func (a *App) HotTopic(size int) []any {
+	if size <= 0 {
+		size = 10
+	}
+	return data.NewMarketNewsApi().HotTopic(size)
+}
+
+func (a *App) InvestCalendarTimeLine(yearMonth string) []any {
+	return data.NewMarketNewsApi().InvestCalendar(yearMonth)
+}
+func (a *App) ClsCalendar() []any {
+	return data.NewMarketNewsApi().ClsCalendar()
+}
+
+func (a *App) SearchStock(words string) map[string]any {
+	return data.NewSearchStockApi(words).SearchStock(5000)
+}
+func (a *App) GetHotStrategy() map[string]any {
+	return data.NewSearchStockApi("").HotStrategy()
+}
+
+func (a *App) ChatWithAgent(question string, aiConfigId int, sysPromptId *int) {
+	ch := agent.NewStockAiAgentApi().Chat(question, aiConfigId, sysPromptId)
+	for msg := range ch {
+		runtime.EventsEmit(a.ctx, "agent-message", msg)
+	}
+}
+
+func (a *App) AnalyzeSentimentWithFreqWeight(text string) map[string]any {
+	result, cleanFrequencies := data.NewsAnalyze(text, false)
+	return map[string]any{
+		"result":      result,
+		"frequencies": cleanFrequencies,
+	}
+}
+
+func (a *App) GetAIResponseResultList(query models.AIResponseResultQuery) *models.AIResponseResultPageData {
+	page, err := data.NewAIResponseResultService().GetAIResponseResultList(query)
+	if err != nil {
+		return &models.AIResponseResultPageData{}
+	}
+	return page
+}
+func (a *App) DeleteAIResponseResult(id string) string {
+	err := data.NewAIResponseResultService().DeleteAIResponseResult(id)
+	if err != nil {
+		return "删除失败"
+	}
+	return "删除成功"
+}
+func (a *App) BatchDeleteAIResponseResult(ids []uint) string {
+	err := data.NewAIResponseResultService().BatchDeleteAIResponseResult(ids)
+	if err != nil {
+		return "删除失败"
+	}
+	return "删除成功"
+}
+
+func (a *App) GetAiRecommendStocksList(query models.AiRecommendStocksQuery) *models.AiRecommendStocksPageData {
+	page, err := data.NewAiRecommendStocksService().GetAiRecommendStocksList(&query)
+	if err != nil {
+		return &models.AiRecommendStocksPageData{}
+	}
+	return page
+}

app_darwin.go

@@ -0,0 +1,202 @@
+//go:build darwin
+// +build darwin
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/gen2brain/beeep"
+	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+	"go-stock/backend/data"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"log"
+	"time"
+)
+
+// startup 在应用程序启动时调用
+func (a *App) startup(ctx context.Context) {
+	defer PanicHandler()
+	runtime.EventsOn(ctx, "frontendError", func(optionalData ...interface{}) {
+		logger.SugaredLogger.Errorf("Frontend error: %v\n", optionalData)
+	})
+	logger.SugaredLogger.Infof("Version:%s", Version)
+	// Perform your setup here
+	a.ctx = ctx
+
+	// 监听设置更新事件
+	runtime.EventsOn(ctx, "updateSettings", func(optionalData ...interface{}) {
+		config := data.GetSettingConfig()
+		//setMap := optionalData[0].(map[string]interface{})
+		//
+		//// 将 map 转换为 JSON 字节切片
+		//jsonData, err := json.Marshal(setMap)
+		//if err != nil {
+		//	logger.SugaredLogger.Errorf("Marshal error:%s", err.Error())
+		//	return
+		//}
+		//// 将 JSON 字节切片解析到结构体中
+		//err = json.Unmarshal(jsonData, config)
+		//if err != nil {
+		//	logger.SugaredLogger.Errorf("Unmarshal error:%s", err.Error())
+		//	return
+		//}
+
+		logger.SugaredLogger.Infof("updateSettings config:%+v", config)
+		if config.DarkTheme {
+			runtime.WindowSetBackgroundColour(ctx, 27, 38, 54, 1)
+			runtime.WindowSetDarkTheme(ctx)
+		} else {
+			runtime.WindowSetBackgroundColour(ctx, 255, 255, 255, 1)
+			runtime.WindowSetLightTheme(ctx)
+		}
+		runtime.WindowReloadApp(ctx)
+	})
+
+	// 创建 macOS 托盘
+	go func() {
+		// 使用 Beeep 库替代 Windows 的托盘库
+		err := beeep.Notify("go-stock", "应用程序已启动", "")
+		if err != nil {
+			log.Fatalf("系统通知失败: %v", err)
+		}
+	}()
+	go setUpScreen(a)
+	logger.SugaredLogger.Infof(" application startup Version:%s", Version)
+}
+
+func setUpScreen(a *App) {
+	screens, _ := runtime.ScreenGetAll(a.ctx)
+	if len(screens) == 0 {
+		return
+	}
+	screen := screens[0]
+	sw, sh := screen.Width, screen.Height
+
+	// macOS 菜单栏 + Dock 留出空间
+	topBarHeight := 22
+	dockHeight := 56
+	verticalMargin := topBarHeight + dockHeight
+
+	// 设置窗口为屏幕 80% 宽 × 可用高度 90%
+	w := int(float64(sw) * 0.8)
+	h := int(float64(sh-verticalMargin) * 0.9)
+
+	runtime.WindowSetSize(a.ctx, w, h)
+	runtime.WindowCenter(a.ctx)
+}
+
+// OnSecondInstanceLaunch 处理第二实例启动时的通知
+func OnSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	err := beeep.Notify("go-stock", "程序已经在运行了", "")
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+	}
+	time.Sleep(time.Second * 3)
+}
+
+func MonitorStockPrices(a *App) {
+	dest := &[]data.FollowedStock{}
+	db.Dao.Model(&data.FollowedStock{}).Find(dest)
+	total := float64(0)
+
+	// 股票信息处理逻辑
+	stockInfos := GetStockInfos(*dest...)
+	for _, stockInfo := range *stockInfos {
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"SZ", "SH", "sh", "sz"}) && (!isTradingTime(time.Now())) {
+			continue
+		}
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"hk", "HK"}) && (!IsHKTradingTime(time.Now())) {
+			continue
+		}
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"us", "US", "gb_"}) && (!IsUSTradingTime(time.Now())) {
+			continue
+		}
+
+		total += stockInfo.ProfitAmountToday
+		price, _ := convertor.ToFloat(stockInfo.Price)
+
+		if stockInfo.PrePrice != price {
+			go runtime.EventsEmit(a.ctx, "stock_price", stockInfo)
+		}
+	}
+
+	// 计算总收益并更新状态
+	if total != 0 {
+		// 使用通知替代 systray 更新 Tooltip
+		title := "go-stock " + time.Now().Format(time.DateTime) + fmt.Sprintf("  %.2f¥", total)
+
+		// 发送通知显示实时数据
+		err := beeep.Notify("go-stock", title, "")
+		if err != nil {
+			logger.SugaredLogger.Errorf("发送通知失败: %v", err)
+		}
+	}
+
+	// 触发实时利润事件
+	go runtime.EventsEmit(a.ctx, "realtime_profit", fmt.Sprintf("  %.2f", total))
+}
+
+// onReady 在应用程序准备好时调用
+func onReady(a *App) {
+	// 初始化操作
+	logger.SugaredLogger.Infof("onReady")
+
+	// 使用 Beeep 发送通知
+	err := beeep.Notify("go-stock", "应用程序已准备就绪", "")
+	if err != nil {
+		log.Fatalf("系统通知失败: %v", err)
+	}
+
+	// 显示应用窗口
+	runtime.WindowShow(a.ctx)
+
+	// 在 macOS 上没有系统托盘图标菜单，通常我们通过通知或其他方式提供与用户交互的界面
+}
+
+// beforeClose 在应用程序关闭前调用，显示确认对话框
+func (a *App) beforeClose(ctx context.Context) (prevent bool) {
+	defer PanicHandler()
+
+	// 在 macOS 上使用 MessageDialog 显示确认窗口
+	dialog, err := runtime.MessageDialog(ctx, runtime.MessageDialogOptions{
+		Type:         runtime.QuestionDialog,
+		Title:        "go-stock",
+		Message:      "确定关闭吗？",
+		Buttons:      []string{"确定", "取消"},
+		Icon:         icon,
+		CancelButton: "取消",
+	})
+
+	if err != nil {
+		logger.SugaredLogger.Errorf("dialog error:%s", err.Error())
+		return false
+	}
+
+	logger.SugaredLogger.Debugf("dialog:%s", dialog)
+	if dialog == "取消" {
+		return true // 如果选择了取消，不关闭应用
+	} else {
+		// 在 macOS 上应用退出时执行清理工作
+		a.cron.Stop() // 停止定时任务
+		return false  // 如果选择了确定，继续关闭应用
+	}
+}
+
+func getFrameless() bool {
+	return false
+}
+
+func getScreenResolution() (int, int, int, int, error) {
+	//user32 := syscall.NewLazyDLL("user32.dll")
+	//getSystemMetrics := user32.NewProc("GetSystemMetrics")
+	//
+	//width, _, _ := getSystemMetrics.Call(0)
+	//height, _, _ := getSystemMetrics.Call(1)
+
+	return int(1200), int(800), 0, 0, nil
+}

app_linux.go

@@ -0,0 +1,193 @@
+//go:build linux
+// +build linux
+
+package main
+
+import (
+	"context"
+	"github.com/coocood/freecache"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+	"go-stock/backend/data"
+	"go-stock/backend/logger"
+)
+
+// App struct
+type App struct {
+	ctx   context.Context
+	cache *freecache.Cache
+}
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	cacheSize := 512 * 1024
+	cache := freecache.NewCache(cacheSize)
+	return &App{
+		cache: cache,
+	}
+}
+
+// startup is called at application startup
+func (a *App) startup(ctx context.Context) {
+	// Perform your setup here
+	a.ctx = ctx
+
+}
+
+// domReady is called after front-end resources have been loaded
+func (a *App) domReady(ctx context.Context) {
+	// Add your action here
+	//ticker := time.NewTicker(time.Second)
+	//defer ticker.Stop()
+	////定时更新数据
+	//go func() {
+	//	for range ticker.C {
+	//		runtime.WindowSetTitle(ctx, "go-stock "+time.Now().Format("2006-01-02 15:04:05"))
+	//	}
+	//}()
+}
+
+// beforeClose is called when the application is about to quit,
+// either by clicking the window close button or calling runtime.Quit.
+// Returning true will cause the application to continue, false will continue shutdown as normal.
+func (a *App) beforeClose(ctx context.Context) (prevent bool) {
+
+	dialog, err := runtime.MessageDialog(ctx, runtime.MessageDialogOptions{
+		Type:         runtime.QuestionDialog,
+		Title:        "go-stock",
+		Message:      "确定关闭吗？",
+		Buttons:      []string{"确定"},
+		Icon:         icon,
+		CancelButton: "取消",
+	})
+
+	if err != nil {
+		return false
+	}
+	logger.SugaredLogger.Debugf("dialog:%s", dialog)
+	if dialog == "No" {
+		return true
+	}
+	return false
+}
+
+// shutdown is called at application termination
+func (a *App) shutdown(ctx context.Context) {
+	// Perform your teardown here
+}
+
+// Greet returns a greeting for the given name
+func (a *App) Greet(name string) *data.StockInfo {
+	stockDatas, _ := data.NewStockDataApi().GetStockCodeRealTimeData(name)
+	stockData := (*stockDatas)[0]
+	return &stockData
+}
+
+func (a *App) Follow(stockCode string) string {
+	return data.NewStockDataApi().Follow(stockCode)
+}
+
+func (a *App) UnFollow(stockCode string) string {
+	return data.NewStockDataApi().UnFollow(stockCode)
+}
+
+func (a *App) GetFollowList() []data.FollowedStock {
+	return data.NewStockDataApi().GetFollowList()
+}
+
+func (a *App) GetStockList(key string) []data.StockBasic {
+	return data.NewStockDataApi().GetStockList(key)
+}
+
+func (a *App) SetCostPriceAndVolume(stockCode string, price float64, volume int64) string {
+	return data.NewStockDataApi().SetCostPriceAndVolume(price, volume, stockCode)
+}
+
+func (a *App) SetAlarmChangePercent(val, alarmPrice float64, stockCode string) string {
+	return data.NewStockDataApi().SetAlarmChangePercent(val, alarmPrice, stockCode)
+}
+
+func (a *App) SendDingDingMessage(message string, stockCode string) string {
+	ttl, _ := a.cache.TTL([]byte(stockCode))
+	logger.SugaredLogger.Infof("stockCode %s ttl:%d", stockCode, ttl)
+	if ttl > 0 {
+		return ""
+	}
+	err := a.cache.Set([]byte(stockCode), []byte("1"), 60*5)
+	if err != nil {
+		logger.SugaredLogger.Errorf("set cache error:%s", err.Error())
+		return ""
+	}
+	return data.NewDingDingAPI().SendDingDingMessage(message)
+}
+
+func (a *App) SetStockSort(sort int64, stockCode string) {
+	data.NewStockDataApi().SetStockSort(sort, stockCode)
+}
+
+// SendDingDingMessageByType msgType 报警类型: 1 涨跌报警;2 股价报警 3 成本价报警
+func (a *App) SendDingDingMessageByType(message string, stockCode string, msgType int) string {
+	ttl, _ := a.cache.TTL([]byte(stockCode))
+	logger.SugaredLogger.Infof("stockCode %s ttl:%d", stockCode, ttl)
+	if ttl > 0 {
+		return ""
+	}
+	err := a.cache.Set([]byte(stockCode), []byte("1"), getMsgTypeTTL(msgType))
+	if err != nil {
+		logger.SugaredLogger.Errorf("set cache error:%s", err.Error())
+		return ""
+	}
+	return data.NewDingDingAPI().SendDingDingMessage(message)
+}
+
+func GenNotificationMsg(stockInfo *data.StockInfo) string {
+	Price, err := convertor.ToFloat(stockInfo.Price)
+	if err != nil {
+		Price = 0
+	}
+	PreClose, err := convertor.ToFloat(stockInfo.PreClose)
+	if err != nil {
+		PreClose = 0
+	}
+	var RF float64
+	if PreClose > 0 {
+		RF = mathutil.RoundToFloat(((Price-PreClose)/PreClose)*100, 2)
+	}
+
+	return "[" + stockInfo.Name + "] " + stockInfo.Price + " " + convertor.ToString(RF) + "% " + stockInfo.Date + " " + stockInfo.Time
+}
+
+// msgType : 1 涨跌报警(5分钟);2 股价报警(30分钟) 3 成本价报警(30分钟)
+func getMsgTypeTTL(msgType int) int {
+	switch msgType {
+	case 1:
+		return 60 * 5
+	case 2:
+		return 60 * 30
+	case 3:
+		return 60 * 30
+	default:
+		return 60 * 5
+	}
+}
+
+func getMsgTypeName(msgType int) string {
+	switch msgType {
+	case 1:
+		return "涨跌报警"
+	case 2:
+		return "股价报警"
+	case 3:
+		return "成本价报警"
+	default:
+		return "未知类型"
+	}
+}
+func (a *App) UpdateConfig(settingConfig *data.SettingConfig) string {
+	return data.UpdateConfig(settingConfig)
+}
+
+func (a *App) GetConfig() *data.SettingConfig {
+	return data.GetSettingConfig()
+}

app_test.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"testing"
+	"time"
+
+	"github.com/go-resty/resty/v2"
+)
+
+// @Author spark
+// @Date 2025/2/24 9:35
+// @Desc
+// -----------------------------------------------------------------------------------
+func TestIsHKTradingTime(t *testing.T) {
+	f := IsHKTradingTime(time.Now())
+	t.Log(f)
+}
+
+func TestIsUSTradingTime(t *testing.T) {
+
+	date := time.Now()
+	hour, minute, _ := date.Clock()
+	logger.SugaredLogger.Infof("当前时间: %d:%d", hour, minute)
+
+	t.Log(IsUSTradingTime(time.Now()))
+}
+
+func TestCheckStockBaseInfo(t *testing.T) {
+	db.Init("./data/stock.db")
+	NewApp().CheckStockBaseInfo(context.Background())
+}
+
+func TestJson(t *testing.T) {
+	db.Init("./data/stock.db")
+
+	jsonStr := "{\n\t\t\"id\" : 3334,\n\t\t\"created_at\" : \"2025-02-28 16:49:31.8342514+08:00\",\n\t\t\"updated_at\" : \"2025-02-28 16:49:31.8342514+08:00\",\n\t\t\"deleted_at\" : null,\n\t\t\"code\" : \"PUK.US\",\n\t\t\"name\" : \"英国保诚集团\",\n\t\t\"full_name\" : \"\",\n\t\t\"e_name\" : \"\",\n\t\t\"exchange\" : \"NASDAQ\",\n\t\t\"type\" : \"stock\",\n\t\t\"is_del\" : 0,\n\t\t\"bk_name\" : null,\n\t\t\"bk_code\" : null\n\t}"
+
+	v := &models.StockInfoUS{}
+	json.Unmarshal([]byte(jsonStr), v)
+	logger.SugaredLogger.Infof("v:%+v", v)
+
+	db.Dao.Model(v).Updates(v)
+
+}
+
+func TestUpdateCheck(t *testing.T) {
+	releaseVersion := &models.GitHubReleaseVersion{}
+	_, err := resty.New().R().
+		SetResult(releaseVersion).
+		SetHeader("Accept", "application/vnd.github+json").
+		SetHeader("X-GitHub-Api-Version", "2022-11-28").
+		Get("https://api.github.com/repos/ArvinLovegood/go-stock/releases/latest")
+	//  https://api.github.com/repos/OWNER/REPO/releases/latest
+	if err != nil {
+		logger.SugaredLogger.Errorf("get github release version error:%s", err.Error())
+		return
+	}
+	logger.SugaredLogger.Infof("releaseVersion:%+v", releaseVersion)
+}
+
+func TestGetScreenResolution(t *testing.T) {
+	x, y, w, h, err := getScreenResolution()
+	if err != nil {
+		logger.SugaredLogger.Errorf("get screen resolution error:%s", err.Error())
+		return
+	}
+	logger.SugaredLogger.Infof("x:%d,y:%d,w:%d,h:%d", x, y, w, h)
+
+}

app_windows.go

@@ -0,0 +1,216 @@
+//go:build windows
+// +build windows
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"go-stock/backend/data"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"time"
+
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/energye/systray"
+	"github.com/go-toast/toast"
+	"github.com/wailsapp/wails/v2/pkg/options"
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// startup is called at application startup
+func (a *App) startup(ctx context.Context) {
+	defer PanicHandler()
+	runtime.EventsOn(ctx, "frontendError", func(optionalData ...interface{}) {
+		logger.SugaredLogger.Errorf("Frontend error: %v\n", optionalData)
+	})
+	logger.SugaredLogger.Infof("Version:%s", Version)
+	// Perform your setup here
+	a.ctx = ctx
+
+	// 创建系统托盘
+	//systray.RunWithExternalLoop(func() {
+	//	onReady(a)
+	//}, func() {
+	//	onExit(a)
+	//})
+	runtime.EventsOn(ctx, "updateSettings", func(optionalData ...interface{}) {
+		logger.SugaredLogger.Infof("updateSettings : %v\n", optionalData)
+		config := data.GetSettingConfig()
+		//setMap := optionalData[0].(map[string]interface{})
+		//
+		//// 将 map 转换为 JSON 字节切片
+		//jsonData, err := json.Marshal(setMap)
+		//if err != nil {
+		//	logger.SugaredLogger.Errorf("Marshal error:%s", err.Error())
+		//	return
+		//}
+		//// 将 JSON 字节切片解析到结构体中
+		//err = json.Unmarshal(jsonData, config)
+		//if err != nil {
+		//	logger.SugaredLogger.Errorf("Unmarshal error:%s", err.Error())
+		//	return
+		//}
+
+		logger.SugaredLogger.Infof("updateSettings config:%+v", config)
+		if config.DarkTheme {
+			runtime.WindowSetBackgroundColour(ctx, 27, 38, 54, 1)
+			runtime.WindowSetDarkTheme(ctx)
+		} else {
+			runtime.WindowSetBackgroundColour(ctx, 255, 255, 255, 1)
+			runtime.WindowSetLightTheme(ctx)
+		}
+		runtime.WindowReloadApp(ctx)
+
+	})
+	go systray.Run(func() {
+		onReady(a)
+	}, func() {
+		onExit(a)
+	})
+
+	logger.SugaredLogger.Infof(" application startup Version:%s", Version)
+}
+
+func OnSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	notification := toast.Notification{
+		AppID:    "go-stock",
+		Title:    "go-stock",
+		Message:  "程序已经在运行了",
+		Icon:     "",
+		Duration: "short",
+		Audio:    toast.Default,
+	}
+	err := notification.Push()
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+	}
+	time.Sleep(time.Second * 3)
+}
+
+func MonitorStockPrices(a *App) {
+	dest := &[]data.FollowedStock{}
+	db.Dao.Model(&data.FollowedStock{}).Find(dest)
+	total := float64(0)
+	//for _, follow := range *dest {
+	//	stockData := getStockInfo(follow)
+	//	total += stockData.ProfitAmountToday
+	//	price, _ := convertor.ToFloat(stockData.Price)
+	//	if stockData.PrePrice != price {
+	//		go runtime.EventsEmit(a.ctx, "stock_price", stockData)
+	//	}
+	//}
+
+	stockInfos := GetStockInfos(*dest...)
+	for _, stockInfo := range *stockInfos {
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"SZ", "SH", "sh", "sz"}) && (!isTradingTime(time.Now())) {
+			continue
+		}
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"hk", "HK"}) && (!IsHKTradingTime(time.Now())) {
+			continue
+		}
+		if strutil.HasPrefixAny(stockInfo.Code, []string{"us", "US", "gb_"}) && (!IsUSTradingTime(time.Now())) {
+			continue
+		}
+
+		total += stockInfo.ProfitAmountToday
+		price, _ := convertor.ToFloat(stockInfo.Price)
+
+		if stockInfo.PrePrice != price {
+			//logger.SugaredLogger.Infof("-----------sz------------股票代码: %s, 股票名称: %s, 股票价格: %s,盘前盘后:%s", stockInfo.Code, stockInfo.Name, stockInfo.Price, stockInfo.BA)
+			go runtime.EventsEmit(a.ctx, "stock_price", stockInfo)
+		}
+
+	}
+	if total != 0 {
+		title := "go-stock " + time.Now().Format(time.DateTime) + fmt.Sprintf("  %.2f¥", total)
+		systray.SetTooltip(title)
+	}
+
+	go runtime.EventsEmit(a.ctx, "realtime_profit", fmt.Sprintf("  %.2f", total))
+	//runtime.WindowSetTitle(a.ctx, title)
+
+}
+
+func onReady(a *App) {
+
+	// 初始化操作
+	logger.SugaredLogger.Infof("systray onReady")
+	systray.SetIcon(icon2)
+	systray.SetTitle("go-stock")
+	systray.SetTooltip("go-stock 股票行情实时获取")
+	// 创建菜单项
+	show := systray.AddMenuItem("显示", "显示应用程序")
+	show.Click(func() {
+		//logger.SugaredLogger.Infof("显示应用程序")
+		runtime.WindowShow(a.ctx)
+	})
+	hide := systray.AddMenuItem("隐藏", "隐藏应用程序")
+	hide.Click(func() {
+		//logger.SugaredLogger.Infof("隐藏应用程序")
+		runtime.WindowHide(a.ctx)
+	})
+	systray.AddSeparator()
+	mQuitOrig := systray.AddMenuItem("退出", "退出应用程序")
+	mQuitOrig.Click(func() {
+		//logger.SugaredLogger.Infof("退出应用程序")
+		runtime.Quit(a.ctx)
+	})
+	systray.SetOnRClick(func(menu systray.IMenu) {
+		menu.ShowMenu()
+		//logger.SugaredLogger.Infof("SetOnRClick")
+	})
+	systray.SetOnClick(func(menu systray.IMenu) {
+		//logger.SugaredLogger.Infof("SetOnClick")
+		menu.ShowMenu()
+	})
+	systray.SetOnDClick(func(menu systray.IMenu) {
+		menu.ShowMenu()
+		//logger.SugaredLogger.Infof("SetOnDClick")
+	})
+}
+
+// beforeClose is called when the application is about to quit,
+// either by clicking the window close button or calling runtime.Quit.
+// Returning true will cause the application to continue, false will continue shutdown as normal.
+func (a *App) beforeClose(ctx context.Context) (prevent bool) {
+	defer PanicHandler()
+
+	dialog, err := runtime.MessageDialog(ctx, runtime.MessageDialogOptions{
+		Type:         runtime.QuestionDialog,
+		Title:        "go-stock",
+		Message:      "确定关闭吗？",
+		Buttons:      []string{"确定"},
+		Icon:         icon,
+		CancelButton: "取消",
+	})
+
+	if err != nil {
+		logger.SugaredLogger.Errorf("dialog error:%s", err.Error())
+		return false
+	}
+	logger.SugaredLogger.Debugf("dialog:%s", dialog)
+	if dialog == "No" {
+		return true
+	} else {
+		systray.Quit()
+		a.cron.Stop()
+		return false
+	}
+}
+
+func getFrameless() bool {
+	return true
+}
+
+func getScreenResolution() (int, int, int, int, error) {
+	//user32 := syscall.NewLazyDLL("user32.dll")
+	//getSystemMetrics := user32.NewProc("GetSystemMetrics")
+	//
+	//width, _, _ := getSystemMetrics.Call(0)
+	//height, _, _ := getSystemMetrics.Call(1)
+	//return int(width), int(height), 1456, 768, nil
+
+	return int(1366), int(768), 1456, 768, nil
+}

backend/agent/agent.go

@@ -0,0 +1,93 @@
+package agent
+
+import (
+	"context"
+	"go-stock/backend/agent/tools"
+	"go-stock/backend/data"
+	"go-stock/backend/logger"
+	"time"
+
+	"github.com/cloudwego/eino-ext/components/model/ark"
+	"github.com/cloudwego/eino-ext/components/model/deepseek"
+	"github.com/cloudwego/eino-ext/components/model/openai"
+	"github.com/cloudwego/eino/components/model"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/compose"
+	"github.com/cloudwego/eino/flow/agent/react"
+	"github.com/cloudwego/eino/schema"
+)
+
+// GetStockAiAgent @Author spark
+// @Date 2025/8/4 16:17
+// @Desc
+// -----------------------------------------------------------------------------------
+func GetStockAiAgent(ctx *context.Context, aiConfig data.AIConfig) *react.Agent {
+	logger.SugaredLogger.Infof("GetStockAiAgent aiConfig: %v", aiConfig)
+	temperature := float32(aiConfig.Temperature)
+	var toolableChatModel model.ToolCallingChatModel
+	var err error
+	if aiConfig.BaseUrl == "https://ark.cn-beijing.volces.com/api/v3" {
+		toolableChatModel, err = ark.NewChatModel(context.Background(), &ark.ChatModelConfig{
+			BaseURL:     aiConfig.BaseUrl,
+			Model:       aiConfig.ModelName,
+			APIKey:      aiConfig.ApiKey,
+			MaxTokens:   &aiConfig.MaxTokens,
+			Temperature: &temperature,
+		})
+
+	} else if aiConfig.BaseUrl == "https://api.deepseek.com" {
+		toolableChatModel, err = deepseek.NewChatModel(*ctx, &deepseek.ChatModelConfig{
+			BaseURL:     aiConfig.BaseUrl,
+			Model:       aiConfig.ModelName,
+			APIKey:      aiConfig.ApiKey,
+			Timeout:     time.Duration(aiConfig.TimeOut) * time.Second,
+			MaxTokens:   aiConfig.MaxTokens,
+			Temperature: temperature,
+		})
+
+	} else {
+		toolableChatModel, err = openai.NewChatModel(*ctx, &openai.ChatModelConfig{
+			BaseURL:     aiConfig.BaseUrl,
+			Model:       aiConfig.ModelName,
+			APIKey:      aiConfig.ApiKey,
+			Timeout:     time.Duration(aiConfig.TimeOut) * time.Second,
+			MaxTokens:   &aiConfig.MaxTokens,
+			Temperature: &temperature,
+		})
+	}
+
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+		return nil
+	}
+	// 初始化所需的 tools
+	aiTools := compose.ToolsNodeConfig{
+		Tools: []tool.BaseTool{
+			tools.GetQueryEconomicDataTool(),
+			tools.GetQueryStockPriceInfoTool(),
+			tools.GetQueryStockCodeInfoTool(),
+			tools.GetQueryMarketNewsTool(),
+			tools.GetChoiceStockByIndicatorsTool(),
+			tools.GetStockKLineTool(),
+			tools.GetInteractiveAnswerDataTool(),
+			tools.GetFinancialReportTool(),
+			tools.GetQueryStockNewsTool(),
+			tools.GetIndustryResearchReportTool(),
+			tools.GetQueryBKDictTool(),
+		},
+	}
+	// 创建 agent
+	agent, err := react.NewAgent(*ctx, &react.AgentConfig{
+		ToolCallingModel: toolableChatModel,
+		ToolsConfig:      aiTools,
+		MaxStep:          len(aiTools.Tools)*1 + 3,
+		MessageModifier: func(ctx context.Context, input []*schema.Message) []*schema.Message {
+			return input
+		},
+	})
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+		return nil
+	}
+	return agent
+}

backend/agent/agent_api.go

@@ -0,0 +1,91 @@
+package agent
+
+import (
+	"context"
+	"errors"
+	"github.com/cloudwego/eino/compose"
+	"github.com/cloudwego/eino/flow/agent"
+	"github.com/cloudwego/eino/flow/agent/react"
+	"github.com/cloudwego/eino/schema"
+	"github.com/samber/lo"
+	"go-stock/backend/agent/tool_logger"
+	"go-stock/backend/data"
+	"go-stock/backend/logger"
+	"io"
+)
+
+// @Author spark
+// @Date 2025/8/7 9:07
+// @Desc
+// -----------------------------------------------------------------------------------
+type StockAiAgent struct {
+	*react.Agent
+}
+
+func NewStockAiAgentApi() *StockAiAgent {
+	return &StockAiAgent{}
+}
+
+func (receiver StockAiAgent) newStockAiAgent(ctx *context.Context, aiConfigId int) *StockAiAgent {
+	settingConfig := data.GetSettingConfig()
+	aiConfig, ok := lo.Find(settingConfig.AiConfigs, func(item *data.AIConfig) bool {
+		return uint(aiConfigId) == item.ID
+	})
+	if !ok {
+		return nil
+	}
+	return &StockAiAgent{
+		Agent: GetStockAiAgent(ctx, *aiConfig),
+	}
+}
+
+func (receiver StockAiAgent) Chat(question string, aiConfigId int, sysPromptId *int) chan *schema.Message {
+	ch := make(chan *schema.Message, 512)
+	ctx := context.Background()
+	stockAiAgent := receiver.newStockAiAgent(&ctx, aiConfigId)
+
+	sysPrompt := ""
+	if sysPromptId == nil || *sysPromptId == 0 {
+		sysPrompt = "你现在扮演一位拥有20年实战经验的顶级股票投资大师，精通价值投资、趋势交易、量化分析等多种策略。你擅长结合宏观经济、行业周期和企业基本面进行全方位、精准的多维分析，尤其对A股、港股、美股市场有深刻理解，始终秉持“风险控制第一”的原则，善于用通俗易懂的方式传授投资智慧。"
+	} else {
+		sysPrompt = data.NewPromptTemplateApi().GetPromptTemplateByID(*sysPromptId)
+	}
+	agentOption := []agent.AgentOption{
+		agent.WithComposeOptions(compose.WithCallbacks(&tool_logger.LoggerCallback{MessageChanel: ch})),
+		//react.WithChatModelOptions(ark.WithCache(cacheOption)),
+	}
+
+	go func() {
+		defer close(ch)
+		sr, err := stockAiAgent.Stream(ctx, []*schema.Message{
+			{
+				Role:    schema.System,
+				Content: sysPrompt,
+			},
+			{
+				Role:    schema.User,
+				Content: question,
+			},
+		}, agentOption...)
+		if err != nil {
+			logger.SugaredLogger.Errorf("stream error: %v", err)
+			return
+		}
+		defer sr.Close()
+		for {
+			msg, err := sr.Recv()
+			if err != nil {
+				if errors.Is(err, io.EOF) {
+					// finish
+					break
+				}
+				// error
+				logger.SugaredLogger.Errorf("failed to recv: %v", err)
+				break
+			}
+			logger.SugaredLogger.Infof("stream: %s", msg.String())
+			ch <- msg
+		}
+	}()
+	return ch
+}

backend/agent/agent_test.go

@@ -0,0 +1,88 @@
+package agent
+
+import (
+	"context"
+	"errors"
+	"go-stock/backend/agent/tool_logger"
+	"go-stock/backend/data"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/cloudwego/eino/compose"
+	"github.com/cloudwego/eino/flow/agent"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/fileutil"
+)
+
+// @Author spark
+// @Date 2025/8/4 17:32
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func TestGetStockAiAgent(t *testing.T) {
+	ctx := context.Background()
+	db.Init("../../data/stock.db")
+	config := data.GetSettingConfig()
+	aiAgent := GetStockAiAgent(&ctx, *config.AiConfigs[0])
+
+	opt := []agent.AgentOption{
+		agent.WithComposeOptions(compose.WithCallbacks(&tool_logger.LoggerCallback{})),
+		//react.WithChatModelOptions(ark.WithCache(cacheOption)),
+	}
+
+	sr, err := aiAgent.Stream(ctx, []*schema.Message{
+		{
+			Role:    schema.System,
+			Content: config.Settings.Prompt + "",
+		},
+		{
+			Role:    schema.User,
+			Content: "结合以上提供的宏观经济数据/市场指数行情/国内外市场资讯/电报/会议/事件/投资者关注的问题，\n结合宏观经济，事件驱动，政策支持，投资者关注的问题，分析当前市场情绪和热点 找出有潜力/优质的板块/行业/概念/标的/主题，\n多因子深度分析计算上涨或下跌的逻辑和概率，\n最后按风险和投资周期给出具体推荐标的操作建议",
+		},
+	}, opt...)
+	if err != nil {
+		logger.SugaredLogger.Errorf("stream error: %v", err)
+		return
+	}
+
+	defer sr.Close() // remember to close the stream
+
+	md := strings.Builder{}
+	for {
+		msg, err := sr.Recv()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				// finish
+				break
+			}
+			// error
+			logger.SugaredLogger.Errorf("failed to recv: %v", err)
+			return
+		}
+		logger.SugaredLogger.Infof("stream recv: %v", msg)
+		if msg.ReasoningContent != "" {
+			md.WriteString(msg.ReasoningContent)
+		}
+		if msg.Content != "" {
+			md.WriteString(msg.Content)
+		}
+	}
+	logger.SugaredLogger.Info(md.String())
+	//logger.SugaredLogger.Infof("stream done:\n%s", md.String())
+}
+
+func TestAgent(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	md := strings.Builder{}
+	ch := NewStockAiAgentApi().Chat("分析一下立讯精密", 0, nil)
+	for message := range ch {
+		logger.SugaredLogger.Infof("res:%s", message.String())
+		md.WriteString(message.String())
+	}
+	logger.SugaredLogger.Info(md.String())
+	fileutil.WriteStringToFile("../../data/result.md", md.String(), false)
+}

backend/agent/tool_logger/tool_logger.go

@@ -0,0 +1,98 @@
+package tool_logger
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"go-stock/backend/logger"
+	"io"
+
+	"github.com/cloudwego/eino/callbacks"
+	"github.com/cloudwego/eino/components/model"
+	"github.com/cloudwego/eino/flow/agent/react"
+	"github.com/cloudwego/eino/schema"
+)
+
+// @Author spark
+// @Date 2025/8/5 10:21
+// @Desc
+//-----------------------------------------------------------------------------------
+
+type LoggerCallback struct {
+	MessageChanel            chan *schema.Message
+	callbacks.HandlerBuilder // 可以用 callbacks.HandlerBuilder 来辅助实现 callback
+}
+
+func (cb *LoggerCallback) OnStart(ctx context.Context, info *callbacks.RunInfo, input callbacks.CallbackInput) context.Context {
+	logger.SugaredLogger.Infof("==================")
+	inputStr, _ := json.MarshalIndent(input, "", "  ") // nolint: byted_s_returned_err_check
+	logger.SugaredLogger.Infof("[OnStart] %s\n", string(inputStr))
+
+	modelCallbackInput := model.ConvCallbackInput(input)
+	if modelCallbackInput != nil {
+		for _, message := range modelCallbackInput.Messages {
+			cb.MessageChanel <- message
+		}
+	}
+	return ctx
+}
+
+func (cb *LoggerCallback) OnEnd(ctx context.Context, info *callbacks.RunInfo, output callbacks.CallbackOutput) context.Context {
+	logger.SugaredLogger.Infof("=========[OnEnd]=========")
+	outputStr, _ := json.MarshalIndent(output, "", "  ") // nolint: byted_s_returned_err_check
+	logger.SugaredLogger.Infof(string(outputStr))
+	return ctx
+}
+
+func (cb *LoggerCallback) OnError(ctx context.Context, info *callbacks.RunInfo, err error) context.Context {
+	logger.SugaredLogger.Infof("=========[OnError]=========")
+	logger.SugaredLogger.Infof("%s", err.Error())
+	return ctx
+}
+
+func (cb *LoggerCallback) OnEndWithStreamOutput(ctx context.Context, info *callbacks.RunInfo,
+	output *schema.StreamReader[callbacks.CallbackOutput]) context.Context {
+
+	var graphInfoName = react.GraphName
+
+	go func() {
+		defer func() {
+			if err := recover(); err != nil {
+				logger.SugaredLogger.Infof("[OnEndStream] panic err:", err)
+			}
+		}()
+
+		defer output.Close() // remember to close the stream in defer
+
+		logger.SugaredLogger.Infof("=========[OnEndStream]=========")
+		for {
+			frame, err := output.Recv()
+			if errors.Is(err, io.EOF) {
+				// finish
+				break
+			}
+			if err != nil {
+				logger.SugaredLogger.Infof("internal error: %s\n", err)
+				return
+			}
+
+			s, err := json.Marshal(frame)
+			if err != nil {
+				logger.SugaredLogger.Infof("internal error: %s\n", err)
+				return
+			}
+
+			if info.Name == graphInfoName { // 仅打印 graph 的输出, 否则每个 stream 节点的输出都会打印一遍
+				logger.SugaredLogger.Infof("%s: %s\n", info.Name, string(s))
+			}
+		}
+
+	}()
+	return ctx
+}
+
+func (cb *LoggerCallback) OnStartWithStreamInput(ctx context.Context, info *callbacks.RunInfo,
+	input *schema.StreamReader[callbacks.CallbackInput]) context.Context {
+	defer input.Close()
+	return ctx
+}

backend/agent/tools/bk_dict_tool.go

@@ -0,0 +1,34 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"go-stock/backend/data"
+
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/coocood/freecache"
+)
+
+// @Author spark
+// @Date 2025/9/27 14:09
+// @Desc
+// -----------------------------------------------------------------------------------
+type ToolQueryBKDict struct{}
+
+func (t ToolQueryBKDict) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryBKDictInfo",
+		Desc: "获取所有板块/行业名称或者代码(bkCode,bkName)",
+	}, nil
+}
+
+func (t ToolQueryBKDict) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	resp := data.NewMarketNewsApi().EMDictCode("016", freecache.NewCache(100))
+	bytes, err := json.Marshal(resp)
+	return string(bytes), err
+}
+
+func GetQueryBKDictTool() tool.InvokableTool {
+	return &ToolQueryBKDict{}
+}

backend/agent/tools/choice_stock_by_indicators_tool.go

@@ -0,0 +1,140 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go-stock/backend/data"
+
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/random"
+)
+
+// @Author spark
+// @Date 2025/8/5 11:17
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetChoiceStockByIndicatorsTool() tool.InvokableTool {
+	return &ChoiceStockByIndicators{}
+}
+
+type ChoiceStockByIndicators struct {
+}
+
+func (c ChoiceStockByIndicators) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "ChoiceStockByIndicators",
+		Desc: "根据自然语言筛选股票，返回自然语言选股条件要求的股票所有相关数据。输入股票名称可以获取当前股票最新的股价交易数据和基础财务指标信息，多个股票名称使用,分隔。",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"words": {
+				Type: "string",
+				Desc: "选股自然语言。" +
+					"例：上海贝岭,macd,rsi,kdj,boll,5日均线,14日均线,30日均线,60日均线,成交量,OBV,EMA" +
+					"例1：创新药,半导体;PE<30;净利润增长率>50%。 " +
+					"例2：上证指数,科创50。 " +
+					"例3：长电科技,上海贝岭。" +
+					"例4：长电科技,上海贝岭;KDJ,MACD,RSI,BOLL,主力净流入/流出" +
+					"例5：换手率大于3%小于25%.量比1以上. 10日内有过涨停.股价处于峰值的二分之一以下.流通股本<100亿.当日和连续四日净流入;股价在20日均线以上.分时图股价在均线之上.热门板块下涨幅领先的A股. 当日量能20000手以上.沪深个股.近一年市盈率波动小于150%.MACD金叉;不要ST股及不要退市股，非北交所，每股收益>0。" +
+					"例6：沪深主板.流通市值小于100亿.市值大于10亿.60分钟dif大于dea.60分钟skdj指标k值大于d值.skdj指标k值小于90.换手率大于3%.成交额大于1亿元.量比大于2.涨幅大于2%小于7%.股价大于5小于50.创业板.10日均线大于20日均线;不要ST股及不要退市股;不要北交所;不要科创板;不要创业板。" +
+					"例7：股价在20日线上，一月之内涨停次数>=1，量比大于1，换手率大于3%，流通市值大于 50亿小于200亿。" +
+					"例8：基本条件：前期有爆量，回调到 10 日线，当日是缩量阴线，均线趋势向上。;优选条件：一月之内涨停次数>=1" +
+					"例9：今日涨幅大于等于2%小于等于9%;量比大于等于1.1小于等于5;换手率大于等于5%小于等于20%;市值大于等于30小于等于300亿;5日、10日、30日、60日均线、5周、10周、30周、60周均线多头排列",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (c ChoiceStockByIndicators) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	parms := map[string]any{}
+	err := json.Unmarshal([]byte(argumentsInJSON), &parms)
+	if err != nil {
+		return "", err
+	}
+	content := "无符合条件的数据"
+	words := parms["words"].(string)
+	res := data.NewSearchStockApi(words).SearchStock(random.RandInt(5, 20))
+	if convertor.ToString(res["code"]) == "100" {
+		resData := res["data"].(map[string]any)
+		result := resData["result"].(map[string]any)
+		dataList := result["dataList"].([]any)
+		columns := result["columns"].([]any)
+		headers := map[string]string{}
+		for _, v := range columns {
+			//logger.SugaredLogger.Infof("v:%+v", v)
+			d := v.(map[string]any)
+			//logger.SugaredLogger.Infof("key:%s title:%s dateMsg:%s unit:%s", d["key"], d["title"], d["dateMsg"], d["unit"])
+			title := convertor.ToString(d["title"])
+			if convertor.ToString(d["dateMsg"]) != "" {
+				title = title + "[" + convertor.ToString(d["dateMsg"]) + "]"
+			}
+			if convertor.ToString(d["unit"]) != "" {
+				title = title + "(" + convertor.ToString(d["unit"]) + ")"
+			}
+			headers[d["key"].(string)] = title
+		}
+		table := &[]map[string]any{}
+		for _, v := range dataList {
+			d := v.(map[string]any)
+			tmp := map[string]any{}
+			for key, title := range headers {
+				tmp[title] = convertor.ToString(d[key])
+			}
+			*table = append(*table, tmp)
+		}
+		jsonData, _ := json.Marshal(*table)
+		markdownTable, _ := JSONToMarkdownTable(jsonData)
+		//logger.SugaredLogger.Infof("markdownTable=\n%s", markdownTable)
+		content = "\r\n### 工具筛选出的股票数据：\r\n" + markdownTable + "\r\n"
+	}
+	return content, nil
+}
+
+// JSONToMarkdownTable 将JSON数据转换为Markdown表格
+func JSONToMarkdownTable(jsonData []byte) (string, error) {
+	var data []map[string]interface{}
+	err := json.Unmarshal(jsonData, &data)
+	if err != nil {
+		return "", err
+	}
+
+	if len(data) == 0 {
+		return "", nil
+	}
+
+	// 获取表头
+	headers := []string{}
+	for key := range data[0] {
+		headers = append(headers, key)
+	}
+
+	// 构建表头行
+	headerRow := "|"
+	for _, header := range headers {
+		headerRow += fmt.Sprintf(" %s |", header)
+	}
+	headerRow += "\n"
+
+	// 构建分隔行
+	separatorRow := "|"
+	for range headers {
+		separatorRow += " --- |"
+	}
+	separatorRow += "\n"
+
+	// 构建数据行
+	bodyRows := ""
+	for _, rowData := range data {
+		bodyRow := "|"
+		for _, header := range headers {
+			value := rowData[header]
+			bodyRow += fmt.Sprintf(" %v |", value)
+		}
+		bodyRows += bodyRow + "\n"
+	}
+
+	return headerRow + separatorRow + bodyRows, nil
+}

backend/agent/tools/common.go

@@ -0,0 +1,35 @@
+package tools
+
+import (
+	"github.com/duke-git/lancet/v2/strutil"
+	"strings"
+)
+
+// @Author spark
+// @Date 2025/8/5 17:20
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetStockCode(dcCode string) string {
+	if strutil.ContainsAny(dcCode, []string{"."}) {
+		sp := strings.Split(dcCode, ".")
+		return strings.ToLower(sp[1] + sp[0])
+	}
+
+	//北京证券交易所	8（83、87、88 等）	创新型中小企业（专精特新为主）
+	//上海证券交易所	6（60、688 等）	大盘蓝筹、科创板（高新技术）
+	//深圳证券交易所	0、3（000、002、30 等）	中小盘、创业板（成长型创新企业）
+	switch dcCode[0:1] {
+	case "8":
+		return "bj" + dcCode
+	case "9":
+		return "bj" + dcCode
+	case "6":
+		return "sh" + dcCode
+	case "0":
+		return "sz" + dcCode
+	case "3":
+		return "sz" + dcCode
+	}
+	return dcCode
+}

backend/agent/tools/economic_data_tool.go

@@ -0,0 +1,79 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"go-stock/backend/data"
+	"go-stock/backend/util"
+	"strings"
+)
+
+// @Author spark
+// @Date 2025/8/4 16:38
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetQueryEconomicDataTool() tool.InvokableTool {
+	return &ToolQueryEconomicData{}
+}
+
+type ToolQueryEconomicData struct {
+}
+
+func (t ToolQueryEconomicData) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryEconomicData",
+		Desc: "查询宏观经济数据(GDP,CPI,PPI,PMI)",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"flag": {
+				Type:     "string",
+				Desc:     "all:宏观经济数据(GDP,CPI,PPI,PMI);GDP:国内生产总值;CPI:居民消费价格指数;PPI:工业品出厂价格指数;PMI:采购经理人指数",
+				Required: false,
+			},
+		}),
+	}, nil
+}
+
+func (t ToolQueryEconomicData) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	parms := map[string]any{}
+	err := json.Unmarshal([]byte(argumentsInJSON), &parms)
+	if err != nil {
+		return "", err
+	}
+	var market strings.Builder
+
+	switch parms["flag"].(string) {
+	case "GDP":
+		res := data.NewMarketNewsApi().GetGDP()
+		md := util.MarkdownTableWithTitle("国内生产总值(GDP)", res.GDPResult.Data)
+		market.WriteString(md)
+	case "CPI":
+		res2 := data.NewMarketNewsApi().GetCPI()
+		md2 := util.MarkdownTableWithTitle("居民消费价格指数(CPI)", res2.CPIResult.Data)
+		market.WriteString(md2)
+	case "PPI":
+		res3 := data.NewMarketNewsApi().GetPPI()
+		md3 := util.MarkdownTableWithTitle("工业品出厂价格指数(PPI)", res3.PPIResult.Data)
+		market.WriteString(md3)
+	case "PMI":
+		res4 := data.NewMarketNewsApi().GetPMI()
+		md4 := util.MarkdownTableWithTitle("商品价格指数(PMI)", res4.PMIResult.Data)
+		market.WriteString(md4)
+	default:
+		res := data.NewMarketNewsApi().GetGDP()
+		md := util.MarkdownTableWithTitle("国内生产总值(GDP)", res.GDPResult.Data)
+		market.WriteString(md)
+		res2 := data.NewMarketNewsApi().GetCPI()
+		md2 := util.MarkdownTableWithTitle("居民消费价格指数(CPI)", res2.CPIResult.Data)
+		market.WriteString(md2)
+		res3 := data.NewMarketNewsApi().GetPPI()
+		md3 := util.MarkdownTableWithTitle("工业品出厂价格指数(PPI)", res3.PPIResult.Data)
+		market.WriteString(md3)
+		res4 := data.NewMarketNewsApi().GetPMI()
+		md4 := util.MarkdownTableWithTitle("采购经理人指数(PMI)", res4.PMIResult.Data)
+		market.WriteString(md4)
+	}
+	return market.String(), nil
+}

backend/agent/tools/financial_reports_tool.go

@@ -0,0 +1,50 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/tidwall/gjson"
+	"go-stock/backend/data"
+	"strings"
+)
+
+// @Author spark
+// @Date 2025/8/5 15:49
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetFinancialReportTool() tool.InvokableTool {
+	return &FinancialReportTool{}
+}
+
+type FinancialReportTool struct {
+}
+
+func (f FinancialReportTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "GetFinancialReport",
+		Desc: "查询股票财务报表数据",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"stockCode": {
+				Type:     "string",
+				Desc:     "股票代码（A股：sh,sz开头;港股hk开头,美股：us开头）不能批量查询",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (f FinancialReportTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	stockCode := gjson.Get(argumentsInJSON, "stockCode").String()
+	messages := data.GetFinancialReportsByXUEQIU(GetStockCode(stockCode), 30)
+	if messages == nil || len(*messages) == 0 {
+		return "", fmt.Errorf("没有找到%s的财务报告", stockCode)
+	}
+	md := strings.Builder{}
+	for _, s := range *messages {
+		md.WriteString(s)
+	}
+	return md.String(), nil
+}

backend/agent/tools/industry_research_report_tool.go

@@ -0,0 +1,69 @@
+package tools
+
+import (
+	"context"
+	"go-stock/backend/data"
+	log "go-stock/backend/logger"
+	"strings"
+
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/tidwall/gjson"
+)
+
+// @Author spark
+// @Date 2025/8/9 18:48
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetIndustryResearchReportTool() tool.InvokableTool {
+	return &IndustryResearchReportTool{api: data.NewMarketNewsApi()}
+}
+
+type IndustryResearchReportTool struct {
+	api *data.MarketNewsApi
+}
+
+func (i IndustryResearchReportTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "GetIndustryResearchReport",
+		Desc: "获取行业/板块研究报告",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"name": {
+				Type:     "string",
+				Desc:     "行业/板块行业名称",
+				Required: false,
+			},
+			"code": {
+				Type:     "string",
+				Desc:     "行业/板块代码",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (i IndustryResearchReportTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	code := gjson.Get(argumentsInJSON, "code").String()
+	code = strutil.ReplaceWithMap(code, map[string]string{
+		"-":   "",
+		"_":   "",
+		"bk":  "",
+		"BK":  "",
+		"bk0": "",
+		"BK0": "",
+	})
+
+	log.SugaredLogger.Debugf("code:%s", code)
+	codeStr := convertor.ToString(code)
+	resp := i.api.IndustryResearchReport(codeStr, 7)
+	md := strings.Builder{}
+	for _, a := range resp {
+		data := a.(map[string]any)
+		md.WriteString(i.api.GetIndustryReportInfo(data["infoCode"].(string)))
+	}
+	log.SugaredLogger.Debugf("codeNum:%s IndustryResearchReport:\n %s", code, md.String())
+	return md.String(), nil
+}

backend/agent/tools/interactive_answer_data_tool.go

@@ -0,0 +1,64 @@
+package tools
+
+import (
+	"context"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/tidwall/gjson"
+	"go-stock/backend/data"
+	"go-stock/backend/util"
+)
+
+// @Author spark
+// @Date 2025/8/5 12:46
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetInteractiveAnswerDataTool() tool.InvokableTool {
+	return &InteractiveAnswerDataTool{}
+}
+
+type InteractiveAnswerDataTool struct {
+}
+
+func (i InteractiveAnswerDataTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryInteractiveAnswerData",
+		Desc: "获取投资者与上市公司互动问答的数据,反映当前投资者关注的热点问题。",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"page": {
+				Type:     "string",
+				Desc:     "分页号",
+				Required: true,
+			},
+			"pageSize": {
+				Type:     "string",
+				Desc:     "分页大小",
+				Required: true,
+			},
+			"keyWord": {
+				Type:     "string",
+				Desc:     "搜索关键词,多个关键词空格隔开（可输入股票名称或者当前热门板块/行业/概念/标的/事件等）",
+				Required: false,
+			},
+		}),
+	}, nil
+}
+
+func (i InteractiveAnswerDataTool) InvokableRun(ctx context.Context, funcArguments string, opts ...tool.Option) (string, error) {
+	page := gjson.Get(funcArguments, "page").String()
+	pageSize := gjson.Get(funcArguments, "pageSize").String()
+	keyWord := gjson.Get(funcArguments, "keyWord").String()
+	pageNo, err := convertor.ToInt(page)
+	if err != nil {
+		pageNo = 1
+	}
+	pageSizeNum, err := convertor.ToInt(pageSize)
+	if err != nil {
+		pageSizeNum = 50
+	}
+	datas := data.NewMarketNewsApi().InteractiveAnswer(int(pageNo), int(pageSizeNum), keyWord)
+	content := util.MarkdownTableWithTitle("投资互动数据", datas.Results)
+	return content, nil
+}

backend/agent/tools/market_news_tool.go

@@ -0,0 +1,80 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"go-stock/backend/data"
+	"go-stock/backend/logger"
+	"strings"
+
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/random"
+	"github.com/tidwall/gjson"
+)
+
+// @Author spark
+// @Date 2025/8/4 16:38
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetQueryMarketNewsTool() tool.InvokableTool {
+	return &QueryMarketNews{}
+}
+
+type QueryMarketNews struct {
+}
+
+func (q QueryMarketNews) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryMarketNews",
+		Desc: "国内外市场资讯/电报/会议/事件",
+	}, nil
+}
+
+func (q QueryMarketNews) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	md := strings.Builder{}
+	res := data.NewMarketNewsApi().ClsCalendar()
+	for _, a := range res {
+		bytes, err := json.Marshal(a)
+		if err != nil {
+			continue
+		}
+		//logger.SugaredLogger.Debugf("value: %+v", string(bytes))
+		date := gjson.Get(string(bytes), "calendar_day")
+		md.WriteString("\n### 事件/会议日期：" + date.String())
+		list := gjson.Get(string(bytes), "items")
+		//logger.SugaredLogger.Debugf("value: %+v,list: %+v", date.String(), list)
+		list.ForEach(func(key, value gjson.Result) bool {
+			logger.SugaredLogger.Debugf("key: %+v,value: %+v", key.String(), gjson.Get(value.String(), "title"))
+			md.WriteString("\n- " + gjson.Get(value.String(), "title").String())
+			return true
+		})
+	}
+
+	news := data.NewMarketNewsApi().GetNewsList("", random.RandInt(100, 500))
+	messageText := strings.Builder{}
+	for _, telegraph := range *news {
+		messageText.WriteString("## " + telegraph.Time + ":" + "\n")
+		messageText.WriteString("### " + telegraph.Content + "\n")
+	}
+	md.WriteString("\n### 市场资讯：\n" + messageText.String())
+
+	resp := data.NewMarketNewsApi().TradingViewNews()
+	var newsText strings.Builder
+	for _, a := range *resp {
+		logger.SugaredLogger.Debugf("TradingViewNews: %s", a.Title)
+		newsText.WriteString(a.Title + "\n")
+	}
+	md.WriteString("\n### 全球新闻资讯：\n" + newsText.String())
+
+	reutersNew := data.NewMarketNewsApi().ReutersNew()
+	reutersNewMessageText := strings.Builder{}
+	for _, article := range reutersNew.Result.Articles {
+		reutersNewMessageText.WriteString("## " + article.Title + "\n")
+		reutersNewMessageText.WriteString("### " + article.Description + "\n")
+	}
+	md.WriteString("\n### 外媒全球新闻资讯：\n" + reutersNewMessageText.String())
+
+	return md.String(), nil
+}

backend/agent/tools/stock_code_tool.go

@@ -0,0 +1,49 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"go-stock/backend/data"
+)
+
+// @Author spark
+// @Date 2025/8/4 18:25
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetQueryStockCodeInfoTool() tool.InvokableTool {
+	return &QueryStockCodeInfo{}
+}
+
+type QueryStockCodeInfo struct {
+}
+
+func (q QueryStockCodeInfo) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryStockCodeInfo",
+		Desc: "查询股票/指数信息(股票/指数名称,股票/指数代码,股票/指数拼音,股票/指数拼音首字母,股票/指数交易所等",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"searchWord": {
+				Type:     "string",
+				Desc:     "股票搜索关键词",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (q QueryStockCodeInfo) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	parms := map[string]any{}
+	err := json.Unmarshal([]byte(argumentsInJSON), &parms)
+	if err != nil {
+		return "", err
+	}
+	stockList := data.NewStockDataApi().GetStockList(parms["searchWord"].(string))
+	marshal, err := json.Marshal(stockList)
+	if err != nil {
+		return "", err
+	}
+	return string(marshal), nil
+}

backend/agent/tools/stock_k_line_data_tool.go

@@ -0,0 +1,80 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/tidwall/gjson"
+	"go-stock/backend/data"
+)
+
+// @Author spark
+// @Date 2025/8/5 11:31
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetStockKLineTool() tool.InvokableTool {
+	return &QueryStockKLine{}
+}
+
+type QueryStockKLine struct {
+}
+
+func (q QueryStockKLine) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryStockKLine",
+		Desc: "获取股票K线数据。输入股票名称和K线周期，返回股票K线数据。",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"days": {
+				Type:     "string",
+				Desc:     "日K数据条数。",
+				Required: true,
+			},
+			"stockCode": {
+				Type:     "string",
+				Desc:     "股票代码（A股：sh,sz开头;港股hk开头,美股：us开头）",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (q QueryStockKLine) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	stockCode := GetStockCode(gjson.Get(argumentsInJSON, "stockCode").String())
+	days := gjson.Get(argumentsInJSON, "days").String()
+	toIntDay, err := convertor.ToInt(days)
+	if err != nil {
+		toIntDay = 90
+	}
+	if strutil.HasPrefixAny(stockCode, []string{"sz", "sh", "hk", "us", "gb_"}) {
+		K := &[]data.KLineData{}
+		if strutil.HasPrefixAny(stockCode, []string{"sz", "sh"}) {
+			K = data.NewStockDataApi().GetKLineData(stockCode, "240", toIntDay)
+		}
+		if strutil.HasPrefixAny(stockCode, []string{"hk", "us", "gb_"}) {
+			K = data.NewStockDataApi().GetHK_KLineData(stockCode, "day", toIntDay)
+		}
+		Kmap := &[]map[string]any{}
+		for _, kline := range *K {
+			mapk := make(map[string]any, 6)
+			mapk["日期"] = kline.Day
+			mapk["开盘价"] = kline.Open
+			mapk["最高价"] = kline.High
+			mapk["最低价"] = kline.Low
+			mapk["收盘价"] = kline.Close
+			Volume, _ := convertor.ToFloat(kline.Volume)
+			mapk["成交量(万手)"] = Volume / 10000.00 / 100.00
+			*Kmap = append(*Kmap, mapk)
+		}
+		jsonData, _ := json.Marshal(Kmap)
+		markdownTable, _ := JSONToMarkdownTable(jsonData)
+		res := "\r\n ### " + stockCode + " " + convertor.ToString(toIntDay) + "日K线数据：\r\n" + markdownTable + "\r\n"
+		return res, nil
+	} else {
+		return "无数据，可能股票代码错误。（A股：sh,sz开头;港股hk开头,美股：us开头）", fmt.Errorf("不支持的股票代码:%s", stockCode)
+	}
+}

backend/agent/tools/stock_news_tool.go

@@ -0,0 +1,42 @@
+package tools
+
+import (
+	"context"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"github.com/tidwall/gjson"
+	"go-stock/backend/data"
+	"go-stock/backend/util"
+)
+
+// @Author spark
+// @Date 2025/8/5 16:27
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetQueryStockNewsTool() tool.InvokableTool {
+	return &QueryStockNewsTool{}
+}
+
+type QueryStockNewsTool struct {
+}
+
+func (q QueryStockNewsTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryStockNewsTool",
+		Desc: "按关键词搜索相关市场资讯/新闻",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"searchWords": {
+				Type:     "string",
+				Desc:     "搜索关键词(多个关键词使用空格分隔)",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (q QueryStockNewsTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	searchWords := gjson.Get(argumentsInJSON, "searchWords").String()
+	res := data.NewMarketNewsApi().CailianpressWeb(searchWords)
+	return util.MarkdownTableWithTitle(searchWords+"市场资讯/新闻", res.List), nil
+}

backend/agent/tools/stock_price_info_tool.go

@@ -0,0 +1,57 @@
+package tools
+
+import (
+	"context"
+	"encoding/json"
+	"github.com/cloudwego/eino/components/tool"
+	"github.com/cloudwego/eino/schema"
+	"go-stock/backend/data"
+	"strings"
+)
+
+// @Author spark
+// @Date 2025/8/4 17:58
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func GetQueryStockPriceInfoTool() tool.InvokableTool {
+	return &ToolQueryStockPriceInfo{}
+}
+
+type ToolQueryStockPriceInfo struct{}
+
+func (t ToolQueryStockPriceInfo) Info(ctx context.Context) (*schema.ToolInfo, error) {
+	return &schema.ToolInfo{
+		Name: "QueryStockPriceInfo",
+		Desc: "批量获取实时股价数据",
+		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
+			"stockCodes": {
+				Type:     "string",
+				Desc:     "股票代码,多个,隔开,股票代码必须转化为sh或者sz或者hk开头的形式，例如：sz399001,sh600859",
+				Required: true,
+			},
+		}),
+	}, nil
+}
+
+func (t ToolQueryStockPriceInfo) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
+	parms := map[string]any{}
+	err := json.Unmarshal([]byte(argumentsInJSON), &parms)
+	if err != nil {
+		return "", err
+	}
+	stockCodes := strings.Split(parms["stockCodes"].(string), ",")
+	var codes []string
+	for _, code := range stockCodes {
+		codes = append(codes, GetStockCode(code))
+	}
+	realTimeData, err := data.NewStockDataApi().GetStockCodeRealTimeData(codes...)
+	if err != nil {
+		return "", err
+	}
+	marshal, err := json.Marshal(realTimeData)
+	if err != nil {
+		return "", err
+	}
+	return string(marshal), nil
+}

backend/data/ai_recommend_stocks_api.go

@@ -0,0 +1,138 @@
+// Package data ai_recommend_stocks_api.go
+package data
+
+import (
+	"go-stock/backend/db"
+	"go-stock/backend/models"
+
+	"github.com/duke-git/lancet/v2/slice"
+	"github.com/duke-git/lancet/v2/strutil"
+)
+
+type AiRecommendStocksService struct{}
+
+func NewAiRecommendStocksService() *AiRecommendStocksService {
+	return &AiRecommendStocksService{}
+}
+
+// CreateAiRecommendStocks 创建AI推荐股票记录
+func (s *AiRecommendStocksService) CreateAiRecommendStocks(recommend *models.AiRecommendStocks) error {
+	result := db.Dao.Create(recommend)
+	return result.Error
+}
+
+func (s *AiRecommendStocksService) BatchCreateAiRecommendStocks(recommends []*models.AiRecommendStocks) error {
+	result := db.Dao.Create(recommends)
+	return result.Error
+}
+
+// GetAiRecommendStocksList 分页查询AI推荐股票记录
+func (s *AiRecommendStocksService) GetAiRecommendStocksList(query *models.AiRecommendStocksQuery) (*models.AiRecommendStocksPageData, error) {
+	var list []models.AiRecommendStocks
+	var total int64
+
+	q := db.Dao.Model(&models.AiRecommendStocks{})
+
+	// 构建查询条件
+	if query.StockCode != "" {
+		q.Or("stock_code LIKE ?", "%"+query.StockCode+"%")
+	}
+	if query.StockName != "" {
+		q.Or("stock_name LIKE ?", "%"+query.StockName+"%")
+	}
+	if query.BkCode != "" {
+		q.Or("bk_code LIKE ?", "%"+query.BkCode+"%")
+	}
+	if query.BkName != "" {
+		q.Or("bk_name LIKE ?", "%"+query.BkName+"%")
+	}
+
+	if query.StartDate != "" && query.EndDate != "" {
+		query.StartDate = strutil.ReplaceWithMap(query.StartDate, map[string]string{
+			"T": " ",
+			"Z": "",
+		})
+		query.StartDate = strutil.ReplaceWithMap(query.StartDate, map[string]string{
+			"T": " ",
+			"Z": "",
+		})
+		q = q.Where("data_time BETWEEN ? AND ?", query.StartDate, query.EndDate)
+	}
+
+	// 计算总数
+	err := q.Count(&total).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置默认分页参数
+	page := query.Page
+	pageSize := query.PageSize
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 || pageSize > 100 {
+		pageSize = 10
+	}
+
+	// 执行分页查询
+	offset := (page - 1) * pageSize
+	err = q.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&list).Error
+	if err != nil {
+		return nil, err
+	}
+
+	totalPages := int((total + int64(pageSize) - 1) / int64(pageSize))
+
+	stockCodes := slice.Map(list, func(index int, item models.AiRecommendStocks) string {
+		return ConvertTushareCodeToStockCode(item.StockCode)
+	})
+	stockData, _ := NewStockDataApi().GetStockCodeRealTimeData(stockCodes...)
+	for _, info := range *stockData {
+		for idx, item := range list {
+			if ConvertTushareCodeToStockCode(item.StockCode) == ConvertTushareCodeToStockCode(info.Code) {
+				list[idx].StockCurrentPrice = info.Price
+				list[idx].StockPrePrice = info.PreClose
+				list[idx].StockCurrentPriceTime = info.Date + " " + info.Time
+			}
+		}
+	}
+
+	return &models.AiRecommendStocksPageData{
+		List:       list,
+		Total:      total,
+		Page:       page,
+		PageSize:   pageSize,
+		TotalPages: totalPages,
+	}, nil
+}
+
+// GetAiRecommendStocksByID 根据ID获取AI推荐股票记录
+func (s *AiRecommendStocksService) GetAiRecommendStocksByID(id uint) (*models.AiRecommendStocks, error) {
+	var recommend models.AiRecommendStocks
+	err := db.Dao.First(&recommend, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &recommend, nil
+}
+
+// UpdateAiRecommendStocks 更新AI推荐股票记录
+func (s *AiRecommendStocksService) UpdateAiRecommendStocks(id uint, recommend *models.AiRecommendStocks) error {
+	result := db.Dao.Model(&models.AiRecommendStocks{}).Where("id = ?", id).Updates(recommend)
+	return result.Error
+}
+
+// DeleteAiRecommendStocks 根据ID删除AI推荐股票记录
+func (s *AiRecommendStocksService) DeleteAiRecommendStocks(id uint) error {
+	// 使用软删除
+	result := db.Dao.Where("id = ?", id).Delete(&models.AiRecommendStocks{})
+	return result.Error
+}
+
+// BatchDeleteAiRecommendStocks 批量删除AI推荐股票记录
+func (s *AiRecommendStocksService) BatchDeleteAiRecommendStocks(ids []uint) error {
+	// 使用软删除
+	result := db.Dao.Where("id IN ?", ids).Delete(&models.AiRecommendStocks{})
+	return result.Error
+}

backend/data/ai_response_result_api.go

@@ -0,0 +1,97 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"go-stock/backend/models"
+
+	"github.com/duke-git/lancet/v2/strutil"
+)
+
+type AIResponseResultService struct{}
+
+func NewAIResponseResultService() *AIResponseResultService {
+	return &AIResponseResultService{}
+}
+
+// GetAIResponseResultList 分页查询AI响应结果
+func (s *AIResponseResultService) GetAIResponseResultList(query models.AIResponseResultQuery) (*models.AIResponseResultPageData, error) {
+	var list []models.AIResponseResult
+	var total int64
+
+	q := db.Dao.Model(&models.AIResponseResult{})
+
+	// 构建查询条件
+	if query.ChatId != "" {
+		q.Where("chat_id LIKE ?", "%"+query.ChatId+"%")
+	}
+	if query.ModelName != "" {
+		q.Or("model_name LIKE ?", "%"+query.ModelName+"%")
+	}
+	if query.StockCode != "" {
+		q.Or("stock_code LIKE ?", "%"+query.StockCode+"%")
+	}
+	if query.Question != "" {
+		q.Or("question LIKE ?", "%"+query.Question+"%")
+	}
+	if query.StartDate != "" && query.EndDate != "" {
+		query.StartDate = strutil.ReplaceWithMap(query.StartDate, map[string]string{
+			"T": " ",
+			"Z": "",
+		})
+		query.StartDate = strutil.ReplaceWithMap(query.StartDate, map[string]string{
+			"T": " ",
+			"Z": "",
+		})
+		q = q.Where("created_at BETWEEN ? AND ?", query.StartDate, query.EndDate)
+	}
+
+	// 计算总数
+	err := q.Count(&total).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置默认分页参数
+	page := query.Page
+	pageSize := query.PageSize
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 || pageSize > 100 {
+		pageSize = 10
+	}
+
+	// 执行分页查询
+	offset := (page - 1) * pageSize
+	err = q.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&list).Error
+	if err != nil {
+		return nil, err
+	}
+
+	totalPages := int((total + int64(pageSize) - 1) / int64(pageSize))
+
+	return &models.AIResponseResultPageData{
+		List:       list,
+		Total:      total,
+		Page:       page,
+		PageSize:   pageSize,
+		TotalPages: totalPages,
+	}, nil
+}
+
+// DeleteAIResponseResult 根据ID删除AI响应结果
+func (s *AIResponseResultService) DeleteAIResponseResult(id string) error {
+
+	// 使用软删除
+	result := db.Dao.Where("id = ?", id).Delete(&models.AIResponseResult{})
+
+	return result.Error
+}
+
+// BatchDeleteAIResponseResult 批量删除AI响应结果
+func (s *AIResponseResultService) BatchDeleteAIResponseResult(ids []uint) error {
+	// 使用软删除
+	result := db.Dao.Where("id IN ?", ids).Delete(&models.AIResponseResult{})
+
+	return result.Error
+}

backend/data/ai_response_result_api_test.go

@@ -0,0 +1,26 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"go-stock/backend/models"
+	"testing"
+)
+
+// @Author spark
+// @Date 2026/1/23 17:39
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func TestAIResponseResultService_GetAIResponseResultList(t *testing.T) {
+	db.Init("../../data/stock.db")
+	service := NewAIResponseResultService()
+	list, err := service.GetAIResponseResultList(models.AIResponseResultQuery{
+		Page:     1,
+		PageSize: 10,
+	})
+	if err != nil {
+		return
+	}
+	t.Log(list)
+
+}

backend/data/alert_darwin_api.go

@@ -0,0 +1,52 @@
+//go:build darwin
+// +build darwin
+
+package data
+
+import (
+	"fmt"
+	"go-stock/backend/logger"
+
+	"os/exec"
+)
+
+// AlertWindowsApi @Author 2lovecode
+// @Date 2025/02/06 17:50
+// @Desc
+// -----------------------------------------------------------------------------------
+type AlertWindowsApi struct {
+	AppID string
+	// 窗口标题
+	Title string
+	// 窗口内容
+	Content string
+	// 窗口图标
+	Icon string
+}
+
+func NewAlertWindowsApi(AppID string, Title string, Content string, Icon string) *AlertWindowsApi {
+	return &AlertWindowsApi{
+		AppID:   AppID,
+		Title:   Title,
+		Content: Content,
+		Icon:    Icon,
+	}
+}
+
+func (a AlertWindowsApi) SendNotification() bool {
+	if GetSettingConfig().LocalPushEnable == false {
+		logger.SugaredLogger.Error("本地推送未开启")
+		return false
+	}
+
+	script := fmt.Sprintf(`display notification "%s" with title "%s"`, a.Content, a.Title)
+
+	cmd := exec.Command("osascript", "-e", script)
+	err := cmd.Run()
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return false
+	}
+
+	return true
+}

backend/data/alert_darwin_api_test.go

@@ -0,0 +1,32 @@
+//go:build darwin
+// +build darwin
+
+package data
+
+import (
+	"go-stock/backend/logger"
+	"testing"
+
+	"github.com/go-toast/toast"
+)
+
+// @Author 2lovecode
+// @Date 2025/02/06 17:50
+// @Desc
+// -----------------------------------------------------------------------------------
+
+func TestAlert(t *testing.T) {
+	notification := toast.Notification{
+		AppID:    "go-stock",
+		Title:    "Hello, World!",
+		Message:  "This is a toast notification.",
+		Icon:     "../../build/appicon.png",
+		Duration: "short",
+		Audio:    toast.Default,
+	}
+	err := notification.Push()
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return
+	}
+}

backend/data/alert_windows_api.go

@@ -0,0 +1,55 @@
+//go:build windows
+// +build windows
+
+package data
+
+import (
+	"go-stock/backend/logger"
+
+	"github.com/go-toast/toast"
+)
+
+// AlertWindowsApi @Author spark
+// @Date 2025/1/8 9:40
+// @Desc
+// -----------------------------------------------------------------------------------
+type AlertWindowsApi struct {
+	AppID string
+	// 窗口标题
+	Title string
+	// 窗口内容
+	Content string
+	// 窗口图标
+	Icon string
+}
+
+func NewAlertWindowsApi(AppID string, Title string, Content string, Icon string) *AlertWindowsApi {
+	return &AlertWindowsApi{
+		AppID:   AppID,
+		Title:   Title,
+		Content: Content,
+		Icon:    Icon,
+	}
+}
+
+func (a AlertWindowsApi) SendNotification() bool {
+	if GetSettingConfig().LocalPushEnable == false {
+		logger.SugaredLogger.Error("本地推送未开启")
+		return false
+	}
+
+	notification := toast.Notification{
+		AppID:    a.AppID,
+		Title:    a.Title,
+		Message:  a.Content,
+		Icon:     a.Icon,
+		Duration: "short",
+		Audio:    toast.Default,
+	}
+	err := notification.Push()
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return false
+	}
+	return true
+}

backend/data/alert_windows_api_test.go

@@ -0,0 +1,32 @@
+//go:build windows
+// +build windows
+
+package data
+
+import (
+	"go-stock/backend/logger"
+	"testing"
+
+	"github.com/go-toast/toast"
+)
+
+// @Author spark
+// @Date 2025/1/8 9:40
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func TestAlert(t *testing.T) {
+	notification := toast.Notification{
+		AppID:    "go-stock",
+		Title:    "Hello, World!",
+		Message:  "This is a toast notification.",
+		Icon:     "../../build/appicon.png",
+		Duration: "short",
+		Audio:    toast.Default,
+	}
+	err := notification.Push()
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return
+	}
+}

backend/data/crawler_api.go

@@ -0,0 +1,237 @@
+package data
+
+import (
+	"context"
+	"github.com/chromedp/chromedp"
+	"go-stock/backend/logger"
+	"time"
+)
+
+// @Author spark
+// @Date 2025/2/13 9:25
+// @Desc
+// -----------------------------------------------------------------------------------
+
+type CrawlerApi struct {
+	crawlerCtx      context.Context
+	crawlerBaseInfo CrawlerBaseInfo
+	pool            *BrowserPool
+}
+
+func (c *CrawlerApi) NewTimeOutCrawler(timeout int, crawlerBaseInfo CrawlerBaseInfo) CrawlerApi {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
+	defer cancel()
+	return c.NewCrawler(ctx, crawlerBaseInfo)
+}
+func (c *CrawlerApi) NewCrawler(ctx context.Context, crawlerBaseInfo CrawlerBaseInfo) CrawlerApi {
+	return CrawlerApi{
+		crawlerCtx:      ctx,
+		crawlerBaseInfo: crawlerBaseInfo,
+		pool:            NewBrowserPool(GetSettingConfig().BrowserPoolSize),
+	}
+}
+func (c *CrawlerApi) GetHtml(url, waitVisible string, headless bool) (string, bool) {
+	page, err := c.pool.FetchPage(url, waitVisible)
+	if err != nil {
+		return "", false
+	}
+	return page, true
+}
+func (c *CrawlerApi) GetHtml_old(url, waitVisible string, headless bool) (string, bool) {
+	htmlContent := ""
+	path := GetSettingConfig().BrowserPath
+	//logger.SugaredLogger.Infof("Browser path:%s", path)
+	if path != "" {
+		pctx, pcancel := chromedp.NewExecAllocator(
+			c.crawlerCtx,
+			chromedp.ExecPath(path),
+			chromedp.Flag("headless", headless),
+			chromedp.Flag("blink-settings", "imagesEnabled=false"),
+			chromedp.Flag("disable-javascript", false),
+			chromedp.Flag("disable-gpu", true),
+			chromedp.UserAgent(c.crawlerBaseInfo.Headers["User-Agent"]),
+			chromedp.Flag("disable-background-networking", true),
+			chromedp.Flag("enable-features", "NetworkService,NetworkServiceInProcess"),
+			chromedp.Flag("disable-background-timer-throttling", true),
+			chromedp.Flag("disable-backgrounding-occluded-windows", true),
+			chromedp.Flag("disable-breakpad", true),
+			chromedp.Flag("disable-client-side-phishing-detection", true),
+			chromedp.Flag("disable-default-apps", true),
+			chromedp.Flag("disable-dev-shm-usage", true),
+			chromedp.Flag("disable-extensions", true),
+			chromedp.Flag("disable-features", "site-per-process,Translate,BlinkGenPropertyTrees"),
+			chromedp.Flag("disable-hang-monitor", true),
+			chromedp.Flag("disable-ipc-flooding-protection", true),
+			chromedp.Flag("disable-popup-blocking", true),
+			chromedp.Flag("disable-prompt-on-repost", true),
+			chromedp.Flag("disable-renderer-backgrounding", true),
+			chromedp.Flag("disable-sync", true),
+			chromedp.Flag("force-color-profile", "srgb"),
+			chromedp.Flag("metrics-recording-only", true),
+			chromedp.Flag("safebrowsing-disable-auto-update", true),
+			chromedp.Flag("enable-automation", true),
+			chromedp.Flag("password-store", "basic"),
+			chromedp.Flag("use-mock-keychain", true),
+		)
+		defer pcancel()
+		ctx, cancel := chromedp.NewContext(pctx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		defer cancel()
+		//defer chromedp.Cancel(ctx)
+		err := chromedp.Run(ctx, chromedp.Navigate(url),
+			chromedp.WaitVisible(waitVisible, chromedp.ByQuery), // 确保  元素可见
+			chromedp.WaitReady(waitVisible, chromedp.ByQuery),   // 确保  元素准备好
+			chromedp.InnerHTML("body", &htmlContent),
+		)
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false
+		}
+	} else {
+		ctx, cancel := chromedp.NewContext(c.crawlerCtx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		defer cancel()
+		//defer chromedp.Cancel(ctx)
+		err := chromedp.Run(ctx, chromedp.Navigate(url), chromedp.WaitVisible("body"), chromedp.InnerHTML("body", &htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false
+		}
+	}
+	return htmlContent, true
+
+}
+
+func (c *CrawlerApi) GetHtmlWithNoCancel(url, waitVisible string, headless bool) (html string, ok bool, parent context.CancelFunc, child context.CancelFunc) {
+	htmlContent := ""
+	path := GetSettingConfig().BrowserPath
+	//logger.SugaredLogger.Infof("BrowserPath :%s", path)
+	var parentCancel context.CancelFunc
+	var childCancel context.CancelFunc
+	var pctx context.Context
+	var cctx context.Context
+
+	if path != "" {
+		pctx, parentCancel = chromedp.NewExecAllocator(
+			c.crawlerCtx,
+			chromedp.ExecPath(path),
+			chromedp.Flag("headless", headless),
+			chromedp.Flag("blink-settings", "imagesEnabled=false"),
+			chromedp.Flag("disable-javascript", false),
+			chromedp.Flag("disable-gpu", true),
+			chromedp.UserAgent(c.crawlerBaseInfo.Headers["User-Agent"]),
+			chromedp.Flag("disable-background-networking", true),
+			chromedp.Flag("enable-features", "NetworkService,NetworkServiceInProcess"),
+			chromedp.Flag("disable-background-timer-throttling", true),
+			chromedp.Flag("disable-backgrounding-occluded-windows", true),
+			chromedp.Flag("disable-breakpad", true),
+			chromedp.Flag("disable-client-side-phishing-detection", true),
+			chromedp.Flag("disable-default-apps", true),
+			chromedp.Flag("disable-dev-shm-usage", true),
+			chromedp.Flag("disable-extensions", true),
+			chromedp.Flag("disable-features", "site-per-process,Translate,BlinkGenPropertyTrees"),
+			chromedp.Flag("disable-hang-monitor", true),
+			chromedp.Flag("disable-ipc-flooding-protection", true),
+			chromedp.Flag("disable-popup-blocking", true),
+			chromedp.Flag("disable-prompt-on-repost", true),
+			chromedp.Flag("disable-renderer-backgrounding", true),
+			chromedp.Flag("disable-sync", true),
+			chromedp.Flag("force-color-profile", "srgb"),
+			chromedp.Flag("metrics-recording-only", true),
+			chromedp.Flag("safebrowsing-disable-auto-update", true),
+			chromedp.Flag("enable-automation", true),
+			chromedp.Flag("password-store", "basic"),
+			chromedp.Flag("use-mock-keychain", true),
+		)
+		//defer pcancel()
+		cctx, childCancel = chromedp.NewContext(pctx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		//defer cancel()
+		err := chromedp.Run(cctx, chromedp.Navigate(url),
+			chromedp.WaitVisible(waitVisible, chromedp.ByQuery), // 确保  元素可见
+			chromedp.WaitReady(waitVisible, chromedp.ByQuery),   // 确保  元素准备好
+			chromedp.InnerHTML("body", &htmlContent),
+		)
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false, parentCancel, childCancel
+		}
+	} else {
+		cctx, childCancel = chromedp.NewContext(c.crawlerCtx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		//defer cancel()
+		err := chromedp.Run(cctx, chromedp.Navigate(url), chromedp.WaitVisible("body"), chromedp.InnerHTML("body", &htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false, parentCancel, childCancel
+		}
+	}
+	return htmlContent, true, parentCancel, childCancel
+
+}
+
+func (c *CrawlerApi) GetHtmlWithActions(actions *[]chromedp.Action, headless bool) (string, bool) {
+	htmlContent := ""
+	*actions = append(*actions, chromedp.InnerHTML("body", &htmlContent))
+
+	path := GetSettingConfig().BrowserPath
+	//logger.SugaredLogger.Infof("GetHtmlWithActions path:%s", path)
+	if path != "" {
+		pctx, pcancel := chromedp.NewExecAllocator(
+			c.crawlerCtx,
+			chromedp.ExecPath(path),
+			chromedp.Flag("headless", headless),
+			chromedp.Flag("blink-settings", "imagesEnabled=false"),
+			chromedp.Flag("disable-javascript", false),
+			chromedp.Flag("disable-gpu", true),
+			chromedp.UserAgent(c.crawlerBaseInfo.Headers["User-Agent"]),
+			chromedp.Flag("disable-background-networking", true),
+			chromedp.Flag("enable-features", "NetworkService,NetworkServiceInProcess"),
+			chromedp.Flag("disable-background-timer-throttling", true),
+			chromedp.Flag("disable-backgrounding-occluded-windows", true),
+			chromedp.Flag("disable-breakpad", true),
+			chromedp.Flag("disable-client-side-phishing-detection", true),
+			chromedp.Flag("disable-default-apps", true),
+			chromedp.Flag("disable-dev-shm-usage", true),
+			chromedp.Flag("disable-extensions", true),
+			chromedp.Flag("disable-features", "site-per-process,Translate,BlinkGenPropertyTrees"),
+			chromedp.Flag("disable-hang-monitor", true),
+			chromedp.Flag("disable-ipc-flooding-protection", true),
+			chromedp.Flag("disable-popup-blocking", true),
+			chromedp.Flag("disable-prompt-on-repost", true),
+			chromedp.Flag("disable-renderer-backgrounding", true),
+			chromedp.Flag("disable-sync", true),
+			chromedp.Flag("force-color-profile", "srgb"),
+			chromedp.Flag("metrics-recording-only", true),
+			chromedp.Flag("safebrowsing-disable-auto-update", true),
+			chromedp.Flag("enable-automation", true),
+			chromedp.Flag("password-store", "basic"),
+			chromedp.Flag("use-mock-keychain", true),
+		)
+		defer pcancel()
+		ctx, cancel := chromedp.NewContext(pctx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		defer cancel()
+		//defer chromedp.Cancel(ctx)
+
+		err := chromedp.Run(ctx, *actions...)
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false
+		}
+	} else {
+		ctx, cancel := chromedp.NewContext(c.crawlerCtx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+		defer cancel()
+		//defer chromedp.Cancel(ctx)
+
+		err := chromedp.Run(ctx, *actions...)
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return "", false
+		}
+	}
+
+	return htmlContent, true
+}
+
+type CrawlerBaseInfo struct {
+	Name        string            `json:"name"`
+	Description string            `json:"description"`
+	BaseUrl     string            `json:"base_url"`
+	Headers     map[string]string `json:"headers"`
+}

backend/data/crawler_api_test.go

@@ -0,0 +1,371 @@
+package data
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/PuerkitoBio/goquery"
+	"github.com/duke-git/lancet/v2/strutil"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/chromedp/chromedp"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewTimeOutGuShiTongCrawler(t *testing.T) {
+	crawlerAPI := CrawlerApi{}
+	timeout := 10
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://gushitong.baidu.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+
+	result := crawlerAPI.NewTimeOutCrawler(timeout, crawlerBaseInfo)
+	assert.NotNil(t, result.crawlerCtx)
+	assert.Equal(t, crawlerBaseInfo, result.crawlerBaseInfo)
+}
+
+func TestNewGuShiTongCrawler(t *testing.T) {
+	crawlerAPI := CrawlerApi{}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://gushitong.baidu.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+
+	result := crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+	assert.Equal(t, ctx, result.crawlerCtx)
+	assert.Equal(t, crawlerBaseInfo, result.crawlerBaseInfo)
+}
+
+func TestGetHtml(t *testing.T) {
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://gushitong.baidu.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+	url := "https://www.cls.cn/searchPage?type=depth&keyword=%E6%96%B0%E5%B8%8C%E6%9C%9B"
+	waitVisible := ".search-telegraph-list,.subject-interest-list"
+
+	//url = "https://gushitong.baidu.com/stock/ab-600745"
+	//waitVisible = "div.news-item"
+	htmlContent, success := crawlerAPI.GetHtml(url, waitVisible, true)
+	if success {
+		document, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+		}
+		var messages []string
+		document.Find(waitVisible).Each(func(i int, selection *goquery.Selection) {
+			text := strutil.RemoveNonPrintable(selection.Text())
+			messages = append(messages, text)
+			logger.SugaredLogger.Infof("搜索到消息-%s: %s", "", text)
+		})
+	}
+	//logger.SugaredLogger.Infof("htmlContent:%s", htmlContent)
+}
+
+func TestGetHtmlWithActions(t *testing.T) {
+	crawlerAPI := CrawlerApi{}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, CrawlerBaseInfo{
+		Name:        "百度股市通",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://gushitong.baidu.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	})
+	actions := []chromedp.Action{
+		chromedp.Navigate("https://gushitong.baidu.com/stock/ab-600745"),
+		chromedp.WaitVisible("div.cos-tab"),
+		chromedp.Click(".header div.cos-tab:nth-child(6)", chromedp.ByQuery),
+		chromedp.ScrollIntoView("div.finance-container >div.row:nth-child(3)"),
+		chromedp.WaitVisible("div.cos-tabs-header-container"),
+		chromedp.Click(".page-content .cos-tabs-header-container .cos-tabs-header .cos-tab:nth-child(1)", chromedp.ByQuery),
+		chromedp.WaitVisible(".page-content .finance-container .report-col-content", chromedp.ByQuery),
+		chromedp.Click(".page-content .cos-tabs-header-container .cos-tabs-header .cos-tab:nth-child(4)", chromedp.ByQuery),
+		chromedp.Evaluate(`window.scrollTo(0, document.body.scrollHeight);`, nil),
+		chromedp.Sleep(1 * time.Second),
+	}
+	htmlContent, success := crawlerAPI.GetHtmlWithActions(&actions, false)
+	if success {
+		document, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+		}
+		var messages []string
+		document.Find("div.report-table-list-container,div.report-row").Each(func(i int, selection *goquery.Selection) {
+			text := strutil.RemoveWhiteSpace(selection.Text(), false)
+			messages = append(messages, text)
+			logger.SugaredLogger.Infof("搜索到消息-%s: %s", "", text)
+		})
+		logger.SugaredLogger.Infof("messages:%d", len(messages))
+	}
+	//logger.SugaredLogger.Infof("htmlContent:%s", htmlContent)
+}
+
+func TestHk(t *testing.T) {
+	//https://stock.finance.sina.com.cn/hkstock/quotes/00001.html
+	db.Init("../../data/stock.db")
+	hks := &[]models.StockInfoHK{}
+	db.Dao.Model(&models.StockInfoHK{}).Limit(1).Find(hks)
+
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://stock.finance.sina.com.cn",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+	for _, hk := range *hks {
+		logger.SugaredLogger.Infof("hk: %+v", hk)
+		url := fmt.Sprintf("https://stock.finance.sina.com.cn/hkstock/quotes/%s.html", strings.ReplaceAll(hk.Code, ".HK", ""))
+		htmlContent, ok := crawlerAPI.GetHtml(url, "#stock_cname", true)
+		if !ok {
+			continue
+		}
+		//logger.SugaredLogger.Infof("htmlContent: %s", htmlContent)
+		document, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+		}
+		document.Find("#stock_cname").Each(func(i int, selection *goquery.Selection) {
+			text := strutil.RemoveNonPrintable(selection.Text())
+			logger.SugaredLogger.Infof("股票名称-:%s", text)
+		})
+
+		document.Find("#mts_stock_hk_price").Each(func(i int, selection *goquery.Selection) {
+			text := strutil.RemoveNonPrintable(selection.Text())
+			logger.SugaredLogger.Infof("股票名称-现价: %s", text)
+		})
+
+		document.Find(".deta_hqContainer >.deta03 li").Each(func(i int, selection *goquery.Selection) {
+			text := strutil.RemoveNonPrintable(selection.Text())
+			logger.SugaredLogger.Infof("股票名称-%s: %s", "", text)
+		})
+
+	}
+}
+
+func TestUpdateUSName(t *testing.T) {
+	db.Init("../../data/stock.db")
+	us := &[]models.StockInfoUS{}
+	db.Dao.Model(&models.StockInfoUS{}).Where("name = ?", "").Order("RANDOM()").Find(us)
+
+	for _, us := range *us {
+		crawlerAPI := CrawlerApi{}
+		crawlerBaseInfo := CrawlerBaseInfo{
+			Name:        "TestCrawler",
+			Description: "Test Crawler Description",
+			BaseUrl:     "https://stock.finance.sina.com.cn",
+			Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+		url := fmt.Sprintf("https://stock.finance.sina.com.cn/usstock/quotes/%s.html", us.Code[:len(us.Code)-3])
+		logger.SugaredLogger.Infof("url: %s", url)
+		//waitVisible := "span.quote_title_name"
+		waitVisible := "div.hq_title > h1"
+
+		htmlContent, ok := crawlerAPI.GetHtml(url, waitVisible, true)
+
+		if !ok {
+			continue
+		}
+		//logger.SugaredLogger.Infof("htmlContent: %s", htmlContent)
+		document, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+		}
+		name := ""
+		document.Find(waitVisible).Each(func(i int, selection *goquery.Selection) {
+			name = strutil.RemoveNonPrintable(selection.Text())
+			name = strutil.SplitAndTrim(name, " ", "")[0]
+			logger.SugaredLogger.Infof("股票名称-:%s", name)
+		})
+		db.Dao.Model(&models.StockInfoUS{}).Where("code = ?", us.Code).Updates(map[string]interface{}{
+			"name":      name,
+			"full_name": name,
+		})
+	}
+
+}
+func TestUS(t *testing.T) {
+	db.Init("../../data/stock.db")
+	bytes, err := os.ReadFile("../../build/us.json")
+	if err != nil {
+		return
+	}
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://quote.eastmoney.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+	tick := &Tick{}
+	json.Unmarshal(bytes, &tick)
+	for i, datum := range tick.Data {
+		logger.SugaredLogger.Infof("datum: %d, %+v", i, datum)
+		name := ""
+
+		//https://quote.eastmoney.com/us/AAPL.html
+		//https://stock.finance.sina.com.cn/usstock/quotes/goog.html
+		//url := fmt.Sprintf("https://stock.finance.sina.com.cn/usstock/quotes/%s.html", strings.ReplaceAll(datum.C, ".US", ""))
+		////waitVisible := "span.quote_title_name"
+		//waitVisible := "div.hq_title > h1"
+		//
+		//htmlContent, ok := crawlerAPI.GetHtml(url, waitVisible, true)
+		//
+		//if !ok {
+		//	continue
+		//}
+		////logger.SugaredLogger.Infof("htmlContent: %s", htmlContent)
+		//document, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+		//if err != nil {
+		//	logger.SugaredLogger.Error(err.Error())
+		//}
+		//document.Find(waitVisible).Each(func(i int, selection *goquery.Selection) {
+		//	name = strutil.RemoveNonPrintable(selection.Text())
+		//	name = strutil.SplitAndTrim(name, " ", "")[0]
+		//	logger.SugaredLogger.Infof("股票名称-:%s", name)
+		//})
+
+		us := &models.StockInfoUS{
+			Code:     datum.C + ".US",
+			EName:    datum.N,
+			FullName: datum.N,
+			Name:     name,
+			Exchange: datum.E,
+			Type:     datum.T,
+		}
+		db.Dao.Create(us)
+	}
+}
+
+func TestUSSINA(t *testing.T) {
+	//https://finance.sina.com.cn/stock/usstock/sector.shtml#cm
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://quote.eastmoney.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+	html, ok := crawlerAPI.GetHtml("https://finance.sina.com.cn/stock/usstock/sector.shtml#cm", "div#data", false)
+	if !ok {
+		return
+	}
+	document, err := goquery.NewDocumentFromReader(strings.NewReader(html))
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+	}
+	document.Find("div#data > table >tbody >tr").Each(func(i int, selection *goquery.Selection) {
+		tr := selection.Text()
+		logger.SugaredLogger.Infof("tr: %s", tr)
+	})
+}
+
+func TestSina(t *testing.T) {
+	db.Init("../../data/stock.db")
+	url := "https://finance.sina.com.cn/realstock/company/sz002906/nc.shtml"
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://finance.sina.com.cn",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+	html, ok := crawlerAPI.GetHtml(url, "div#hqDetails table", true)
+	if !ok {
+		return
+	}
+	document, err := goquery.NewDocumentFromReader(strings.NewReader(html))
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+	}
+
+	//price
+	price := strutil.RemoveWhiteSpace(document.Find("div#price").First().Text(), false)
+	hqTime := strutil.RemoveWhiteSpace(document.Find("div#hqTime").First().Text(), false)
+
+	var markdown strings.Builder
+	markdown.WriteString("\n ## 当前股票数据：\n")
+	markdown.WriteString(fmt.Sprintf("### 当前股价：%s 时间：%s\n", price, hqTime))
+	GetTableMarkdown(document, "div#hqDetails table", &markdown)
+
+}
+
+func TestDC(t *testing.T) {
+	url := "https://emweb.securities.eastmoney.com/pc_hsf10/pages/index.html?type=web&code=sh600745#/cwfx"
+	db.Init("../../data/stock.db")
+	crawlerAPI := CrawlerApi{}
+	crawlerBaseInfo := CrawlerBaseInfo{
+		Name:        "TestCrawler",
+		Description: "Test Crawler Description",
+		BaseUrl:     "https://emweb.securities.eastmoney.com",
+		Headers:     map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0"},
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)
+	defer cancel()
+	crawlerAPI = crawlerAPI.NewCrawler(ctx, crawlerBaseInfo)
+
+	var markdown strings.Builder
+	markdown.WriteString("\n ## 财务数据：\n")
+	html, ok := crawlerAPI.GetHtml(url, "div.report_table table", false)
+	if !ok {
+		return
+	}
+	document, err := goquery.NewDocumentFromReader(strings.NewReader(html))
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+	}
+	GetTableMarkdown(document, "div.report_table table", &markdown)
+
+}
+
+type Tick struct {
+	Code   int    `json:"code"`
+	Status string `json:"status"`
+	Data   []struct {
+		C string `json:"c"`
+		N string `json:"n"`
+		T string `json:"t"`
+		E string `json:"e"`
+	} `json:"data"`
+}

backend/data/data/dict/README.md

@@ -0,0 +1 @@
+Some dict/zh data is from [github.com/fxsjy/jieba](https://github.com/fxsjy/jieba)

backend/data/data/dict/base.txt

@@ -0,0 +1,428 @@
+# 金融股票全场景分词字典（最终去重优化版）
+# 格式：单词 权重 词性 | 权重280-350分，核心术语优先匹配，无重复词汇
+
+# 一、净买卖与资金流向（核心交易表述）
+净卖出 340 v
+净买入 340 v
+净卖出额 330 n
+净买入额 330 n
+净卖出量 330 n
+净买入量 330 n
+资金净流出 340 n
+资金净流入 340 n
+净额 330 n
+买卖净额 330 n
+资金净额 330 n
+北向资金净买入 330 n
+北向资金净卖出 330 n
+南向资金净买入 320 n
+南向资金净卖出 320 n
+主力资金净买入 330 n
+主力资金净卖出 330 n
+散户资金净买入 320 n
+散户资金净卖出 320 n
+机构资金净买入 330 n
+机构资金净卖出 330 n
+游资净买入 320 n
+游资净卖出 320 n
+大单净买入 320 n
+大单净卖出 320 n
+中单净买入 320 n
+中单净卖出 320 n
+小单净买入 320 n
+小单净卖出 320 n
+净买入占比 320 n
+净卖出占比 320 n
+净买入率 320 n
+净卖出率 320 n
+连续净买入 320 v
+连续净卖出 320 v
+单日净买入 320 n
+单日净卖出 320 n
+累计净买入 320 n
+累计净卖出 320 n
+净买入创纪录 310 adj
+净卖出创纪录 310 adj
+净买入放量 310 v
+净卖出放量 310 v
+净买入缩量 310 v
+净卖出缩量 310 v
+净多 310 n
+净空 310 n
+净多头 310 n
+净空头 310 n
+净多头头寸 310 n
+净空头头寸 310 n
+跌超 310 n
+跌逾 310 n
+
+# 二、金融资讯与市场分析
+金融资讯 350 n
+市场快讯 340 n
+财经新闻 340 n
+政策解读 330 n
+市场分析 330 n
+行业研报 320 n
+宏观经济 330 n
+微观层面 310 n
+基本面 320 n
+技术面 320 n
+资金面 320 n
+政策面 320 n
+市场情绪 320 n
+风险偏好 310 n
+流动性 320 n
+估值修复 310 n
+价值投资 310 n
+趋势投资 310 n
+波段操作 310 n
+左侧交易 290 n
+右侧交易 290 n
+止损止盈 300 n
+仓位管理 300 n
+资产配置 310 n
+分散投资 290 n
+集中投资 290 n
+风险控制 310 n
+系统性风险 300 n
+非系统性风险 290 n
+黑天鹅事件 310 n
+灰犀牛事件 300 n
+熔断机制 300 n
+市场监管 310 n
+信息披露 310 n
+内幕交易 300 n
+操纵市场 300 n
+亏损 100 n
+加工 100 n
+
+# 三、全球主要股指（含中英文缩写）
+# 中国市场
+A股 350 n
+港股 350 n
+上证指数 350 n
+深证成指 350 n
+创业板指 340 n
+科创板指 330 n
+北证50 330 n
+沪深300 350 n
+沪深300指数 350 n
+中证500 340 n
+中证500指数 340 n
+中证1000 330 n
+中证1000指数 330 n
+上证50 340 n
+上证50指数 340 n
+科创50 330 n
+科创50指数 330 n
+上证综指 350 n
+富时中国A50指数 340 n
+恒生指数 340 n
+恒生科技指数 340 n
+恒生国企指数 330 n
+H股指数 330 n
+# 美洲市场
+道琼斯工业平均指数 350 n
+标普500指数 350 n
+纳斯达克综合指数 340 n
+纳斯达克100指数 340 n
+罗素2000指数 320 n
+标普400中型股指数 310 n
+标普600小型股指数 310 n
+纽约证交所综合指数 310 n
+纳斯达克中国金龙指数 310 n
+# 欧洲市场
+德国DAX指数 330 n
+法国CAC40指数 330 n
+富时100指数 330 n
+欧元斯托克50指数 320 n
+英国富时250指数 310 n
+意大利富时MIB指数 310 n
+西班牙IBEX 35指数 310 n
+# 亚太其他市场
+日经225指数 330 n
+日经500指数 310 n
+韩国综合股价指数 320 n
+韩国kospi指数 320 n
+KOSPI 310 n
+澳洲标普200指数 310 n
+印度孟买敏感指数 310 n
+Sensex 300 n
+印度Nifty 50指数 310 n
+# 全球综合指数
+MSCI指数 320 n
+MSCI全球指数 330 n
+MSCI新兴市场指数 330 n
+富时罗素全球指数 320 n
+摩根大通全球债券指数 310 n
+全球股指 300 n
+发达市场指数 300 n
+新兴市场指数 300 n
+金砖国家指数 300 n
+G20国家指数 300 n
+# 股指衍生工具
+指数期货 320 n
+股指期货 320 n
+富时中国A50指数期货 320 n
+沪深300股指期货 320 n
+标普500股指期货 320 n
+纳斯达克100股指期货 310 n
+指数成分股 320 n
+指数权重股 320 n
+指数涨幅 320 n
+指数跌幅 320 n
+指数反弹 310 n
+指数回调 310 n
+指数创新高 310 v
+指数创新低 310 v
+指数估值 310 n
+指数市盈率 310 n
+
+# 四、财务与估值核心指标
+市盈率 350 n
+PE 350 n
+动态市盈率 340 n
+静态市盈率 340 n
+滚动市盈率 340 n
+市净率 350 n
+PB 350 n
+市销率 330 n
+PS 330 n
+市现率 320 n
+PCF 320 n
+净资产收益率 350 n
+ROE 350 n
+总资产收益率 330 n
+ROA 330 n
+毛利率 340 n
+净利率 340 n
+销售净利率 330 n
+资产负债率 340 n
+营收 340 n
+营业收入 340 n
+净利润 350 n
+归母净利润 340 n
+扣非净利润 340 n
+EPS 330 n
+每股收益 330 n
+现金流 340 n
+经营活动现金流 330 n
+自由现金流 330 n
+营收增长率 330 n
+净利润增长率 330 n
+股息率 320 n
+分红率 320 n
+换手率 330 n
+成交量 340 n
+成交额 340 n
+量比 320 n
+振幅 320 n
+
+# 五、政策与宏观经济
+货币政策 330 n
+财政政策 330 n
+稳健货币政策 320 n
+积极财政政策 320 n
+宽松政策 320 n
+紧缩政策 320 n
+利率 330 n
+基准利率 320 n
+LPR 330 n
+贷款市场报价利率 320 n
+存款准备金率 320 n
+MLF 320 n
+中期借贷便利 310 n
+逆回购 320 n
+正回购 310 n
+汇率 330 n
+人民币汇率 330 n
+美元汇率 320 n
+通胀 320 n
+CPI 330 n
+PPI 330 n
+GDP 330 n
+国内生产总值 320 n
+PMI 330 n
+采购经理人指数 320 n
+行业政策 320 n
+产业政策 320 n
+税收政策 310 n
+补贴政策 310 n
+关税 310 n
+贸易政策 310 n
+地缘政治 310 n
+大宗商品 320 n
+原油价格 310 n
+黄金价格 310 n
+有色金属价格 300 n
+
+# 六、金融产品与机构
+股票 320 n
+基金 320 n
+公募基金 310 n
+私募基金 310 n
+ETF 320 n
+指数基金 310 n
+混合型基金 300 n
+股票型基金 310 n
+债券型基金 300 n
+货币基金 290 n
+REITs 310 n
+可转债 310 n
+可交换债 300 n
+期货 310 n
+股指期货 310 n
+国债期货 300 n
+商品期货 300 n
+期权 300 n
+融资融券 310 n
+两融余额 300 n
+北向资金 320 n
+南向资金 310 n
+沪股通 310 n
+深股通 310 n
+陆股通 310 n
+证券公司 310 n
+券商 320 n
+基金公司 300 n
+保险公司 300 n
+银行 310 n
+监管机构 310 n
+证监会 320 n
+交易所 320 n
+上交所 320 n
+深交所 320 n
+北交所 310 n
+港交所 310 n
+社保基金 310 n
+养老金 300 n
+QFII 300 n
+RQFII 290 n
+北向资金机构 300 n
+
+# 七、热点概念与行业
+AI 330 n
+人工智能 350 n
+算力 330 n
+大数据 320 n
+云计算 320 n
+半导体 350 n
+芯片 350 n
+集成电路 340 n
+新能源 350 n
+光伏 340 n
+锂电 320 n
+储能 340 n
+充电桩 310 n
+新能源车 320 n
+智能汽车 310 n
+自动驾驶 330 n
+军工 310 n
+国防军工 300 n
+医药 310 n
+创新药 310 n
+医疗器械 300 n
+CXO 300 n
+白酒 310 n
+消费 320 n
+可选消费 300 n
+必选消费 300 n
+食品饮料 310 n
+家电 300 n
+地产 300 n
+房地产 300 n
+基建 300 n
+新基建 310 n
+数字经济 350 n
+数字货币 310 n
+区块链 300 n
+元宇宙 300 n
+低空经济 340 n
+人形机器人 330 n
+工业互联网 330 n
+物联网 300 n
+5G 300 n
+6G 340 n
+
+# 八、交易操作与行情
+上涨 310 v
+下跌 310 v
+涨停 310 v
+跌停 310 v
+反弹 300 v
+反转 300 v
+回调 300 v
+横盘 290 v
+震荡 290 v
+跳水 300 v
+拉升 300 v
+砸盘 300 v
+护盘 290 v
+建仓 300 v
+加仓 300 v
+减仓 300 v
+清仓 300 v
+平仓 300 v
+抄底 300 v
+逃顶 300 v
+追涨 290 v
+杀跌 290 v
+套牢 280 v
+解套 280 v
+净流入 300 n
+净流出 300 n
+主力资金 300 n
+资金流入 290 v
+资金流出 290 v
+放量 290 v
+缩量 290 v
+高换手 290 n
+低换手 280 n
+高估值 290 n
+低估值 290 n
+超预期 300 v
+不及预期 300 v
+符合预期 290 v
+利好 310 n
+利空 310 n
+政策利好 310 n
+业绩利好 310 n
+风险警示 300 n
+涨停板 300 n
+跌停板 300 n
+一字涨停 290 n
+一字跌停 290 n
+打开涨停 320 v
+打开跌停 320 v
+集合竞价 290 n
+连续竞价 280 n
+开盘价 340 n
+收盘价 340 n
+最高价 330 n
+最低价 330 n
+均价 330 n
+昨日收盘价 320 n
+涨跌额 330 n
+涨跌幅 340 n
+涨幅 340 n
+跌幅 340 n
+涨停价 330 n
+跌停价 330 n
+熔断 330 n
+临时停牌 320 n
+复牌 320 v
+停牌 320 n
+量价齐升 320 n
+量价背离 320 n
+高开 320 n
+低开 320 n
+平开 320 n
+高走 320 v
+低走 320 v
+震荡上行 320 v
+震荡下行 320 v
+
+# 九、委托交易与规则
+限价委托 340 n
+市价委托 340 n
+止损委托 330 n

backend/data/data/dict/jp/README.md

@@ -0,0 +1 @@
+dict.txt 通过内部工具生成, Copyright 2017 ego authors. 商用和拷贝请注明来源和版权

backend/data/data/dict/user.txt

@@ -0,0 +1,185 @@
+# 补充：热点概念与板块（Jieba/gse兼容格式）
+# 权重说明：核心热点500-700分，事件类400分，负权重词汇按需求保留
+
+# 一、负权重低优先级词汇（减少无差别匹配干扰）
+公司 -0.1 n
+国家 -0.1 n
+国际 -0.1 n
+会议 -0.1 n
+市场 -0.1 n
+经济 -0.1 n
+技术 -0.1 n
+记者 -0.1 n
+时间 -0.1 n
+项目 -0.1 n
+问题 -0.1 n
+企业 -0.1 n
+财联社 -0.1 n
+上涨 -0.1 v
+下跌 -0.1 v
+期货 -0.1 n
+跌幅 -0.1 n
+跌超 -0.1 adj
+股票 -0.1 n
+基金 -0.1 n
+电讯 -0.1 n
+建筑 -0.1 n
+平开 -0.1 n
+保险 -0.1 n
+行业 -0.1 n
+其他 -0.1 n
+
+# 二、核心热点概念（700分，最高优先级）
+比特币 700 n
+摩尔线程 700 n
+摩尔线程概念 700 n
+AI算力 700 n
+生成式AI 700 n
+量子计算 700 n
+脑机接口 700 n
+6G通信 700 n
+人形机器人 700 n
+固态电池 700 n
+ChatGPT概念 700 n
+Web3.0 700 n
+元宇宙 700 n
+数字孪生 700 n
+量子通信 700 n
+
+# 三、重点赛道板块（500分，高优先级）
+冰雪旅游 500 n
+特高压 500 n
+跨境电商 500 n
+新能源汽车 500 n
+机器人 500 n
+具身智能 500 n
+油气 500 n
+商业航天 500 n
+光伏储能 500 n
+锂电材料 500 n
+半导体设备 500 n
+集成电路 500 n
+创新药 500 n
+CXO 500 n
+医疗器械 500 n
+数字经济 500 n
+数字货币 500 n
+区块链 500 n
+低空经济 500 n
+工业互联网 500 n
+物联网 500 n
+5G应用 500 n
+充电桩 500 n
+氢能源 500 n
+核聚变 500 n
+工业母机 500 n
+新材料 500 n
+生物制造 500 n
+智能网联汽车 500 n
+乡村振兴 500 n
+国企改革 500 n
+央企重组 500 n
+跨境金融 500 n
+自贸港 500 n
+一带一路 500 n
+绿色低碳 500 n
+碳交易 500 n
+数据要素 500 n
+数字基建 500 n
+东数西算 500 n
+国产替代 500 n
+信创 500 n
+网络安全 500 n
+算力网络 500 n
+边缘计算 500 n
+虚拟现实 500 n
+增强现实 500 n
+智能穿戴 500 n
+智能家居 500 n
+车联网 500 n
+激光雷达 500 n
+氮化镓 500 n
+碳化硅 500 n
+第三代半导体 500 n
+EDA工具 500 n
+光刻胶 500 n
+芯片设计 500 n
+封装测试 500 n
+储能电池 500 n
+钠离子电池 500 n
+氢燃料电池 500 n
+光伏组件 500 n
+风电设备 500 n
+特高压设备 500 n
+电力物联网 500 n
+智能电网 500 n
+轨道交通 500 n
+航空航天 500 n
+海洋工程 500 n
+高端装备 500 n
+军工电子 500 n
+卫星互联网 500 n
+北斗导航 500 n
+国产大飞机 500 n
+生物医药 500 n
+基因测序 500 n
+疫苗 500 n
+医疗美容 500 n
+养老产业 500 n
+教育信息化 500 n
+体育产业 500 n
+文化创意 500 n
+旅游复苏 500 n
+预制菜 500 n
+白酒 500 n
+食品饮料 500 n
+家电下乡 500 n
+房地产复苏 500 n
+基建投资 500 n
+新型城镇化 500 n
+冷链物流 500 n
+快递物流 500 n
+跨境支付 500 n
+金融科技 500 n
+消费电子 500 n
+元宇宙基建 500 n
+数字藏品 500 n
+NFT 500 n
+绿色电力 500 n
+节能降碳 500 n
+抽水蓄能 500 n
+生物质能 500 n
+地热能 500 n
+潮汐能 500 n
+
+# 四、事件驱动型概念（400分，中优先级）
+俄乌冲突 400 n
+中东局势 400 n
+美联储加息 400 n
+降息预期 400 n
+贸易摩擦 400 n
+供应链重构 400 n
+能源危机 400 n
+粮食安全 400 n
+疫情复苏 400 n
+政策利好 400 n
+产业扶持 400 n
+技术突破 400 n
+并购重组 400 n
+IPO提速 400 n
+解禁潮 400 n
+北向资金流入 400 n
+南向资金流入 400 n
+主力资金异动 400 n
+行业景气度 400 n
+业绩预增 400 n
+商誉减值 400 n
+退市风险 400 n
+监管新规 400 n
+税收优惠 400 n
+补贴政策 400 n
+基建刺激 400 n
+消费刺激 400 n
+新能源补贴 400 n
+碳达峰政策 400 n
+碳中和目标 400 n

backend/data/data/dict/zh/stop_word.txt

@@ -0,0 +1,88 @@
+,
+.
+?
+!
+"
+@
+，
+。
+、
+？
+！
+：
+“
+”
+；
+　
+（
+）
+《
+》
+~
+*
+<
+>
+/
+\
+|
+-
+_
++
+=
+&
+^
+%
+#
+`
+;
+$
+￥
+‘
+’
+〉
+〈
+…
+＞
+＜
+＠
+＃
+＄
+％
+︿
+＆
+＊
+＋
+～
+｜
+［
+］
+｛
+｝
+啊
+阿
+哎
+哎呀
+哎哟
+唉
+俺
+俺们
+按
+按照
+吧
+吧哒
+把
+罢了
+被
+本
+本着
+比
+比方
+比如
+鄙人
+彼
+彼此
+边
+别
+别的
+别说
+并

backend/data/dingding_api.go

@@ -10,8 +10,6 @@ import (
 // @Desc
 //-----------------------------------------------------------------------------------
 
-const dingding_robot_url = "https://oapi.dingtalk.com/robot/send?access_token=0237527b404598f37ae5d83ef36e936860c7ba5d3892cd43f64c4159d3ed7cb1"
-
 type DingDingAPI struct {
 	client *resty.Client
 }
@@ -23,11 +21,15 @@ func NewDingDingAPI() *DingDingAPI {
 }
 
 func (DingDingAPI) SendDingDingMessage(message string) string {
+	if GetSettingConfig().DingPushEnable == false {
+		//logger.SugaredLogger.Info("钉钉推送未开启")
+		return "钉钉推送未开启"
+	}
 	// 发送钉钉消息
 	resp, err := resty.New().R().
 		SetHeader("Content-Type", "application/json").
 		SetBody(message).
-		Post(dingding_robot_url)
+		Post(getApiURL())
 	if err != nil {
 		logger.SugaredLogger.Error(err.Error())
 		return "发送钉钉消息失败"
@@ -36,6 +38,10 @@ func (DingDingAPI) SendDingDingMessage(message string) string {
 	return "发送钉钉消息成功"
 }
 
+func getApiURL() string {
+	return GetSettingConfig().DingRobot
+}
+
 func (DingDingAPI) SendToDingDing(title, message string) string {
 	// 发送钉钉消息
 	resp, err := resty.New().R().
@@ -50,7 +56,7 @@ func (DingDingAPI) SendToDingDing(title, message string) string {
 				IsAtAll: true,
 			},
 		}).
-		Post(dingding_robot_url)
+		Post(getApiURL())
 	if err != nil {
 		logger.SugaredLogger.Error(err.Error())
 		return "发送钉钉消息失败"

backend/data/dingding_api_test.go

@@ -11,6 +11,7 @@ import (
 //-----------------------------------------------------------------------------------
 
 func TestRobot(t *testing.T) {
+	dingdingRobotUrl := "XXX"
 	resp, err := resty.New().R().
 		SetHeader("Content-Type", "application/json").
 		SetBody(`{
@@ -23,7 +24,7 @@ func TestRobot(t *testing.T) {
 			"isAtAll": true
 		  }
 		}`).
-		Post(dingding_robot_url)
+		Post(dingdingRobotUrl)
 	if err != nil {
 		t.Error(err)
 	}

backend/data/fund_data_api.go

@@ -0,0 +1,401 @@
+package data
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/go-resty/resty/v2"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/PuerkitoBio/goquery"
+	"gorm.io/gorm"
+)
+
+type FundApi struct {
+	client *resty.Client
+	config *SettingConfig
+}
+
+func NewFundApi() *FundApi {
+	return &FundApi{
+		client: resty.New(),
+		config: GetSettingConfig(),
+	}
+}
+
+type FollowedFund struct {
+	gorm.Model
+	Code string `json:"code" gorm:"index"` // 基金代码
+	Name string `json:"name"`              // 基金简称
+
+	NetUnitValue     *float64 `json:"netUnitValue"`         // 单位净值
+	NetUnitValueDate string   `json:"netUnitValueDate"`     // 单位净值日期
+	NetEstimatedUnit *float64 `json:"netEstimatedUnit"`     // 估算单位净值
+	NetEstimatedTime string   `json:"netEstimatedUnitTime"` // 估算单位净值日期
+	NetAccumulated   *float64 `json:"netAccumulated"`       // 累计净值
+
+	//计算值
+	NetEstimatedRate *float64 `json:"netEstimatedRate"` // 估算单位净值涨跌幅
+
+	FundBasic FundBasic `json:"fundBasic" gorm:"foreignKey:Code;references:Code"`
+}
+
+func (FollowedFund) TableName() string {
+	return "followed_fund"
+}
+
+// FundBasic 基金基本信息结构体
+type FundBasic struct {
+	gorm.Model
+	Code           string `json:"code" gorm:"index"` // 基金代码
+	Name           string `json:"name"`              // 基金简称
+	FullName       string `json:"fullName"`          // 基金全称
+	Type           string `json:"type"`              // 基金类型
+	Establishment  string `json:"establishment"`     // 成立日期
+	Scale          string `json:"scale"`             // 最新规模(亿元)
+	Company        string `json:"company"`           // 基金管理人
+	Manager        string `json:"manager"`           // 基金经理
+	Rating         string `json:"rating"`            //基金评级
+	TrackingTarget string `json:"trackingTarget"`    //跟踪标的
+
+	NetUnitValue     *float64 `json:"netUnitValue"`         // 单位净值
+	NetUnitValueDate string   `json:"netUnitValueDate"`     // 单位净值日期
+	NetEstimatedUnit *float64 `json:"netEstimatedUnit"`     // 估算单位净值
+	NetEstimatedTime string   `json:"netEstimatedUnitTime"` // 估算单位净值日期
+	NetAccumulated   *float64 `json:"netAccumulated"`       // 累计净值
+
+	//净值涨跌幅： 近1月,近3月,近6月,近1年,近3年,近5年,今年来,成立来
+	NetGrowth1   *float64 `json:"netGrowth1"`   //近1月
+	NetGrowth3   *float64 `json:"netGrowth3"`   //近3月
+	NetGrowth6   *float64 `json:"netGrowth6"`   //近6月
+	NetGrowth12  *float64 `json:"netGrowth12"`  //近1年
+	NetGrowth36  *float64 `json:"netGrowth36"`  //近3年
+	NetGrowth60  *float64 `json:"netGrowth60"`  //近5年
+	NetGrowthYTD *float64 `json:"netGrowthYTD"` //今年来
+	NetGrowthAll *float64 `json:"netGrowthAll"` //成立来
+}
+
+func (FundBasic) TableName() string {
+	return "fund_basic"
+}
+
+// CrawlFundBasic 爬取基金基本信息
+func (f *FundApi) CrawlFundBasic(fundCode string) (*FundBasic, error) {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.SugaredLogger.Errorf("CrawlFundBasic panic: %v", r)
+		}
+	}()
+
+	crawler := CrawlerApi{
+		crawlerBaseInfo: CrawlerBaseInfo{
+			Name:    "天天基金",
+			BaseUrl: "http://fund.eastmoney.com",
+			Headers: map[string]string{"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"},
+		},
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(f.config.CrawlTimeOut)*time.Second)
+	defer cancel()
+
+	crawler = crawler.NewCrawler(ctx, crawler.crawlerBaseInfo)
+	url := fmt.Sprintf("%s/%s.html", crawler.crawlerBaseInfo.BaseUrl, fundCode)
+	//logger.SugaredLogger.Infof("CrawlFundBasic url:%s", url)
+
+	// 使用现有爬虫框架解析页面
+	htmlContent, ok := crawler.GetHtml(url, ".merchandiseDetail", true)
+	if !ok {
+		return nil, fmt.Errorf("页面解析失败")
+	}
+
+	fund := &FundBasic{Code: fundCode}
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+	if err != nil {
+		return nil, err
+	}
+
+	// 解析基础信息
+	name := doc.Find(".merchandiseDetail .fundDetail-tit").First().Text()
+	fund.Name = strings.TrimSpace(strutil.ReplaceWithMap(name, map[string]string{"查看相关ETF>": ""}))
+	//logger.SugaredLogger.Infof("基金名称:%s", fund.Name)
+
+	doc.Find(".infoOfFund table td ").Each(func(i int, s *goquery.Selection) {
+		text := strutil.RemoveWhiteSpace(s.Text(), true)
+		//logger.SugaredLogger.Infof("基金信息:%+v", text)
+		defer func() {
+			if r := recover(); r != nil {
+				//logger.SugaredLogger.Errorf("panic: %v", r)
+			}
+		}()
+		splitEx := strutil.SplitEx(text, "：", true)
+		if strutil.ContainsAny(text, []string{"基金类型", "类型"}) {
+			fund.Type = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"成立日期", "成立日"}) {
+			fund.Establishment = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"基金规模", "规模"}) {
+			fund.Scale = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"管理人", "基金公司"}) {
+			fund.Company = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"基金经理", "经理人"}) {
+			fund.Manager = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"基金评级", "评级"}) {
+			fund.Rating = splitEx[1]
+		}
+		if strutil.ContainsAny(text, []string{"跟踪标的", "标的"}) {
+			fund.TrackingTarget = splitEx[1]
+		}
+	})
+
+	//获取基金净值涨跌幅信息
+	doc.Find(".dataOfFund dl > dd").Each(func(i int, s *goquery.Selection) {
+		text := strutil.RemoveWhiteSpace(s.Text(), true)
+		//logger.SugaredLogger.Infof("净值涨跌幅信息:%+v", text)
+		defer func() {
+			if r := recover(); r != nil {
+				//logger.SugaredLogger.Errorf("panic: %v", r)
+			}
+		}()
+		splitEx := strutil.SplitAndTrim(text, "：", "%")
+		toFloat, err1 := convertor.ToFloat(splitEx[1])
+		if err1 != nil {
+			//logger.SugaredLogger.Errorf("转换失败:%+v", err)
+			return
+		}
+		//logger.SugaredLogger.Infof("净值涨跌幅信息:%+v", toFloat)
+		if strutil.ContainsAny(text, []string{"近1月"}) {
+			fund.NetGrowth1 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"近3月"}) {
+			fund.NetGrowth3 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"近6月"}) {
+			fund.NetGrowth6 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"近1年"}) {
+			fund.NetGrowth12 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"近3年"}) {
+			fund.NetGrowth36 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"近5年"}) {
+			fund.NetGrowth60 = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"今年来"}) {
+			fund.NetGrowthYTD = &toFloat
+		}
+		if strutil.ContainsAny(text, []string{"成立来"}) {
+			fund.NetGrowthAll = &toFloat
+		}
+	})
+	//doc.Find(".dataOfFund dl > dd.dataNums,.dataOfFund dl > dt").Each(func(i int, s *goquery.Selection) {
+	//	//text := s.Text()
+	//	defer func() {
+	//		if r := recover(); r != nil {
+	//			//logger.SugaredLogger.Errorf("panic: %v", r)
+	//		}
+	//	}()
+	//	//logger.SugaredLogger.Infof("净值信息:%+v", text)
+	//})
+
+	//logger.SugaredLogger.Infof("基金信息:%+v", fund)
+
+	count := int64(0)
+	db.Dao.Model(fund).Where("code=?", fund.Code).Count(&count)
+	if count == 0 {
+		db.Dao.Create(fund)
+	} else {
+		db.Dao.Model(fund).Where("code=?", fund.Code).Updates(fund)
+	}
+
+	return fund, nil
+}
+
+func (f *FundApi) GetFundList(key string) []FundBasic {
+	var funds []FundBasic
+	db.Dao.Where("code like ? or name like ?", "%"+key+"%", "%"+key+"%").Limit(10).Find(&funds)
+	return funds
+}
+
+func (f *FundApi) GetFollowedFund() []FollowedFund {
+	var funds []FollowedFund
+	db.Dao.Preload("FundBasic").Find(&funds)
+	for i, fund := range funds {
+		if fund.NetUnitValue != nil && fund.NetEstimatedUnit != nil && *fund.NetUnitValue > 0 {
+			netEstimatedRate := (*(funds[i].NetEstimatedUnit) - *(funds[i].NetUnitValue)) / *(fund.NetUnitValue) * 100
+			netEstimatedRate = mathutil.RoundToFloat(netEstimatedRate, 2)
+			funds[i].NetEstimatedRate = &netEstimatedRate
+		}
+
+	}
+	return funds
+}
+func (f *FundApi) FollowFund(fundCode string) string {
+	var fund FundBasic
+	db.Dao.Where("code=?", fundCode).First(&fund)
+	if fund.Code != "" {
+		follow := &FollowedFund{
+			Code: fundCode,
+			Name: fund.Name,
+		}
+		err := db.Dao.Model(follow).Where("code = ?", fundCode).FirstOrCreate(follow, "code", fund.Code).Error
+		if err != nil {
+			return "关注失败"
+		}
+		return "关注成功"
+	} else {
+		return "基金信息不存在"
+	}
+}
+func (f *FundApi) UnFollowFund(fundCode string) string {
+	var fund FollowedFund
+	db.Dao.Where("code=?", fundCode).First(&fund)
+	if fund.Code != "" {
+		err := db.Dao.Model(&fund).Delete(&fund).Error
+		if err != nil {
+			return "取消关注失败"
+		}
+		return "取消关注成功"
+	} else {
+		return "基金信息不存在"
+	}
+}
+
+func (f *FundApi) AllFund() {
+	defer func() {
+		if r := recover(); r != nil {
+			//logger.SugaredLogger.Errorf("AllFund panic: %v", r)
+		}
+	}()
+
+	response, err := f.client.SetTimeout(time.Duration(f.config.CrawlTimeOut)*time.Second).R().
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36").
+		Get("https://fund.eastmoney.com/allfund.html")
+	if err != nil {
+		return
+	}
+	//中文编码
+	htmlContent := GB18030ToUTF8(response.Body())
+
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(htmlContent))
+	cnt := 0
+	doc.Find("ul.num_right li").Each(func(i int, s *goquery.Selection) {
+		text := strutil.SplitEx(s.Text(), "|", true)
+		if len(text) > 0 {
+			cnt++
+			name := text[0]
+			str := strutil.SplitAndTrim(name, "）", "（", "）")
+			//logger.SugaredLogger.Infof("%d,基金信息 code:%s,name:%s", cnt, str[0], str[1])
+			//go f.CrawlFundBasic(str[0])
+			fund := &FundBasic{
+				Code: str[0],
+				Name: str[1],
+			}
+			count := int64(0)
+			db.Dao.Model(fund).Where("code=?", fund.Code).Count(&count)
+			if count == 0 {
+				db.Dao.Create(fund)
+			}
+
+		}
+	})
+
+}
+
+type FundNetUnitValue struct {
+	Fundcode string `json:"fundcode"`
+	Name     string `json:"name"`
+	Jzrq     string `json:"jzrq"`
+	Dwjz     string `json:"dwjz"`
+	Gsz      string `json:"gsz"`
+	Gszzl    string `json:"gszzl"`
+	Gztime   string `json:"gztime"`
+}
+
+// CrawlFundNetEstimatedUnit 爬取净值估算值
+func (f *FundApi) CrawlFundNetEstimatedUnit(code string) {
+	var fundNetUnitValue FundNetUnitValue
+	response, err := f.client.SetTimeout(time.Duration(f.config.CrawlTimeOut)*time.Second).R().
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36").
+		SetHeader("Referer", "https://fund.eastmoney.com/").
+		SetQueryParams(map[string]string{"rt": strconv.FormatInt(time.Now().UnixMilli(), 10)}).
+		Get(fmt.Sprintf("https://fundgz.1234567.com.cn/js/%s.js", code))
+	if err != nil {
+		logger.SugaredLogger.Errorf("err:%s", err.Error())
+		return
+	}
+	if response.StatusCode() == 200 {
+		htmlContent := string(response.Body())
+		//logger.SugaredLogger.Infof("htmlContent:%s", htmlContent)
+		if strings.Contains(htmlContent, "jsonpgz") {
+			htmlContent = strutil.Trim(htmlContent, "jsonpgz(", ");")
+			htmlContent = strutil.Trim(htmlContent, ");")
+			//logger.SugaredLogger.Infof("基金净值信息:%s", htmlContent)
+			err := json.Unmarshal([]byte(htmlContent), &fundNetUnitValue)
+			if err != nil {
+				//logger.SugaredLogger.Errorf("json.Unmarshal error:%s", err.Error())
+				return
+			}
+			fund := &FollowedFund{
+				Code:             fundNetUnitValue.Fundcode,
+				Name:             fundNetUnitValue.Name,
+				NetEstimatedTime: fundNetUnitValue.Gztime,
+			}
+			netEstimatedUnit, err := convertor.ToFloat(fundNetUnitValue.Gsz)
+			if err == nil {
+				fund.NetEstimatedUnit = &netEstimatedUnit
+			}
+			db.Dao.Model(fund).Where("code=?", fund.Code).Updates(fund)
+		}
+	}
+}
+
+// CrawlFundNetUnitValue 爬取净值
+func (f *FundApi) CrawlFundNetUnitValue(code string) {
+	//	var fundNetUnitValue FundNetUnitValue
+	url := fmt.Sprintf("http://hq.sinajs.cn/rn=%d&list=f_%s", time.Now().UnixMilli(), code)
+	//logger.SugaredLogger.Infof("url:%s", url)
+	response, err := f.client.SetTimeout(time.Duration(f.config.CrawlTimeOut)*time.Second).R().
+		SetHeader("Host", "hq.sinajs.cn").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0").
+		SetHeader("Referer", "https://finance.sina.com.cn").
+		Get(url)
+	if err != nil {
+		logger.SugaredLogger.Errorf("err:%s", err.Error())
+		return
+	}
+	if response.StatusCode() == 200 {
+		data := string(GB18030ToUTF8(response.Body()))
+		//logger.SugaredLogger.Infof("data:%s", data)
+		datas := strutil.SplitAndTrim(data, "=", "\"")
+		if len(datas) >= 2 {
+			//codex := strings.Split(datas[0], "hq_str_f_")[1]
+			parts := strutil.SplitAndTrim(datas[1], ",", "\"")
+			//logger.SugaredLogger.Infof("parts:%s", parts)
+			val, err := convertor.ToFloat(parts[1])
+			if err != nil {
+				logger.SugaredLogger.Errorf("err:%s", err.Error())
+				return
+			}
+			fund := &FollowedFund{
+				Name:             parts[0],
+				Code:             code,
+				NetUnitValue:     &val,
+				NetUnitValueDate: parts[4],
+			}
+			db.Dao.Model(fund).Where("code=?", fund.Code).Updates(fund)
+		}
+
+	}
+}

backend/data/fund_data_api_test.go

@@ -0,0 +1,23 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"testing"
+)
+
+func TestCrawlFundBasic(t *testing.T) {
+	db.Init("../../data/stock.db")
+	db.Dao.AutoMigrate(&FundBasic{})
+	api := NewFundApi()
+
+	//api.CrawlFundBasic("510630")
+	//api.CrawlFundBasic("159688")
+	//
+	api.AllFund()
+}
+
+func TestCrawlFundNetUnitValue(t *testing.T) {
+	db.Init("../../data/stock.db")
+	api := NewFundApi()
+	api.CrawlFundNetUnitValue("016533")
+}

backend/data/market_news_api_test.go

@@ -0,0 +1,296 @@
+package data
+
+import (
+	"encoding/json"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"go-stock/backend/util"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/coocood/freecache"
+	"github.com/duke-git/lancet/v2/random"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/go-resty/resty/v2"
+	"github.com/tidwall/gjson"
+)
+
+// @Author spark
+// @Date 2025/4/23 17:58
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func TestGetSinaNews(t *testing.T) {
+	db.Init("../../data/stock.db")
+	InitAnalyzeSentiment()
+	news := NewMarketNewsApi().GetSinaNews(30)
+	for i, telegraph := range *news {
+		logger.SugaredLogger.Debugf("key: %+v, value: %+v", i, telegraph)
+
+	}
+	//NewMarketNewsApi().GetNewTelegraph(30)
+
+}
+
+func TestGlobalStockIndexes(t *testing.T) {
+	resp := NewMarketNewsApi().GlobalStockIndexes(30)
+	bytes, err := json.Marshal(resp)
+	if err != nil {
+		return
+	}
+	logger.SugaredLogger.Debugf("resp: %+v", string(bytes))
+}
+
+func TestGetIndustryRank(t *testing.T) {
+	res := NewMarketNewsApi().GetIndustryRank("0", 10)
+	for s, a := range res["data"].([]any) {
+		logger.SugaredLogger.Debugf("key: %+v, value: %+v", s, a)
+	}
+}
+func TestGetIndustryMoneyRankSina(t *testing.T) {
+	res := NewMarketNewsApi().GetIndustryMoneyRankSina("0", "netamount")
+	for i, re := range res {
+		logger.SugaredLogger.Debugf("key: %+v, value: %+v", i, re)
+
+	}
+}
+func TestGetMoneyRankSina(t *testing.T) {
+	res := NewMarketNewsApi().GetMoneyRankSina("r3_net")
+	for i, re := range res {
+		logger.SugaredLogger.Debugf("key: %+v, value: %+v", i, re)
+	}
+}
+
+func TestGetStockMoneyTrendByDay(t *testing.T) {
+	res := NewMarketNewsApi().GetStockMoneyTrendByDay("sh600438", 360)
+	for i, re := range res {
+		logger.SugaredLogger.Debugf("key: %+v, value: %+v", i, re)
+	}
+}
+func TestTopStocksRankingList(t *testing.T) {
+	NewMarketNewsApi().TopStocksRankingList("2025-05-19")
+}
+
+func TestLongTiger(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	NewMarketNewsApi().LongTiger("2025-06-08")
+}
+
+func TestStockResearchReport(t *testing.T) {
+	db.Init("../../data/stock.db")
+	resp := NewMarketNewsApi().StockResearchReport("688082", 7)
+	for _, a := range resp {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+		data := a.(map[string]any)
+		logger.SugaredLogger.Debugf("value: %s  infoCode:%s", data["title"], data["infoCode"])
+		NewMarketNewsApi().GetIndustryReportInfo(data["infoCode"].(string))
+	}
+}
+
+func TestIndustryResearchReport(t *testing.T) {
+	db.Init("../../data/stock.db")
+	resp := NewMarketNewsApi().IndustryResearchReport("", 7)
+	for _, a := range resp {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+		data := a.(map[string]any)
+		logger.SugaredLogger.Debugf("value: %s  infoCode:%s", data["title"], data["infoCode"])
+		logger.SugaredLogger.Debugf("url: https://pdf.dfcfw.com/pdf/H3_%s_1.pdf", data["infoCode"])
+		//NewMarketNewsApi().GetIndustryReportInfo(data["infoCode"].(string))
+	}
+}
+
+func TestStockNotice(t *testing.T) {
+	db.Init("../../data/stock.db")
+	resp := NewMarketNewsApi().StockNotice("600584,600900")
+	for _, a := range resp {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+	}
+
+}
+
+func TestEMDictCode(t *testing.T) {
+	db.Init("../../data/stock.db")
+	resp := NewMarketNewsApi().EMDictCode("016", freecache.NewCache(100))
+	for _, a := range resp {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+	}
+	bytes, err := json.Marshal(resp)
+	if err != nil {
+		return
+	}
+	dict := &[]models.BKDict{}
+	json.Unmarshal(bytes, dict)
+	logger.SugaredLogger.Debugf("value: %s", string(bytes))
+	md := util.MarkdownTableWithTitle("行业/板块代码", dict)
+	logger.SugaredLogger.Debugf(md)
+
+}
+
+func TestTradingViewNews(t *testing.T) {
+	db.Init("../../data/stock.db")
+	InitAnalyzeSentiment()
+	NewMarketNewsApi().TradingViewNews()
+}
+
+func TestXUEQIUHotStock(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewMarketNewsApi().XUEQIUHotStock(50, "10")
+	for _, a := range *res {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+	}
+
+	md := util.MarkdownTableWithTitle("当前热门股票排名", res)
+	logger.SugaredLogger.Debugf(md)
+}
+
+func TestHotEvent(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewMarketNewsApi().HotEvent(50)
+	for _, a := range *res {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+	}
+
+}
+
+func TestHotTopic(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewMarketNewsApi().HotTopic(10)
+	for _, a := range res {
+		logger.SugaredLogger.Debugf("value: %+v", a)
+	}
+
+}
+
+func TestInvestCalendar(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewMarketNewsApi().InvestCalendar("2025-06")
+	for _, a := range res {
+		bytes, err := json.Marshal(a)
+		if err != nil {
+			continue
+		}
+		date := gjson.Get(string(bytes), "date")
+		list := gjson.Get(string(bytes), "list")
+
+		logger.SugaredLogger.Debugf("value: %+v,list: %+v", date.String(), list)
+	}
+}
+
+func TestClsCalendar(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewMarketNewsApi().ClsCalendar()
+	md := strings.Builder{}
+	for _, a := range res {
+		bytes, err := json.Marshal(a)
+		if err != nil {
+			continue
+		}
+		//logger.SugaredLogger.Debugf("value: %+v", string(bytes))
+		date := gjson.Get(string(bytes), "calendar_day")
+		md.WriteString("\n### 事件/会议日期：" + date.String())
+		list := gjson.Get(string(bytes), "items")
+		//logger.SugaredLogger.Debugf("value: %+v,list: %+v", date.String(), list)
+		list.ForEach(func(key, value gjson.Result) bool {
+			logger.SugaredLogger.Debugf("key: %+v,value: %+v", key.String(), gjson.Get(value.String(), "title"))
+			md.WriteString("\n- " + gjson.Get(value.String(), "title").String())
+			return true
+		})
+	}
+	logger.SugaredLogger.Debugf("md:\n %s", md.String())
+}
+
+func TestGetGDP(t *testing.T) {
+	res := NewMarketNewsApi().GetGDP()
+	md := util.MarkdownTableWithTitle("国内生产总值(GDP)", res.GDPResult.Data)
+	logger.SugaredLogger.Debugf(md)
+}
+func TestGetCPI(t *testing.T) {
+	res := NewMarketNewsApi().GetCPI()
+	md := util.MarkdownTableWithTitle("居民消费价格指数(CPI)", res.CPIResult.Data)
+	logger.SugaredLogger.Debugf(md)
+}
+
+// PPI
+func TestGetPPI(t *testing.T) {
+	res := NewMarketNewsApi().GetPPI()
+	md := util.MarkdownTableWithTitle("工业品出厂价格指数(PPI)", res.PPIResult.Data)
+	logger.SugaredLogger.Debugf(md)
+}
+
+// PMI
+func TestGetPMI(t *testing.T) {
+	res := NewMarketNewsApi().GetPMI()
+	md := util.MarkdownTableWithTitle("采购经理人指数(PMI)", res.PMIResult.Data)
+	logger.SugaredLogger.Debugf(md)
+}
+func TestGetIndustryReportInfo(t *testing.T) {
+	NewMarketNewsApi().GetIndustryReportInfo("AP202507151709216483")
+}
+
+func TestReutersNew(t *testing.T) {
+	db.Init("../../data/stock.db")
+	NewMarketNewsApi().ReutersNew()
+}
+
+func TestInteractiveAnswer(t *testing.T) {
+	db.Init("../../data/stock.db")
+	datas := NewMarketNewsApi().InteractiveAnswer(1, 100, "立讯精密")
+	logger.SugaredLogger.Debugf("PageSize:%d", datas.PageSize)
+	md := util.MarkdownTableWithTitle("投资互动", datas.Results)
+	logger.SugaredLogger.Debugf(md)
+
+}
+func TestGetNewsList2(t *testing.T) {
+	db.Init("../../data/stock.db")
+	news := NewMarketNewsApi().GetNewsList2("财联社电报", random.RandInt(100, 500))
+	messageText := strings.Builder{}
+	for _, telegraph := range *news {
+		messageText.WriteString("## " + telegraph.Time + ":" + "\n")
+		messageText.WriteString("### " + telegraph.Content + "\n")
+	}
+	logger.SugaredLogger.Debugf("value: %s", messageText.String())
+}
+
+func TestTelegraphList(t *testing.T) {
+	db.Init("../../data/stock.db")
+	InitAnalyzeSentiment()
+	NewMarketNewsApi().TelegraphList(30)
+}
+
+func TestProxy(t *testing.T) {
+	response, err := resty.New().
+		SetProxy("http://go-stock:778d4ff2-73f3-4d56-b3c3-d9a730a06ae3@stock.sparkmemory.top:8888").
+		R().
+		SetHeader("Host", "news-mediator.tradingview.com").
+		SetHeader("Origin", "https://cn.tradingview.com").
+		SetHeader("Referer", "https://cn.tradingview.com/").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0").
+		//Get("https://api.ipify.org")
+		Get("https://news-mediator.tradingview.com/news-flow/v2/news?filter=lang%3Azh-Hans&client=screener&streaming=false&user_prostatus=non_pro")
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return
+	}
+	logger.SugaredLogger.Debugf("value: %s", response.String())
+
+}
+
+func TestNtfy(t *testing.T) {
+
+	//attach := "http://go-stock.sparkmemory.top/%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A/%E8%B5%84%E9%87%91%E6%B5%81%E5%90%91/2025-12/AI%EF%BC%9A%E5%B8%82%E5%9C%BA%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A-[2025.12.11_12.02.01].html"
+	//post, err := resty.New().SetBaseURL("https://go-stock.sparkmemory.top:16667").R().
+	//	SetHeader("Filename", "AI：市场分析报告-[2025.12.11_12.02.01].html").
+	//	SetHeader("Icon", "https://go-stock.sparkmemory.top/appicon.png").
+	//	SetHeader("Attach", attach).
+	//	SetBody("AI：市场分析报告-[2025.12.11_12.02.01]").Post("/go-stock")
+	//if err != nil {
+	//	logger.SugaredLogger.Error(err)
+	//	return
+	//}
+	//logger.SugaredLogger.Debugf("value: %s", post.String())
+	logger.SugaredLogger.Debugf("value: %s", filepath.Base("https://go-stock.sparkmemory.top/%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A/2025/12/11/%E5%B8%82%E5%9C%BA%E8%B5%84%E8%AE%AF[%E5%B8%82%E5%9C%BA%E8%B5%84%E8%AE%AF]-(2025-12-11)AI%E5%88%86%E6%9E%90%E7%BB%93%E6%9E%9C_20251211131509.html"))
+	logger.SugaredLogger.Debugf("value: %s", strutil.After("/data/go-stock-site/docs/分析报告/2025/12/09/市场资讯[市场资讯]-(2025-12-09)AI分析结果.md", "/data/go-stock-site/docs/"))
+}

backend/data/openai_api_test.go

@@ -0,0 +1,70 @@
+package data
+
+import (
+	"context"
+	"go-stock/backend/db"
+	log "go-stock/backend/logger"
+	"testing"
+)
+
+func TestNewDeepSeekOpenAiConfig(t *testing.T) {
+	db.Init("../../data/stock.db")
+	InitAnalyzeSentiment()
+
+	var tools []Tool
+	tools = append(tools, Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "SearchStockByIndicators",
+			Description: "根据自然语言筛选股票，返回自然语言选股条件要求的股票所有相关数据",
+			Parameters: &FunctionParameters{
+				Type: "object",
+				Properties: map[string]any{
+					"words": map[string]any{
+						"type":        "string",
+						"description": "选股自然语言,并且条件使用;分隔，或者条件使用,分隔。例如：创新药;PE<30;净利润增长率>50%;",
+					},
+				},
+				Required: []string{"words"},
+			},
+		},
+	})
+
+	ai := NewDeepSeekOpenAi(context.TODO(), 11)
+	//res := ai.NewChatStream("长电科技", "sh600584", "长电科技分析和总结", nil)
+	res := ai.NewSummaryStockNewsStreamWithTools("总结市场资讯，发掘潜力标的/行业/板块/概念，控制风险。调用工具函数验证", nil, tools, false)
+
+	for {
+		select {
+		case msg := <-res:
+			if len(msg) > 0 {
+				t.Log(msg)
+				if msg["content"] == "DONE" {
+					return
+				}
+			}
+		}
+	}
+}
+
+func TestGetTopNewsList(t *testing.T) {
+	news := GetTopNewsList(30)
+	t.Log(news)
+}
+
+func TestSearchGuShiTongStockInfo(t *testing.T) {
+	db.Init("../../data/stock.db")
+	//SearchGuShiTongStockInfo("hk01810", 60)
+	msgs := SearchGuShiTongStockInfo("sh600745", 60)
+	for _, msg := range *msgs {
+		log.SugaredLogger.Infof("%s", msg)
+	}
+	//SearchGuShiTongStockInfo("gb_goog", 60)
+
+}
+
+func TestGetZSInfo(t *testing.T) {
+	db.Init("../../data/stock.db")
+	GetZSInfo("中证银行", "sz399986", 5)
+	GetZSInfo("上海贝岭", "sh600171", 5)
+}

backend/data/pool.go

@@ -0,0 +1,115 @@
+package data
+
+import (
+	"context"
+	"go-stock/backend/logger"
+	"sync"
+	"time"
+
+	"github.com/chromedp/chromedp"
+)
+
+// BrowserPool 浏览器池结构
+type BrowserPool struct {
+	pool chan *context.Context
+	mu   sync.Mutex
+	size int
+}
+
+// NewBrowserPool 创建新的浏览器池
+func NewBrowserPool(size int) *BrowserPool {
+	pool := make(chan *context.Context, size)
+	for i := 0; i < size; i++ {
+		path := GetSettingConfig().BrowserPath
+		crawlTimeOut := GetSettingConfig().CrawlTimeOut
+		if crawlTimeOut < 15 {
+			crawlTimeOut = 30
+		}
+		if path != "" {
+			ctx, _ := context.WithTimeout(context.Background(), time.Duration(crawlTimeOut)*time.Second)
+			ctx, _ = chromedp.NewExecAllocator(
+				ctx,
+				chromedp.ExecPath(path),
+				chromedp.Flag("headless", true),
+				chromedp.Flag("blink-settings", "imagesEnabled=false"),
+				chromedp.Flag("disable-javascript", false),
+				chromedp.Flag("disable-gpu", true),
+				//chromedp.UserAgent(""),
+				chromedp.Flag("disable-background-networking", true),
+				chromedp.Flag("enable-features", "NetworkService,NetworkServiceInProcess"),
+				chromedp.Flag("disable-background-timer-throttling", true),
+				chromedp.Flag("disable-backgrounding-occluded-windows", true),
+				chromedp.Flag("disable-breakpad", true),
+				chromedp.Flag("disable-client-side-phishing-detection", true),
+				chromedp.Flag("disable-default-apps", true),
+				chromedp.Flag("disable-dev-shm-usage", true),
+				chromedp.Flag("disable-extensions", true),
+				chromedp.Flag("disable-features", "site-per-process,Translate,BlinkGenPropertyTrees"),
+				chromedp.Flag("disable-hang-monitor", true),
+				chromedp.Flag("disable-ipc-flooding-protection", true),
+				chromedp.Flag("disable-popup-blocking", true),
+				chromedp.Flag("disable-prompt-on-repost", true),
+				chromedp.Flag("disable-renderer-backgrounding", true),
+				chromedp.Flag("disable-sync", true),
+				chromedp.Flag("force-color-profile", "srgb"),
+				chromedp.Flag("metrics-recording-only", true),
+				chromedp.Flag("safebrowsing-disable-auto-update", true),
+				chromedp.Flag("enable-automation", true),
+				chromedp.Flag("password-store", "basic"),
+				chromedp.Flag("use-mock-keychain", true),
+			)
+			ctx, _ = chromedp.NewContext(ctx, chromedp.WithLogf(logger.SugaredLogger.Infof))
+			pool <- &ctx
+		}
+	}
+	return &BrowserPool{
+		pool: pool,
+		size: size,
+	}
+}
+
+// Get 从池中获取浏览器实例
+func (pool *BrowserPool) Get() *context.Context {
+	return <-pool.pool
+}
+
+// Put 将浏览器实例放回池中
+func (pool *BrowserPool) Put(ctx *context.Context) {
+	pool.mu.Lock()
+	defer pool.mu.Unlock()
+	// 检查池是否已满
+	if len(pool.pool) >= pool.size {
+		// 池已满，关闭并丢弃这个实例
+		chromedp.Cancel(*ctx)
+		return
+	}
+	chromedp.Cancel(*ctx)
+	pool.pool <- ctx
+}
+
+// Close 关闭池中的所有浏览器实例
+func (pool *BrowserPool) Close() {
+	close(pool.pool)
+	for ctx := range pool.pool {
+		chromedp.Cancel(*ctx)
+	}
+}
+
+// FetchPage 使用浏览器池获取页面内容
+func (pool *BrowserPool) FetchPage(url, waitVisible string) (string, error) {
+	// 从池中获取浏览器实例
+	ctx := pool.Get()
+	defer pool.Put(ctx) // 使用完毕后放回池中
+	var htmlContent string
+	err := chromedp.Run(*ctx,
+		chromedp.Navigate(url),
+		chromedp.WaitVisible(waitVisible, chromedp.ByQuery), // 确保  元素可见
+		chromedp.WaitReady(waitVisible, chromedp.ByQuery),   // 确保  元素准备好
+		chromedp.InnerHTML("body", &htmlContent),
+		chromedp.Evaluate(`window.close()`, nil),
+	)
+	if err != nil {
+		return "", err
+	}
+	return htmlContent, nil
+}

backend/data/pool_test.go

@@ -0,0 +1,18 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"testing"
+)
+
+func TestPool(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	pool := NewBrowserPool(1)
+	go pool.FetchPage("https://fund.eastmoney.com/016533.html", "body")
+	go pool.FetchPage("https://fund.eastmoney.com/217021.html", "body")
+	go pool.FetchPage("https://fund.eastmoney.com/001125.html", "body")
+
+	select {}
+
+}

backend/data/prompt_template_api.go

@@ -0,0 +1,75 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+)
+
+type PromptTemplateApi struct {
+}
+
+func (t PromptTemplateApi) GetPromptTemplates(name string, promptType string) *[]models.PromptTemplate {
+	var result []models.PromptTemplate
+	if name != "" && promptType != "" {
+		db.Dao.Model(&models.PromptTemplate{}).Where("name=? and type=?", name, promptType).Find(&result)
+	}
+	if name != "" && promptType == "" {
+		db.Dao.Model(&models.PromptTemplate{}).Where("name=?", name).Find(&result)
+	}
+	if name == "" && promptType != "" {
+		db.Dao.Model(&models.PromptTemplate{}).Where("type=?", promptType).Find(&result)
+	}
+	if name == "" && promptType == "" {
+		db.Dao.Model(&models.PromptTemplate{}).Find(&result)
+	}
+
+	return &result
+}
+func (t PromptTemplateApi) AddPrompt(template models.PromptTemplate) string {
+	var tmp models.PromptTemplate
+	db.Dao.Model(&models.PromptTemplate{}).Where("id=?", template.ID).First(&tmp)
+	if tmp.ID == 0 {
+		err := db.Dao.Model(&models.PromptTemplate{}).Create(&models.PromptTemplate{
+			Content: template.Content,
+			Name:    template.Name,
+			Type:    template.Type,
+		}).Error
+		if err != nil {
+			return "添加失败"
+		} else {
+			return "添加成功"
+		}
+	} else {
+		err := db.Dao.Model(&models.PromptTemplate{}).Where("id=?", template.ID).Updates(template).Error
+		if err != nil {
+			return "更新失败"
+		} else {
+			return "更新成功"
+		}
+	}
+}
+
+func (t PromptTemplateApi) DelPrompt(Id uint) string {
+	template := &models.PromptTemplate{}
+	db.Dao.Model(template).Where("id=?", Id).Find(template)
+	if template.ID > 0 {
+		err := db.Dao.Model(template).Delete(template).Error
+		if err != nil {
+			return "删除失败"
+		} else {
+			return "删除成功"
+		}
+	}
+	return "模板信息不存在"
+}
+
+func (t PromptTemplateApi) GetPromptTemplateByID(id int) string {
+	prompt := &models.PromptTemplate{}
+	db.Dao.Model(&models.PromptTemplate{}).Where("id=?", id).First(prompt)
+	logger.SugaredLogger.Infof("GetPromptTemplateByID:%d %s", id, prompt.Content)
+	return prompt.Content
+}
+func NewPromptTemplateApi() *PromptTemplateApi {
+	return &PromptTemplateApi{}
+}

backend/data/search_stock_api.go

@@ -0,0 +1,163 @@
+package data
+
+import (
+	"encoding/json"
+	"fmt"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"go-stock/backend/util"
+	"time"
+
+	"github.com/duke-git/lancet/v2/mathutil"
+	"github.com/go-resty/resty/v2"
+)
+
+// @Author spark
+// @Date 2025/6/28 21:02
+// @Desc
+// -----------------------------------------------------------------------------------
+type SearchStockApi struct {
+	words string
+}
+
+func NewSearchStockApi(words string) *SearchStockApi {
+	return &SearchStockApi{words: words}
+}
+func (s SearchStockApi) SearchStock(pageSize int) map[string]any {
+	qgqpBId := NewSettingsApi().Config.QgqpBId
+	if qgqpBId == "" {
+		return map[string]any{
+			"code":    -1,
+			"message": "请先获取东财用户标识（qgqp_b_id）：打开浏览器,访问东财网站，按F12打开开发人员工具-》网络面板，随便点开一个请求，复制请求cookie中qgqp_b_id对应的值。保存到设置中的东财唯一标识输入框",
+		}
+	}
+	url := "https://np-tjxg-g.eastmoney.com/api/smart-tag/stock/v3/pw/search-code"
+	resp, err := resty.New().SetTimeout(time.Duration(30)*time.Second).R().
+		SetHeader("Host", "np-tjxg-g.eastmoney.com").
+		SetHeader("Origin", "https://xuangu.eastmoney.com").
+		SetHeader("Referer", "https://xuangu.eastmoney.com/").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0").
+		SetHeader("Content-Type", "application/json").
+		SetBody(fmt.Sprintf(`{
+				"keyWord": "%s",
+				"pageSize": %d,
+				"pageNo": 1,
+				"fingerprint": "%s",
+				"gids": [],
+				"matchWord": "",
+				"timestamp": "%d",
+				"shareToGuba": false,
+				"requestId": "",
+				"needCorrect": true,
+				"removedConditionIdList": [],
+				"xcId": "",
+				"ownSelectAll": false,
+				"dxInfo": [],
+				"extraCondition": ""
+				}`, s.words, pageSize, qgqpBId, time.Now().Unix())).Post(url)
+	if err != nil {
+		logger.SugaredLogger.Errorf("SearchStock-err:%+v", err)
+		return map[string]any{
+			"code":    -1,
+			"message": err.Error(),
+		}
+	}
+	respMap := map[string]any{}
+	json.Unmarshal(resp.Body(), &respMap)
+	//logger.SugaredLogger.Infof("resp:%+v", respMap["data"])
+	return respMap
+}
+
+func (s SearchStockApi) SearchBk(pageSize int) map[string]any {
+	url := "https://np-tjxg-b.eastmoney.com/api/smart-tag/bkc/v3/pw/search-code"
+	qgqpBId := NewSettingsApi().Config.QgqpBId
+	if qgqpBId == "" {
+		return map[string]any{
+			"code":    -1,
+			"message": "请先获取东财用户标识（qgqp_b_id）：打开浏览器,访问东财网站，按F12打开开发人员工具-》网络面板，随便点开一个请求，复制请求cookie中qgqp_b_id对应的值。保存到设置中的东财唯一标识输入框",
+		}
+	}
+	resp, err := resty.New().SetTimeout(time.Duration(30)*time.Second).R().
+		SetHeader("Host", "np-tjxg-g.eastmoney.com").
+		SetHeader("Origin", "https://xuangu.eastmoney.com").
+		SetHeader("Referer", "https://xuangu.eastmoney.com/").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0").
+		SetHeader("Content-Type", "application/json").
+		SetBody(fmt.Sprintf(`{
+				"keyWord": "%s",
+				"pageSize": %d,
+				"pageNo": 1,
+				"fingerprint": "%s",
+				"gids": [],
+				"matchWord": "",
+				"timestamp": "%d",
+				"shareToGuba": false,
+				"requestId": "",
+				"needCorrect": true,
+				"removedConditionIdList": [],
+				"xcId": "",
+				"ownSelectAll": false,
+				"dxInfo": [],
+				"extraCondition": ""
+				}`, s.words, pageSize, qgqpBId, time.Now().Unix())).Post(url)
+	if err != nil {
+		logger.SugaredLogger.Errorf("SearchStock-err:%+v", err)
+		return map[string]any{
+			"code":    -1,
+			"message": err.Error(),
+		}
+	}
+	respMap := map[string]any{}
+	json.Unmarshal(resp.Body(), &respMap)
+	//logger.SugaredLogger.Infof("resp:%+v", respMap["data"])
+	return respMap
+}
+
+func (s SearchStockApi) HotStrategy() map[string]any {
+	url := fmt.Sprintf("https://np-ipick.eastmoney.com/recommend/stock/heat/ranking?count=20&trace=%d&client=web&biz=web_smart_tag", time.Now().Unix())
+	resp, err := resty.New().SetTimeout(time.Duration(30)*time.Second).R().
+		SetHeader("Host", "np-ipick.eastmoney.com").
+		SetHeader("Origin", "https://xuangu.eastmoney.com").
+		SetHeader("Referer", "https://xuangu.eastmoney.com/").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0").
+		Get(url)
+	if err != nil {
+		logger.SugaredLogger.Errorf("HotStrategy-err:%+v", err)
+		return map[string]any{}
+	}
+	respMap := map[string]any{}
+	json.Unmarshal(resp.Body(), &respMap)
+	return respMap
+}
+
+func (s SearchStockApi) HotStrategyTable() string {
+	markdownTable := ""
+	res := s.HotStrategy()
+	bytes, _ := json.Marshal(res)
+	strategy := &models.HotStrategy{}
+	json.Unmarshal(bytes, strategy)
+	for _, data := range strategy.Data {
+		data.Chg = mathutil.RoundToFloat(100*data.Chg, 2)
+	}
+	markdownTable = util.MarkdownTableWithTitle("当前热门选股策略", strategy.Data)
+	return markdownTable
+}
+
+func (s SearchStockApi) StrategySquare() map[string]any {
+	//https://backtest.10jqka.com.cn/strategysquare/list?order=desc&page=1&pageNum=10&sortType=hot&keyword=
+	url := "https://backtest.10jqka.com.cn/strategysquare/list?order=desc&page=1&pageNum=10&sortType=hot&keyword="
+	resp, err := resty.New().SetTimeout(time.Duration(30)*time.Second).R().
+		SetHeader("Host", "backtest.10jqka.com.cn").
+		SetHeader("Origin", "https://backtest.10jqka.com.cn").
+		SetHeader("Referer", "https://backtest.10jqka.com.cn/strategysquare/list").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0").
+		Get(url)
+	if err != nil {
+		logger.SugaredLogger.Errorf("StrategySquare-err:%+v", err)
+		return map[string]any{}
+	}
+	respMap := map[string]any{}
+	json.Unmarshal(resp.Body(), &respMap)
+	logger.SugaredLogger.Infof("resp:%+v", respMap["data"])
+	return respMap
+}

backend/data/search_stock_api_test.go

@@ -0,0 +1,89 @@
+package data
+
+import (
+	"encoding/json"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"go-stock/backend/util"
+	"math"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"github.com/duke-git/lancet/v2/random"
+)
+
+func TestSearchStock(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	e := convertor.ToString(math.Floor(float64(9*random.RandFloat(0, 1, 12) + 1)))
+	for i := 0; i < 19; i++ {
+		e += convertor.ToString(math.Floor(float64(9 * random.RandFloat(0, 1, 12))))
+	}
+	logger.SugaredLogger.Infof("e:%s", e)
+
+	//res := NewSearchStockApi("量比大于2，基本面优秀，2025年三季报已披露，主力连续3日净流入，非创业板非科创板非ST").SearchStock(20)
+	res := NewSearchStockApi("今日涨幅前5的概念板块").SearchBk(50)
+
+	logger.SugaredLogger.Infof("res:%+v", res)
+	data := res["data"].(map[string]any)
+	result := data["result"].(map[string]any)
+	dataList := result["dataList"].([]any)
+	columns := result["columns"].([]any)
+	headers := map[string]string{}
+	for _, v := range columns {
+		//logger.SugaredLogger.Infof("v:%+v", v)
+		d := v.(map[string]any)
+		//logger.SugaredLogger.Infof("key:%s title:%s dateMsg:%s unit:%s", d["key"], d["title"], d["dateMsg"], d["unit"])
+		title := convertor.ToString(d["title"])
+		if convertor.ToString(d["dateMsg"]) != "" {
+			title = title + "[" + convertor.ToString(d["dateMsg"]) + "]"
+		}
+		if convertor.ToString(d["unit"]) != "" {
+			title = title + "(" + convertor.ToString(d["unit"]) + ")"
+		}
+		headers[d["key"].(string)] = title
+	}
+	table := &[]map[string]any{}
+	for _, v := range dataList {
+		//logger.SugaredLogger.Infof("v:%+v", v)
+		d := v.(map[string]any)
+		tmp := map[string]any{}
+		for key, title := range headers {
+			//logger.SugaredLogger.Infof("%s:%s", title, convertor.ToString(d[key]))
+			tmp[title] = convertor.ToString(d[key])
+		}
+		*table = append(*table, tmp)
+		//logger.SugaredLogger.Infof("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------")
+	}
+	jsonData, _ := json.Marshal(*table)
+	markdownTable, _ := JSONToMarkdownTable(jsonData)
+	logger.SugaredLogger.Infof("markdownTable=\n%s", markdownTable)
+}
+
+func TestSearchStockApi_HotStrategy(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewSearchStockApi("").HotStrategy()
+	bytes, err := json.Marshal(res)
+	if err != nil {
+		return
+	}
+	strategy := &models.HotStrategy{}
+	json.Unmarshal(bytes, strategy)
+	for _, data := range strategy.Data {
+		data.Chg = mathutil.RoundToFloat(100*data.Chg, 2)
+	}
+	markdownTable := util.MarkdownTable(strategy.Data)
+	logger.SugaredLogger.Infof("res:%s", markdownTable)
+	//dataList := res["data"].([]any)
+	//for _, v := range dataList {
+	//	d := v.(map[string]any)
+	//	logger.SugaredLogger.Infof("v:%+v", d)
+	//}
+}
+func TestSearchStockApi_HotStrategyTable(t *testing.T) {
+	db.Init("../../data/stock.db")
+	res := NewSearchStockApi("").StrategySquare()
+	logger.SugaredLogger.Infof("res:%+v", res)
+}

backend/data/settings_api.go

@@ -0,0 +1,234 @@
+package data
+
+import (
+	"encoding/json"
+	"errors"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"time"
+
+	"github.com/samber/lo"
+	"gorm.io/gorm"
+)
+
+type Settings struct {
+	gorm.Model
+	TushareToken           string `json:"tushareToken"`
+	LocalPushEnable        bool   `json:"localPushEnable"`
+	DingPushEnable         bool   `json:"dingPushEnable"`
+	DingRobot              string `json:"dingRobot"`
+	UpdateBasicInfoOnStart bool   `json:"updateBasicInfoOnStart"`
+	RefreshInterval        int64  `json:"refreshInterval"`
+	OpenAiEnable           bool   `json:"openAiEnable"`
+	Prompt                 string `json:"prompt"`
+	CheckUpdate            bool   `json:"checkUpdate"`
+	QuestionTemplate       string `json:"questionTemplate"`
+	CrawlTimeOut           int64  `json:"crawlTimeOut"`
+	KDays                  int64  `json:"kDays"`
+	EnableDanmu            bool   `json:"enableDanmu"`
+	BrowserPath            string `json:"browserPath"`
+	EnableNews             bool   `json:"enableNews"`
+	DarkTheme              bool   `json:"darkTheme"`
+	BrowserPoolSize        int    `json:"browserPoolSize"`
+	EnableFund             bool   `json:"enableFund"`
+	EnablePushNews         bool   `json:"enablePushNews"`
+	EnableOnlyPushRedNews  bool   `json:"enableOnlyPushRedNews"`
+	SponsorCode            string `json:"sponsorCode"`
+	HttpProxy              string `json:"httpProxy"`
+	HttpProxyEnabled       bool   `json:"httpProxyEnabled"`
+	EnableAgent            bool   `json:"enableAgent"`
+	QgqpBId                string `json:"qgqpBId" gorm:"column:qgqp_b_id"`
+}
+
+func (receiver Settings) TableName() string {
+	return "settings"
+}
+
+type AIConfig struct {
+	ID               uint `gorm:"primarykey"`
+	CreatedAt        time.Time
+	UpdatedAt        time.Time
+	Name             string  `json:"name"`
+	BaseUrl          string  `json:"baseUrl"`
+	ApiKey           string  `json:"apiKey" `
+	ModelName        string  `json:"modelName"`
+	MaxTokens        int     `json:"maxTokens"`
+	Temperature      float64 `json:"temperature"`
+	TimeOut          int     `json:"timeOut"`
+	HttpProxy        string  `json:"httpProxy"`
+	HttpProxyEnabled bool    `json:"httpProxyEnabled"`
+}
+
+func (AIConfig) TableName() string {
+	return "ai_config"
+}
+
+type SettingConfig struct {
+	*Settings
+	AiConfigs []*AIConfig `json:"aiConfigs"`
+}
+
+type SettingsApi struct {
+	Config *SettingConfig
+}
+
+func NewSettingsApi() *SettingsApi {
+	return &SettingsApi{
+		Config: GetSettingConfig(),
+	}
+}
+
+func (s *SettingsApi) Export() string {
+	d, _ := json.MarshalIndent(s.Config, "", "    ")
+	return string(d)
+}
+
+func UpdateConfig(s *SettingConfig) string {
+	count := int64(0)
+	db.Dao.Model(&Settings{}).Count(&count)
+	if count > 0 {
+		db.Dao.Model(&Settings{}).Where("id=?", s.ID).Updates(map[string]any{
+			"local_push_enable":          s.LocalPushEnable,
+			"ding_push_enable":           s.DingPushEnable,
+			"ding_robot":                 s.DingRobot,
+			"update_basic_info_on_start": s.UpdateBasicInfoOnStart,
+			"refresh_interval":           s.RefreshInterval,
+			"open_ai_enable":             s.OpenAiEnable,
+			"tushare_token":              s.TushareToken,
+			"prompt":                     s.Prompt,
+			"check_update":               s.CheckUpdate,
+			"question_template":          s.QuestionTemplate,
+			"crawl_time_out":             s.CrawlTimeOut,
+			"k_days":                     s.KDays,
+			"enable_danmu":               s.EnableDanmu,
+			"browser_path":               s.BrowserPath,
+			"enable_news":                s.EnableNews,
+			"dark_theme":                 s.DarkTheme,
+			"enable_fund":                s.EnableFund,
+			"enable_push_news":           s.EnablePushNews,
+			"enable_only_push_red_news":  s.EnableOnlyPushRedNews,
+			"sponsor_code":               s.SponsorCode,
+			"http_proxy":                 s.HttpProxy,
+			"http_proxy_enabled":         s.HttpProxyEnabled,
+			"enable_agent":               s.EnableAgent,
+			"qgqp_b_id":                  s.QgqpBId,
+		})
+
+		//更新AiConfig
+		err := updateAiConfigs(s.AiConfigs)
+		if err != nil {
+			logger.SugaredLogger.Errorf("更新AI模型服务配置失败: %v", err)
+			return "更新AI模型服务配置失败: " + err.Error()
+		}
+	} else {
+		logger.SugaredLogger.Infof("未找到配置，创建默认配置")
+		// 创建主配置
+		result := db.Dao.Model(&Settings{}).Create(&Settings{})
+		if result.Error != nil {
+			logger.SugaredLogger.Error("创建配置失败:", result.Error)
+			return "创建配置失败: " + result.Error.Error()
+		}
+	}
+	return "保存成功！"
+}
+
+func updateAiConfigs(aiConfigs []*AIConfig) error {
+	if len(aiConfigs) == 0 {
+		err := db.Dao.Exec("DELETE FROM ai_config").Error
+		if err != nil {
+			return err
+		}
+		return db.Dao.Exec("DELETE FROM sqlite_sequence WHERE name='ai_config'").Error
+	}
+	var ids []uint
+	lo.ForEach(aiConfigs, func(item *AIConfig, index int) {
+		ids = append(ids, item.ID)
+	})
+	var existAiConfigs []*AIConfig
+	err := db.Dao.Model(&AIConfig{}).Select("id").Where("id in (?) ", ids).Find(&existAiConfigs).Error
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return err
+	}
+	idMap := make(map[uint]bool)
+	lo.ForEach(existAiConfigs, func(item *AIConfig, index int) {
+		idMap[item.ID] = true
+	})
+	var addAiConfigs []*AIConfig
+	var notDeleteIds []uint
+	var e error
+	lo.ForEach(aiConfigs, func(item *AIConfig, index int) {
+		if e != nil {
+			return
+		}
+		if !idMap[item.ID] {
+			addAiConfigs = append(addAiConfigs, item)
+		} else {
+			notDeleteIds = append(notDeleteIds, item.ID)
+			e = db.Dao.Model(&AIConfig{}).Where("id=?", item.ID).Updates(map[string]interface{}{
+				"name":               item.Name,
+				"base_url":           item.BaseUrl,
+				"api_key":            item.ApiKey,
+				"model_name":         item.ModelName,
+				"max_tokens":         item.MaxTokens,
+				"temperature":        item.Temperature,
+				"time_out":           item.TimeOut,
+				"http_proxy":         item.HttpProxy,
+				"http_proxy_enabled": item.HttpProxyEnabled,
+			}).Error
+			if e != nil {
+				return
+			}
+		}
+	})
+	if e != nil {
+		return e
+	}
+	//删除旧的配置
+	if len(notDeleteIds) > 0 {
+		err = db.Dao.Exec("DELETE FROM ai_config WHERE id NOT IN ?", notDeleteIds).Error
+		if err != nil {
+			return err
+		}
+	}
+	logger.SugaredLogger.Infof("更新aiConfigs +%d", len(addAiConfigs))
+	//批量新增的配置
+	err = db.Dao.CreateInBatches(addAiConfigs, len(addAiConfigs)).Error
+	return err
+}
+
+func GetSettingConfig() *SettingConfig {
+	settingConfig := &SettingConfig{}
+	settings := &Settings{}
+	aiConfigs := make([]*AIConfig, 0)
+	// 处理数据库查询可能返回的空结果
+	result := db.Dao.Model(&Settings{}).First(settings)
+	if settings.OpenAiEnable {
+		// 处理AI配置查询可能出现的错误
+		result = db.Dao.Model(&AIConfig{}).Find(&aiConfigs)
+		if result.Error != nil {
+			logger.SugaredLogger.Error("查询AI配置失败:", result.Error)
+		} else if len(aiConfigs) > 0 {
+			lo.ForEach(aiConfigs, func(item *AIConfig, index int) {
+				if item.TimeOut <= 0 {
+					item.TimeOut = 60 * 5
+				}
+			})
+		}
+		if settings.CrawlTimeOut <= 0 {
+			settings.CrawlTimeOut = 60
+		}
+		if settings.KDays < 30 {
+			settings.KDays = 60
+		}
+	}
+	if settings.BrowserPath == "" {
+		settings.BrowserPath, _ = CheckBrowser()
+	}
+	if settings.BrowserPoolSize <= 0 {
+		settings.BrowserPoolSize = 1
+	}
+	settingConfig.Settings = settings
+	settingConfig.AiConfigs = aiConfigs
+
+	return settingConfig
+}

backend/data/stock_data_api_darwin.go

@@ -0,0 +1,37 @@
+//go:build darwin
+// +build darwin
+
+package data
+
+import "os"
+
+// CheckChrome 检查 macOS 是否安装了 Chrome 浏览器
+func CheckChrome() (string, bool) {
+	// 检查 /Applications 目录下是否存在 Chrome
+	locations := []string{
+		// Mac
+		"/Applications/Chromium.app/Contents/MacOS/Chromium",
+		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+	}
+	path := ""
+	for _, location := range locations {
+		_, err := os.Stat(location)
+		if err != nil {
+			continue
+		}
+		path = location
+	}
+	if path == "" {
+		return "", false
+	}
+
+	return path, true
+}
+
+// CheckBrowser 检查 macOS 是否安装了浏览器，并返回安装路径
+func CheckBrowser() (string, bool) {
+	if path, ok := CheckChrome(); ok {
+		return path, ok
+	}
+	return "", false
+}

backend/data/stock_data_api_test.go

@@ -1,12 +1,22 @@
 package data
 
 import (
+	"context"
 	"encoding/json"
-	"github.com/duke-git/lancet/v2/convertor"
+	"fmt"
 	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/util"
 	"io/ioutil"
+	"regexp"
 	"strings"
 	"testing"
+	"time"
+
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/random"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/go-resty/resty/v2"
 )
 
 // @Author spark
@@ -14,9 +24,181 @@ import (
 // @Desc
 //-----------------------------------------------------------------------------------
 
+func TestGetTelegraph(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	//telegraphs := GetTelegraphList(30)
+	//for _, telegraph := range *telegraphs {
+	//	logger.SugaredLogger.Info(telegraph)
+	//}
+	list := NewMarketNewsApi().GetNewTelegraph(30)
+	for _, telegraph := range *list {
+		logger.SugaredLogger.Infof("telegraph:%+v", telegraph)
+	}
+}
+
+func TestGetFinancialReports(t *testing.T) {
+	db.Init("../../data/stock.db")
+	//GetFinancialReports("sz000802", 30)
+	//GetFinancialReports("hk00927", 30)
+	//GetFinancialReports("gb_aapl", 30)
+	GetFinancialReportsByXUEQIU("sz000802", 30)
+	GetFinancialReportsByXUEQIU("gb_aapl", 30)
+	GetFinancialReportsByXUEQIU("hk00927", 30)
+
+}
+
+func TestGetTelegraphSearch(t *testing.T) {
+	db.Init("../../data/stock.db")
+	searchWords := "半导体 新能源汽车 机器人"
+	//url := "https://www.cls.cn/searchPage?keyword=%E9%97%BB%E6%B3%B0%E7%A7%91%E6%8A%80&type=telegram"
+	messages := SearchStockInfo(searchWords, "telegram", 30)
+	for _, message := range *messages {
+		logger.SugaredLogger.Info(message)
+	}
+
+	//https://www.cls.cn/stock?code=sh600745
+}
+func TestCailianpressWeb(t *testing.T) {
+	db.Init("../../data/stock.db")
+	searchWords := "半导体 新能源汽车 机器人"
+	res := NewMarketNewsApi().CailianpressWeb(searchWords)
+	md := util.MarkdownTableWithTitle(searchWords+"财联社新闻", res.List)
+	logger.SugaredLogger.Info(md)
+}
+
+func TestSearchStockInfoByCode(t *testing.T) {
+	db.Init("../../data/stock.db")
+	SearchStockInfoByCode("sh600745")
+}
+
+func TestSearchStockPriceInfo(t *testing.T) {
+	db.Init("../../data/stock.db")
+	SearchStockPriceInfo("博安生物", "hk06955", 30)
+	SearchStockPriceInfo("上海贝岭", "sh600171", 30)
+	//SearchStockPriceInfo("苹果公司", "gb_aapl", 30)
+	//SearchStockPriceInfo("微创光电", "bj430198", 30)
+	//getZSInfo("创业板指数", "sz399006", 30)
+	//getZSInfo("上证综合指数", "sh000001", 30)
+	//getZSInfo("沪深300指数", "sh000300", 30)
+
+}
+func TestGetStockMinutePriceData(t *testing.T) {
+	db.Init("../../data/stock.db")
+	data, date := NewStockDataApi().GetStockMinutePriceData("usTSLA.OQ")
+	logger.SugaredLogger.Infof("date:%s", date)
+	logger.SugaredLogger.Infof("%+#v", *data)
+}
+func TestGetKLineData(t *testing.T) {
+	db.Init("../../data/stock.db")
+	k := NewStockDataApi().GetKLineData("sh600171", "240", 30)
+	//for _, kline := range *k {
+	//	logger.SugaredLogger.Infof("%+#v", kline)
+	//}
+	jsonData, _ := json.Marshal(*k)
+	markdownTable, err := JSONToMarkdownTable(jsonData)
+	if err != nil {
+		logger.SugaredLogger.Errorf("json.Marshal error:%s", err.Error())
+	}
+	logger.SugaredLogger.Infof("markdownTable:\n%s", markdownTable)
+
+}
+func TestGetHK_KLineData(t *testing.T) {
+	db.Init("../../data/stock.db")
+	k := NewStockDataApi().GetHK_KLineData("hk01810", "day", 1)
+	jsonData, _ := json.Marshal(*k)
+	markdownTable, err := JSONToMarkdownTable(jsonData)
+	if err != nil {
+		logger.SugaredLogger.Errorf("json.Marshal error:%s", err.Error())
+	}
+	logger.SugaredLogger.Infof("markdownTable:\n%s", markdownTable)
+
+}
+
+func TestGetHKStockInfo(t *testing.T) {
+	db.Init("../../data/stock.db")
+	//NewStockDataApi().GetHKStockInfo(200)
+	//NewStockDataApi().GetSinaHKStockInfo()
+	//m:105,m:106,m:107  //美股
+	//m:128+t:3,m:128+t:4,m:128+t:1,m:128+t:2 //港股
+	//274  224 605
+	for i := 197; i <= 274; i++ {
+		NewStockDataApi().getDCStockInfo("", i, 20)
+		time.Sleep(time.Duration(random.RandInt(2, 5)) * time.Second)
+	}
+}
+
+func TestParseTxStockData(t *testing.T) {
+	str := "v_r_hk09660=\"100~地平线机器人-W~09660~6.340~5.690~5.800~210980204.0~0~0~6.340~0~0~0~0~0~0~0~0~0~6.340~0~0~0~0~0~0~0~0~0~210980204.0~2025/04/29\n14:14:52~0.650~11.42~6.450~5.710~6.340~210980204.0~1295585259.040~0~33.03~~0~0~13.01~702.2123~836.8986~HORIZONROBOT-W~0.00~10.380~3.320~1.00~-53.74~0~0~0~0~0~33.03~6.50~1.90~600~76.11~19.85~GP~19.70~11.51~0.63~-17.23~46.76~13200293682.00~11075904412.00~33.03~0.000~6.141~58.90~HKD~1~30\";"
+	//str = "v_sz002241=\"51~歌尔股份~002241~22.26~22.27~0.00~0~0~0~22.26~1004~0.00~0~0.00~0~0.00~0~0.00~0~22.26~1004~0.00~558~0.00~0~0.00~0~0.00~0~~20250509092233~-0.01~-0.04~0.00~0.00~22.26/0/0~0~0~0.00~28.21~~0.00~0.00~0.00~686.46~777.09~2.31~24.50~20.04~0.00~-558~0.00~41.44~29.16~~~1.24~0.0000~0.0000~0~\n~GP-A~-13.75~6.76~1.09~8.18~3.39~30.63~15.70~6.87~17.47~-23.95~3083811231~3490989083~-21.75~12.02~3083811231~~~39.36~-0.04~~CNY~0~~0.00~0\";"
+	str = "v_sz002241=\"51~歌尔股份~002241~21.92~22.27~22.14~109872~40211~69642~21.91~25~21.90~961~21.89~257~21.88~748~21.87~665~21.92~86~21.93~168~21.94~556~21.95~171~21.96~85~~20250509094209~-0.35~-1.57~22.16~21.84~21.92/109872/241183171~109872~24118~0.36~27.78~~22.16~21.84~1.44~675.97~765.22~2.27~24.50~20.04~2.57~1590~21.95~40.80~28.71~~~1.24~24118.3171~0.0000~0~\n~GP-A~-15.07~5.13~1.11~8.18~3.39~30.63~15.70~5.23~15.67~-25.11~3083811231~3490989083~42.72~10.31~3083811231~~~37.23~0.18~~CNY~0~~21.85~1952\";"
+	//str = "v_r_hk09660=\"100~地平线机器人-W~09660~6.860~7.000~7.010~21157200.0~0~0~6.860~0~0~0~0~0~0~0~0~0~6.860~0~0~0~0~0~0~0~0~0~21157200.0~2025/05/09\n09:43:13~-0.140~-2.00~7.030~6.730~6.860~21157200.0~144331073.000~0~35.74~~0~0~4.29~759.8070~905.5401~HORIZONROBOT-W~0.00~10.380~3.320~2.93~11.10~0~0~0~0~0~35.74~7.04~0.19~600~90.56~4.73~GP~19.70~11.51~17.26~48.48~13.58~13200293682.00~11075904412.00~35.74~0.000~6.822~71.93~HKD~1~30\";"
+	info, _ := ParseTxStockData(str)
+	logger.SugaredLogger.Infof("%+#v", info)
+}
+
+func TestGetRealTimeStockPriceInfo(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	text, texttime := GetRealTimeStockPriceInfo(ctx, "sh600171")
+	logger.SugaredLogger.Infof("res:%s,%s", text, texttime)
+
+	text, texttime = GetRealTimeStockPriceInfo(ctx, "sh600438")
+	logger.SugaredLogger.Infof("res:%s,%s", text, texttime)
+
+	texttime = strings.ReplaceAll(texttime, "）", "")
+	texttime = strings.ReplaceAll(texttime, "（", "")
+	parts := strings.Split(texttime, " ")
+	logger.SugaredLogger.Infof("parts:%+v", parts)
+
+	//去除中文字符
+	// 正则表达式匹配中文字符
+	re := regexp.MustCompile(`\p{Han}+`)
+	texttime = re.ReplaceAllString(texttime, "")
+
+	logger.SugaredLogger.Infof("texttime:%s", texttime)
+	location, err := time.ParseInLocation("2006-01-02 15:04:05", texttime, time.Local)
+	if err != nil {
+		return
+	}
+	logger.SugaredLogger.Infof("location:%s", location.Format("2006-01-02 15:04:05"))
+}
+
+func TestParseFullSingleStockData(t *testing.T) {
+	resp, err := resty.New().R().
+		SetHeader("Host", "hq.sinajs.cn").
+		SetHeader("Referer", "https://finance.sina.com.cn/").
+		SetHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0").
+		Get(fmt.Sprintf(sinaStockUrl, time.Now().Unix(), "sh600584,sz000938,hk01810,hk00856,gb_aapl,gb_tsla,sb873721,bj430300"))
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+	}
+	data := GB18030ToUTF8(resp.Body())
+	strs := strutil.SplitEx(data, "\n", true)
+	for _, str := range strs {
+		logger.SugaredLogger.Info(str)
+		stockData, err := ParseFullSingleStockData(str)
+		if err != nil {
+			return
+		}
+		logger.SugaredLogger.Infof("%+#v", stockData)
+	}
+
+	result, er := ParseFullSingleStockData("var hq_str_gb_tsla = \"特斯拉,268.8472,-5.55,2025-03-04 22:52:56,-15.8028,270.9300,278.2800,268.1000,488.5400,138.8030,23618295,88214389,864751599149,2.23,120.550000,0.00,0.00,0.00,0.00,3216517037,61,0.0000,0.00,0.00,,Mar 04 09:52AM EST,284.6500,0,1,2025,6458502467.0000,0.0000,0.0000,0.0000,0.0000,284.6500\";")
+	if er != nil {
+		logger.SugaredLogger.Error(er.Error())
+	}
+	logger.SugaredLogger.Infof("%+#v", result)
+}
+
 func TestNewStockDataApi(t *testing.T) {
+	db.Init("../../data/stock.db")
 	stockDataApi := NewStockDataApi()
-	t.Log(stockDataApi.GetStockCodeRealTimeData("sh600859"))
+	datas, _ := stockDataApi.GetStockCodeRealTimeData("sz002352", "sh600859", "sh600745", "gb_tsla", "hk09660", "hk00700")
+	for _, data := range *datas {
+		t.Log(data)
+	}
 }
 
 func TestGetStockBaseInfo(t *testing.T) {
@@ -74,7 +256,7 @@ func TestReadFile(t *testing.T) {
 func TestFollowedList(t *testing.T) {
 	db.Init("../../data/stock.db")
 	stockDataApi := NewStockDataApi()
-	t.Log(stockDataApi.GetFollowList())
+	stockDataApi.GetFollowList(1)
 
 }
 
@@ -83,3 +265,35 @@ func TestStockDataApi_GetIndexBasic(t *testing.T) {
 	stockDataApi := NewStockDataApi()
 	stockDataApi.GetIndexBasic()
 }
+
+func TestName(t *testing.T) {
+	db.Init("../../data/stock.db")
+
+	stockBasics := &[]StockBasic{}
+	resty.New().SetProxy("").R().
+		SetHeader("user", "go-stock").
+		SetResult(stockBasics).
+		Get("http://8.134.249.145:18080/go-stock/stock_basic.json")
+
+	logger.SugaredLogger.Infof("%+v", stockBasics)
+	//db.Dao.Unscoped().Model(&StockBasic{}).Where("1=1").Delete(&StockBasic{})
+	//err := db.Dao.CreateInBatches(stockBasics, 400).Error
+	//if err != nil {
+	//	t.Log(err.Error())
+	//}
+
+}
+func TestGetStockMoneyData(t *testing.T) {
+	db.Init("../../data/stock.db")
+	stockDataApi := NewStockDataApi()
+	res := stockDataApi.GetStockMoneyData()
+	logger.SugaredLogger.Infof("%s", util.MarkdownTableWithTitle("今日个股资金流向Top50", res.Data.Diff))
+}
+
+func TestGetStockConceptInfo(t *testing.T) {
+	db.Init("../../data/stock.db")
+	stockDataApi := NewStockDataApi()
+	res := stockDataApi.GetStockConceptInfo("601138.SH")
+	logger.SugaredLogger.Infof("%s", util.MarkdownTableWithTitle("601138.SH所属概念/板块信息", res.Result.Data))
+
+}

backend/data/stock_data_api_windows.go

@@ -0,0 +1,50 @@
+//go:build windows
+// +build windows
+
+package data
+
+import "golang.org/x/sys/windows/registry"
+
+// CheckChrome 在 Windows 系统上检查谷歌浏览器是否安装
+func CheckChrome() (string, bool) {
+	key, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe`, registry.QUERY_VALUE)
+	if err != nil {
+		// 尝试在 WOW6432Node 中查找（适用于 64 位系统上的 32 位程序）
+		key, err = registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe`, registry.QUERY_VALUE)
+		if err != nil {
+			return "", false
+		}
+		defer key.Close()
+	}
+	defer key.Close()
+	path, _, err := key.GetStringValue("Path")
+	//logger.SugaredLogger.Infof("Chrome安装路径：%s", path)
+	if err != nil {
+		return "", false
+	}
+	return path + "\\chrome.exe", true
+}
+
+// CheckBrowser 在 Windows 系统上检查Edge浏览器是否安装，并返回安装路径
+func CheckBrowser() (string, bool) {
+	if path, ok := CheckChrome(); ok {
+		return path, true
+	}
+
+	key, err := registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\msedge.exe`, registry.QUERY_VALUE)
+	if err != nil {
+		// 尝试在 WOW6432Node 中查找（适用于 64 位系统上的 32 位程序）
+		key, err = registry.OpenKey(registry.LOCAL_MACHINE, `SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\App Paths\msedge.exe`, registry.QUERY_VALUE)
+		if err != nil {
+			return "", false
+		}
+		defer key.Close()
+	}
+	defer key.Close()
+	path, _, err := key.GetStringValue("Path")
+	//logger.SugaredLogger.Infof("Edge安装路径：%s", path)
+	if err != nil {
+		return "", false
+	}
+	return path + "\\msedge.exe", true
+}

backend/data/stock_group_api.go

@@ -0,0 +1,137 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"gorm.io/gorm"
+)
+
+// @Author spark
+// @Date 2025/4/3 11:18
+// @Desc
+// -----------------------------------------------------------------------------------
+type Group struct {
+	gorm.Model
+	Name string `json:"name" gorm:"index"`
+	Sort int    `json:"sort"`
+}
+
+func (Group) TableName() string {
+	return "stock_groups"
+}
+
+type GroupStock struct {
+	gorm.Model
+	StockCode string `json:"stockCode" gorm:"index"`
+	GroupId   int    `json:"groupId" gorm:"index"`
+	GroupInfo Group  `json:"groupInfo" gorm:"foreignKey:GroupId;references:ID"`
+}
+
+func (GroupStock) TableName() string {
+	return "group_stock_info"
+}
+
+type StockGroupApi struct {
+	dao *gorm.DB
+}
+
+func NewStockGroupApi(dao *gorm.DB) *StockGroupApi {
+	return &StockGroupApi{dao: db.Dao}
+}
+
+func (receiver StockGroupApi) AddGroup(group Group) bool {
+	// 检查是否已存在相同sort的组
+	var existingGroup Group
+	err := receiver.dao.Where("sort = ?", group.Sort).First(&existingGroup).Error
+
+	// 如果存在相同sort的组，则将该组及之后的所有组向后移动一位
+	if err == nil {
+		// 处理sort冲突：将相同sort值及之后的所有组向后移动一位
+		receiver.dao.Model(&Group{}).Where("sort >= ?", group.Sort).Update("sort", gorm.Expr("sort + ?", 1))
+	}
+
+	// 创建新组
+	err = receiver.dao.Create(&group).Error
+	return err == nil
+}
+func (receiver StockGroupApi) GetGroupList() []Group {
+	var groups []Group
+	receiver.dao.Order("sort ASC").Find(&groups)
+	return groups
+}
+func (receiver StockGroupApi) UpdateGroupSort(id int, newSort int) bool {
+	// First, get the current group to check if it exists
+	var currentGroup Group
+	if err := receiver.dao.First(&currentGroup, id).Error; err != nil {
+		return false
+	}
+
+	// If the new sort is the same as current, no need to update
+	if currentGroup.Sort == newSort {
+		return true
+	}
+
+	// Get all groups ordered by sort
+	var allGroups []Group
+	receiver.dao.Order("sort ASC").Find(&allGroups)
+
+	// Adjust sort numbers to make space for the new sort value
+	if newSort > currentGroup.Sort {
+		// Moving down: decrease sort of groups between old and new position
+		receiver.dao.Model(&Group{}).Where("sort > ? AND sort <= ? AND id != ?", currentGroup.Sort, newSort, id).Update("sort", gorm.Expr("sort - ?", 1))
+	} else {
+		// Moving up: increase sort of groups between new and old position
+		receiver.dao.Model(&Group{}).Where("sort >= ? AND sort < ? AND id != ?", newSort, currentGroup.Sort, id).Update("sort", gorm.Expr("sort + ?", 1))
+	}
+
+	// Update the target group's sort
+	err := receiver.dao.Model(&Group{}).Where("id = ?", id).Update("sort", newSort).Error
+	return err == nil
+}
+
+// InitializeGroupSort initializes sort order for all groups based on created time
+func (receiver StockGroupApi) InitializeGroupSort() bool {
+	// Get all groups ordered by created time
+	var groups []Group
+	err := receiver.dao.Order("created_at ASC").Find(&groups).Error
+	if err != nil {
+		return false
+	}
+
+	// Update each group with new sort value based on their position
+	for i, group := range groups {
+		newSort := i + 1
+		err := receiver.dao.Model(&Group{}).Where("id = ?", group.ID).Update("sort", newSort).Error
+		if err != nil {
+			return false
+		}
+	}
+	return true
+}
+func (receiver StockGroupApi) GetGroupStockByGroupId(groupId int) []GroupStock {
+	var stockGroup []GroupStock
+	receiver.dao.Preload("GroupInfo").Where("group_id = ?", groupId).Find(&stockGroup)
+	return stockGroup
+}
+
+func (receiver StockGroupApi) AddStockGroup(groupId int, stockCode string) bool {
+	err := receiver.dao.Where("group_id = ? and stock_code = ?", groupId, stockCode).FirstOrCreate(&GroupStock{
+		GroupId:   groupId,
+		StockCode: stockCode,
+	}).Updates(&GroupStock{
+		GroupId:   groupId,
+		StockCode: stockCode,
+	}).Error
+	return err == nil
+}
+
+func (receiver StockGroupApi) RemoveStockGroup(code string, name string, id int) bool {
+	err := receiver.dao.Where("group_id = ? and stock_code = ?", id, code).Delete(&GroupStock{}).Error
+	return err == nil
+}
+
+func (receiver StockGroupApi) RemoveGroup(id int) bool {
+	err := receiver.dao.Where("id = ?", id).Delete(&Group{}).Error
+	err = receiver.dao.Where("group_id = ?", id).Delete(&GroupStock{}).Error
+	return err == nil
+
+}

backend/data/stock_sentiment_analysis.go

@@ -0,0 +1,578 @@
+package data
+
+import (
+	"bufio"
+	_ "embed"
+	"fmt"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"go-stock/backend/models"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+	"unicode"
+
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/fileutil"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/go-ego/gse"
+)
+
+const basefreq float64 = 100
+
+// 金融情感词典，包含股票市场相关的专业词汇
+var (
+	seg gse.Segmenter
+
+	// 正面金融词汇及其权重
+	positiveFinanceWords = map[string]float64{
+		"涨": 1.0, "上涨": 2.0, "涨停": 3.0, "牛市": 3.0, "反弹": 2.0, "新高": 2.5,
+		"利好": 2.5, "增持": 2.0, "买入": 2.0, "推荐": 1.5, "看多": 2.0,
+		"盈利": 2.0, "增长": 2.0, "超预期": 2.5, "强劲": 1.5, "回升": 1.5,
+		"复苏": 2.0, "突破": 2.0, "创新高": 3.0, "回暖": 1.5, "上扬": 1.5,
+		"利好消息": 3.0, "收益增长": 2.5, "利润增长": 2.5, "业绩优异": 2.5,
+		"潜力股": 2.0, "绩优股": 2.0, "强势": 1.5, "走高": 1.5, "攀升": 1.5,
+		"大涨": 2.5, "飙升": 3.0, "井喷": 3.0, "暴涨": 3.0,
+	}
+
+	// 负面金融词汇及其权重
+	negativeFinanceWords = map[string]float64{
+		"跌": 2.0, "下跌": 2.0, "跌停": 3.0, "熊市": 3.0, "回调": 2.5, "新低": 2.5,
+		"利空": 2.5, "减持": 2.0, "卖出": 2.0, "看空": 2.0, "亏损": 2.5,
+		"下滑": 2.0, "萎缩": 2.0, "不及预期": 2.5, "疲软": 1.5, "恶化": 2.0,
+		"衰退": 2.0, "跌破": 2.0, "创新低": 3.0, "走弱": 2.5, "下挫": 2.5,
+		"利空消息": 3.0, "收益下降": 2.5, "利润下滑": 2.5, "业绩不佳": 2.5,
+		"垃圾股": 2.0, "风险股": 2.0, "弱势": 2.5, "走低": 2.5, "缩量": 2.5,
+		"大跌": 2.5, "暴跌": 3.0, "崩盘": 3.0, "跳水": 3.0, "重挫": 3.0, "跌超": 2.5, "跌逾": 2.5, "跌近": 3.0,
+		"被抓": 3.0, "被抓捕": 3.0, "回吐": 3.0, "转跌": 3.0,
+	}
+
+	// 否定词，用于反转情感极性
+	negationWords = map[string]struct{}{
+		"不": {}, "没": {}, "无": {}, "非": {}, "未": {}, "别": {}, "勿": {},
+	}
+
+	// 程度副词，用于调整情感强度
+	degreeWords = map[string]float64{
+		"非常": 1.8, "极其": 2.2, "太": 1.8, "很": 1.5,
+		"比较": 0.8, "稍微": 0.6, "有点": 0.7, "显著": 1.5,
+		"大幅": 1.8, "急剧": 2.0, "轻微": 0.6, "小幅": 0.7, "逾": 1.8, "超": 1.8,
+	}
+
+	// 转折词，用于识别情感转折
+	transitionWords = map[string]struct{}{
+		"但是": {}, "然而": {}, "不过": {}, "却": {}, "可是": {},
+	}
+)
+
+//go:embed data/dict/base.txt
+var baseDict string
+
+//go:embed data/dict/zh/s_1.txt
+var zhDict string
+
+func InitAnalyzeSentiment() {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.SugaredLogger.Error(fmt.Sprintf("panic: %v", r))
+		}
+	}()
+	// 加载简体中文词典
+	//err := seg.LoadDict("zh_s")
+	//if err != nil {
+	//	logger.SugaredLogger.Error(err.Error())
+	//}
+
+	err := seg.LoadDictEmbed(baseDict)
+	if err != nil {
+		logger.SugaredLogger.Error(err.Error())
+	} else {
+		logger.SugaredLogger.Info("加载默认词典成功")
+	}
+	seg.CalcToken()
+
+	stocks := &[]StockBasic{}
+	db.Dao.Model(&StockBasic{}).Find(stocks)
+	for _, stock := range *stocks {
+		if strutil.Trim(stock.Name) == "" {
+			continue
+		}
+		err := seg.AddToken(stock.Name, basefreq+100, "n")
+		if strutil.Trim(stock.BKName) != "" {
+			err = seg.AddToken(stock.BKName, basefreq+100, "n")
+		}
+		if err != nil {
+			logger.SugaredLogger.Errorf("添加%s失败:%s", stock.Name, err.Error())
+		}
+	}
+	logger.SugaredLogger.Info("加载股票名称词典成功")
+
+	stockhks := &[]models.StockInfoHK{}
+	db.Dao.Model(&models.StockInfoHK{}).Find(stockhks)
+	for _, stock := range *stockhks {
+		if strutil.Trim(stock.Name) == "" {
+			continue
+		}
+		err := seg.AddToken(stock.Name, basefreq+100, "n")
+		if strutil.Trim(stock.BKName) != "" {
+			err = seg.AddToken(stock.BKName, basefreq+100, "n")
+		}
+		if err != nil {
+			logger.SugaredLogger.Errorf("添加%s失败:%s", stock.Name, err.Error())
+		}
+	}
+	logger.SugaredLogger.Info("加载港股名称词典成功")
+	//stockus := &[]models.StockInfoUS{}
+	//db.Dao.Model(&models.StockInfoUS{}).Where("trim(name) != ?", "").Find(stockus)
+	//for _, stock := range *stockus {
+	//	err := seg.AddToken(stock.Name, 500)
+	//	if err != nil {
+	//		logger.SugaredLogger.Errorf("添加%s失败:%s", stock.Name, err.Error())
+	//	}
+	//}
+	tags := &[]models.Tags{}
+	db.Dao.Model(&models.Tags{}).Where("type = ?", "subject").Find(tags)
+	for _, tag := range *tags {
+		if tag.Name == "" {
+			continue
+		}
+		err := seg.AddToken(tag.Name, basefreq+100, "n")
+		if err != nil {
+			logger.SugaredLogger.Errorf("添加%s失败:%s", tag.Name, err.Error())
+		} else {
+			logger.SugaredLogger.Infof("添加tags词典[%s]成功", tag.Name)
+		}
+	}
+	logger.SugaredLogger.Info("加载tags词典成功")
+	seg.CalcToken()
+	//加载用户自定义词典 先判断用户词典是否存在
+	if fileutil.IsExist("data/dict/user.txt") {
+		lines, err := fileutil.ReadFileByLine("data/dict/user.txt")
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+			return
+		}
+		for _, line := range lines {
+			if len(line) == 0 || line[0] == '#' {
+				continue
+			}
+			k := strutil.SplitAndTrim(line, " ")
+			if len(k) == 0 {
+				continue
+			}
+			_, _, ok := seg.Find(k[0])
+			switch len(k) {
+			case 1:
+				if ok {
+					err = seg.ReAddToken(k[0], basefreq)
+				} else {
+					err = seg.AddToken(k[0], basefreq)
+				}
+			case 2:
+				freq, _ := convertor.ToFloat(k[1])
+				if ok {
+					err = seg.ReAddToken(k[0], freq)
+				} else {
+					err = seg.AddToken(k[0], freq)
+				}
+			case 3:
+				freq, _ := convertor.ToFloat(k[1])
+				if ok {
+					err = seg.ReAddToken(k[0], freq, k[2])
+				} else {
+					err = seg.AddToken(k[0], freq, k[2])
+				}
+			default:
+				logger.SugaredLogger.Errorf("用户词典格式错误:%s", line)
+			}
+			logger.SugaredLogger.Infof("添加用户词典[%s]成功", line)
+		}
+		if err != nil {
+			logger.SugaredLogger.Error(err.Error())
+		} else {
+			logger.SugaredLogger.Infof("加载用户词典成功")
+		}
+	} else {
+		logger.SugaredLogger.Info("用户词典不存在")
+	}
+	seg.CalcToken()
+}
+
+// getWordWeight 获取词汇权重
+func getWordWeight(word string) float64 {
+	// 从分词器获取词汇权重
+
+	freq, pos, ok := seg.Dictionary().Find([]byte(word))
+	if ok {
+		logger.SugaredLogger.Infof("获取%s的权重:%f,pos:%s,ok:%v", word, freq, pos, ok)
+		return freq
+	}
+	return 0
+}
+
+// SortByWeightAndFrequency 按权重和频次排序词频结果
+func SortByWeightAndFrequency(frequencies map[string]models.WordFreqWithWeight) []models.WordFreqWithWeight {
+	// 将map转换为slice以便排序
+	freqSlice := make([]models.WordFreqWithWeight, 0, len(frequencies))
+	for _, freq := range frequencies {
+		freqSlice = append(freqSlice, freq)
+	}
+
+	// 按权重*频次降序排列
+	sort.Slice(freqSlice, func(i, j int) bool {
+		return freqSlice[i].Weight*float64(freqSlice[i].Frequency) > freqSlice[j].Weight*float64(freqSlice[j].Frequency)
+	})
+	logger.SugaredLogger.Infof("排序后的结果:%v", freqSlice)
+
+	return freqSlice
+}
+
+// FilterAndSortWords 过滤标点符号并按权重频次排序
+func FilterAndSortWords(frequencies map[string]models.WordFreqWithWeight) []models.WordFreqWithWeight {
+	// 先过滤标点符号和分隔符
+	cleanFrequencies := FilterPunctuationAndSeparators(frequencies)
+
+	// 再按权重和频次排序
+	sortedFrequencies := SortByWeightAndFrequency(cleanFrequencies)
+
+	return sortedFrequencies
+}
+func FilterPunctuationAndSeparators(frequencies map[string]models.WordFreqWithWeight) map[string]models.WordFreqWithWeight {
+	filteredWords := make(map[string]models.WordFreqWithWeight)
+
+	for word, freqInfo := range frequencies {
+		// 过滤纯标点符号和分隔符
+		if !isPunctuationOrSeparator(word) {
+			filteredWords[word] = freqInfo
+		}
+	}
+	return filteredWords
+}
+
+// isPunctuationOrSeparator 判断是否为标点符号或分隔符
+func isPunctuationOrSeparator(word string) bool {
+	// 空字符串
+	if strings.TrimSpace(word) == "" {
+		return true
+	}
+
+	// 检查是否全部由标点符号组成
+	for _, r := range word {
+		if !unicode.IsPunct(r) && !unicode.IsSymbol(r) && !unicode.IsSpace(r) {
+			return false
+		}
+	}
+	return true
+}
+
+// FilterWithRegex 使用正则表达式过滤标点和特殊字符
+func FilterWithRegex(frequencies map[string]models.WordFreqWithWeight) map[string]models.WordFreqWithWeight {
+	filteredWords := make(map[string]models.WordFreqWithWeight)
+
+	// 匹配标点符号、特殊字符的正则表达式
+	punctuationRegex := regexp.MustCompile(`^[[:punct:][:space:]]+$`)
+
+	for word, freqInfo := range frequencies {
+		// 过滤纯标点符号
+		if !punctuationRegex.MatchString(word) && strings.TrimSpace(word) != "" {
+			filteredWords[word] = freqInfo
+		}
+	}
+	return filteredWords
+}
+
+// countWordFrequencyWithWeight 统计词频并包含权重信息
+func countWordFrequencyWithWeight(text string) map[string]models.WordFreqWithWeight {
+	words := splitWords(text)
+	freqMap := make(map[string]models.WordFreqWithWeight)
+
+	// 统计词频
+	wordCount := make(map[string]int)
+	for _, word := range words {
+		wordCount[word]++
+	}
+
+	// 构建包含权重的结果
+	for word, frequency := range wordCount {
+		weight := getWordWeight(word)
+		if weight >= basefreq {
+			freqMap[word] = models.WordFreqWithWeight{
+				Word:      word,
+				Frequency: frequency,
+				Weight:    weight,
+				Score:     float64(frequency) * weight,
+			}
+		}
+
+	}
+
+	return freqMap
+}
+
+// AnalyzeSentimentWithFreqWeight 带权重词频统计的情感分析
+func AnalyzeSentimentWithFreqWeight(text string) (models.SentimentResult, map[string]models.WordFreqWithWeight) {
+	// 原有情感分析逻辑
+	result := AnalyzeSentiment(text)
+
+	// 带权重的词频统计
+	frequencies := countWordFrequencyWithWeight(text)
+
+	return result, frequencies
+}
+
+const (
+	Positive models.SentimentType = iota
+	Negative
+	Neutral
+)
+
+// AnalyzeSentiment 判断文本的情感
+func AnalyzeSentiment(text string) models.SentimentResult {
+	// 初始化得分
+	score := 0.0
+	positiveCount := 0
+	negativeCount := 0
+
+	// 分词（简单按单个字符分割）
+	words := splitWords(text)
+
+	// 检查文本是否包含转折词，并分割成两部分
+	var transitionIndex int
+	var hasTransition bool
+	for i, word := range words {
+		if _, ok := transitionWords[word]; ok {
+			transitionIndex = i
+			hasTransition = true
+			break
+		}
+	}
+
+	// 处理有转折的文本
+	if hasTransition {
+		// 转折前的部分
+		preTransitionWords := words[:transitionIndex]
+		preScore, prePos, preNeg := calculateScore(preTransitionWords)
+
+		// 转折后的部分，权重加倍
+		postTransitionWords := words[transitionIndex+1:]
+		postScore, postPos, postNeg := calculateScore(postTransitionWords)
+		postScore *= 1.5 // 转折后的情感更重要
+
+		score = preScore + postScore
+		positiveCount = prePos + postPos
+		negativeCount = preNeg + postNeg
+	} else {
+		// 没有转折的文本
+		score, positiveCount, negativeCount = calculateScore(words)
+	}
+
+	// 确定情感类别
+	var category models.SentimentType
+	switch {
+	case score > 1.0:
+		category = Positive
+	case score < -1.0:
+		category = Negative
+	default:
+		category = Neutral
+	}
+
+	return models.SentimentResult{
+		Score:         score,
+		Category:      category,
+		PositiveCount: positiveCount,
+		NegativeCount: negativeCount,
+		Description:   GetSentimentDescription(category),
+	}
+}
+
+// 计算情感得分
+func calculateScore(words []string) (float64, int, int) {
+	score := 0.0
+	positiveCount := 0
+	negativeCount := 0
+
+	// 遍历每个词，计算情感得分
+	for i, word := range words {
+		// 首先检查是否为程度副词
+		degree, isDegree := degreeWords[word]
+
+		// 检查是否为否定词
+		_, isNegation := negationWords[word]
+
+		// 检查是否为金融正面词
+		if posScore, isPositive := positiveFinanceWords[word]; isPositive {
+			// 检查前一个词是否为否定词或程度副词
+			if i > 0 {
+				prevWord := words[i-1]
+				if _, isNeg := negationWords[prevWord]; isNeg {
+					score -= posScore
+					negativeCount++
+					continue
+				}
+
+				if deg, isDeg := degreeWords[prevWord]; isDeg {
+					score += posScore * deg
+					positiveCount++
+					continue
+				}
+			}
+
+			score += posScore
+			positiveCount++
+			continue
+		}
+
+		// 检查是否为金融负面词
+		if negScore, isNegative := negativeFinanceWords[word]; isNegative {
+			// 检查前一个词是否为否定词或程度副词
+			if i > 0 {
+				prevWord := words[i-1]
+				if _, isNeg := negationWords[prevWord]; isNeg {
+					score += negScore
+					positiveCount++
+					continue
+				}
+
+				if deg, isDeg := degreeWords[prevWord]; isDeg {
+					score -= negScore * deg
+					negativeCount++
+					continue
+				}
+			}
+
+			score -= negScore
+			negativeCount++
+			continue
+		}
+
+		// 处理程度副词（如果后面跟着情感词）
+		if isDegree && i+1 < len(words) {
+			nextWord := words[i+1]
+
+			if posScore, isPositive := positiveFinanceWords[nextWord]; isPositive {
+				score += posScore * degree
+				positiveCount++
+				continue
+			}
+
+			if negScore, isNegative := negativeFinanceWords[nextWord]; isNegative {
+				score -= negScore * degree
+				negativeCount++
+				continue
+			}
+		}
+
+		// 处理否定词（如果后面跟着情感词）
+		if isNegation && i+1 < len(words) {
+			nextWord := words[i+1]
+
+			if posScore, isPositive := positiveFinanceWords[nextWord]; isPositive {
+				score -= posScore
+				negativeCount++
+				continue
+			}
+
+			if negScore, isNegative := negativeFinanceWords[nextWord]; isNegative {
+				score += negScore
+				positiveCount++
+				continue
+			}
+		}
+	}
+
+	return score, positiveCount, negativeCount
+}
+
+// 简单的分词函数，考虑了中文和英文
+func splitWords(text string) []string {
+	return seg.Cut(text, true)
+}
+
+// GetSentimentDescription 获取情感类别的文本描述
+func GetSentimentDescription(category models.SentimentType) string {
+	switch category {
+	case Positive:
+		return "看涨"
+	case Negative:
+		return "看跌"
+	case Neutral:
+		return "中性"
+	default:
+		return "未知"
+	}
+}
+
+func main() {
+	// 从命令行读取输入
+	reader := bufio.NewReader(os.Stdin)
+	fmt.Println("请输入要分析的股市相关文本（输入exit退出）：")
+
+	for {
+		fmt.Print("> ")
+		text, err := reader.ReadString('\n')
+		if err != nil {
+			fmt.Println("读取输入时出错:", err)
+			continue
+		}
+
+		// 去除换行符
+		text = strings.TrimSpace(text)
+
+		// 检查是否退出
+		if text == "exit" {
+			break
+		}
+
+		// 分析情感
+		result := AnalyzeSentiment(text)
+
+		// 输出结果
+		fmt.Printf("情感分析结果: %s (得分: %.2f, 正面词:%d, 负面词:%d)\n",
+			GetSentimentDescription(result.Category),
+			result.Score,
+			result.PositiveCount,
+			result.NegativeCount)
+	}
+}
+
+func SaveAnalyzeSentimentWithFreqWeight(frequencies []models.WordFreqWithWeight) {
+
+	sort.Slice(frequencies, func(i, j int) bool {
+		return frequencies[i].Frequency > frequencies[j].Frequency
+	})
+	wordAnalyzes := make([]models.WordAnalyze, 0)
+	for _, freq := range frequencies[:10] {
+		wordAnalyze := models.WordAnalyze{
+			WordFreqWithWeight: freq,
+		}
+		wordAnalyzes = append(wordAnalyzes, wordAnalyze)
+	}
+	db.Dao.CreateInBatches(wordAnalyzes, 1000)
+}
+
+func SaveStockSentimentAnalysis(result models.SentimentResult) {
+	db.Dao.Create(&models.SentimentResultAnalyze{
+		SentimentResult: result,
+	})
+}
+
+func NewsAnalyze(text string, save bool) (models.SentimentResult, []models.WordFreqWithWeight) {
+	if text == "" {
+		telegraphs := NewMarketNewsApi().GetNews24HoursList("", 1000*10)
+		messageText := strings.Builder{}
+		for _, telegraph := range *telegraphs {
+			messageText.WriteString(telegraph.Content + "\n")
+		}
+		text = messageText.String()
+	}
+	result, frequencies := AnalyzeSentimentWithFreqWeight(text)
+	// 过滤标点符号和分隔符
+	cleanFrequencies := FilterAndSortWords(frequencies)
+	if save {
+		go SaveAnalyzeSentimentWithFreqWeight(cleanFrequencies)
+		go SaveStockSentimentAnalysis(result)
+	}
+	return result, cleanFrequencies
+}

backend/data/stock_sentiment_analysis_test.go

@@ -0,0 +1,49 @@
+package data
+
+import (
+	"fmt"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"strings"
+	"testing"
+
+	"github.com/duke-git/lancet/v2/random"
+)
+
+// @Author spark
+// @Date 2025/6/19 13:05
+// @Desc
+//-----------------------------------------------------------------------------------
+
+func TestAnalyzeSentiment(t *testing.T) {
+
+	db.Init("../../data/stock.db")
+	InitAnalyzeSentiment()
+
+	messageText := strings.Builder{}
+	news := NewMarketNewsApi().GetNewsList2("", random.RandInt(500, 1000))
+	for _, telegraph := range *news {
+		messageText.WriteString(telegraph.Content + "\n")
+	}
+
+	text := messageText.String()
+	//text = " 【周六你需要知道的隔夜全球要闻：美联储鸽声重振 美股走势回稳】 1、纽约联储行长威廉姆斯表示，随着劳动力市场走软，美联储近期内仍有再次降息的空间。 2、美联储理事斯蒂芬·米兰表示，自上次联邦公开市场委员会（FOMC）会议以来的经济数据应“促使人们偏向鸽派立场”。 3、波士顿联邦储备银行行长柯林斯表示，由于通胀可能在一段时间内保持高位，维持利率不变“目前合适”。 4、据CME“美联储观察”，截至北京时间11月22日6时30分，美联储12月降息25个基点的概率为69.4%，维持利率不变的概率为30.6%。 5、美国劳工统计局表示，11月CPI报告将于12月18日发布，同时取消了10月CPI报告发布，表示无法追溯采集政府停摆期间未能收集的部分数据。 6、俄罗斯总统普京表示，已收到美提出解决俄乌冲突的计划，俄罗斯愿意进行和平谈判。美国总统特朗普表示，他认为27日是乌克兰接受美国支持的和平计划的最后期限。 7、美联储高官鸽派言论提振市场情绪，美股三大指数收盘集体上涨，道琼斯指数涨1.08%，标普500指数涨0.98%，纳斯达克综合指数涨0.88%。甲骨文跌超5%，英伟达跌超1%。纳指本周累计跌2.74%，标普500指数累跌1.95%，道指累跌1.91%。英伟达本周累跌5.9%。 8、热门中概股多数上涨，纳斯达克中国金龙指数收涨1.23%。蔚来涨超3%，哔哩哔哩、理想汽车涨超2%，京东、小鹏汽车涨超1%。 9、国际油价下跌，交易员评估乌克兰与俄罗斯可能达成和平协议的前景。WTI 1月期货下跌1.6%，结算价报每桶58.06美元，为过去五个交易日中第四次下跌。布伦特1月期货下跌1.3%，结算价报每桶62.56美元。 10、美联储延长压力测试改进方案征询期，为银行反馈提供更多时间。 11、由于美国人对个人财务状况的看法恶化，美国消费者信心在11月跌至接近纪录最低水平；密歇根大学数据显示，11月消费者信心指数降至51，10月为53.6。 12、日本央行政策委员会委员Kazuyuki Masu表示，日本央行接近作出加息决定。 13、穆迪将意大利信用评级从BAA3上调至BAA2，展望稳定。\n"
+	//text = "财联社电：英伟达周五冲高回落，股价涨幅收于1%，市场普遍认为其走势疲软"
+	//text = "【本轮巴以冲突已致加沙地带69733人死亡】财联社11月22日电，当地时间22日下午，以军对加沙城西部一辆汽车发动空袭，已造成5人死亡，多人受伤。自2023年10月7日巴以新一轮大规模冲突爆发以来，以色列对加沙地带的袭击已造成69733人死亡、170863人受伤。"
+	//text = "【牛肉加工亏损 美国泰森公司关停缩减相关业务】财联社11月22日电，受牛肉加工业务亏损影响，当地时间21日，美国泰森食品公司发布公告称，将关闭位于内布拉斯加州的一家大型牛肉加工厂，还计划缩小得克萨斯州一家牛肉加工厂的生产规模。根据泰森食品公司的公告，被关闭的这家工厂位于内布拉斯加州列克星敦，日均可宰杀并处理大约5000头牛，约占全美日均牛肉屠宰数量的4.8%。与此同时，公司还计划缩小得克萨斯州一家牛肉加工厂的生产规模，这家工厂每天大约可屠宰6000头牛。据悉，泰森此次业务调整影响两个工厂大约5000个工作岗位。《华尔街日报》报道称，泰森是美国四大肉类加工公司中首家关闭主要牛肉加工厂的公司，其最新财报显示，2025财年牛肉加工是唯一亏损的业务部门，调整后的营业亏损为4.26亿美元。"
+	// 分析情感
+	words := splitWords(text)
+	fmt.Println(strings.Join(words, " "))
+	result, frequencies := AnalyzeSentimentWithFreqWeight(text)
+	// 过滤标点符号和分隔符
+	cleanFrequencies := FilterPunctuationAndSeparators(frequencies)
+	// 输出结果
+	logger.SugaredLogger.Infof("情感分析结果: %s (得分: %.2f, 正面词:%d, 负面词:%d)\n 词频统计结果: %v",
+		result.Description,
+		result.Score,
+		result.PositiveCount,
+		result.NegativeCount,
+		cleanFrequencies,
+	)
+
+}

backend/data/tushare_data_api.go

@@ -0,0 +1,93 @@
+package data
+
+import (
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/slice"
+	"github.com/duke-git/lancet/v2/strutil"
+	"github.com/go-resty/resty/v2"
+	"go-stock/backend/logger"
+	"strings"
+	"time"
+)
+
+// @Author spark
+// @Date 2025/2/17 12:33
+// @Desc
+//-----------------------------------------------------------------------------------
+
+type TushareApi struct {
+	client *resty.Client
+	config *SettingConfig
+}
+
+func NewTushareApi(config *SettingConfig) *TushareApi {
+	return &TushareApi{
+		client: resty.New(),
+		config: config,
+	}
+}
+
+// GetDaily tushare A股日线行情
+func (receiver TushareApi) GetDaily(tsCode, startDate, endDate string, crawlTimeOut int64) string {
+	//logger.SugaredLogger.Debugf("tushare daily request: ts_code=%s, start_date=%s, end_date=%s", tsCode, startDate, endDate)
+	fields := "ts_code,trade_date,open,high,low,close,pre_close,change,pct_chg,vol,amount"
+	resp := &TushareStockBasicResponse{}
+	stockType := getStockType(tsCode)
+	tsCodeNEW := getTsCode(tsCode)
+	//logger.SugaredLogger.Debugf("tushare daily request: %s,tsCode:%s,tsCodeNEW:%s", stockType, tsCode, tsCodeNEW)
+	_, err := receiver.client.SetTimeout(time.Duration(crawlTimeOut)*time.Second).R().
+		SetHeader("content-type", "application/json").
+		SetBody(&TushareRequest{
+			ApiName: stockType,
+			Token:   receiver.config.TushareToken,
+			Params: map[string]any{
+				"ts_code":    tsCodeNEW,
+				"start_date": startDate,
+				"end_date":   endDate,
+			},
+			Fields: fields}).
+		SetResult(resp).
+		Post(tushareApiUrl)
+	if err != nil {
+		logger.SugaredLogger.Error(err)
+		return ""
+	}
+	res := ""
+	if resp.Data.Items != nil && len(resp.Data.Items) > 0 {
+		fieldsStr := slice.JoinFunc(resp.Data.Fields, ",", func(s string) string {
+			return "\"" + convertor.ToString(s) + "\""
+		})
+		res += fieldsStr + "\n"
+		for _, item := range resp.Data.Items {
+			//logger.SugaredLogger.Debugf("%s", slice.Join(item, ","))
+			t := slice.JoinFunc(item, ",", func(s any) any {
+				return "\"" + convertor.ToString(s) + "\""
+			})
+			res += t + "\n"
+		}
+	}
+	//logger.SugaredLogger.Debugf("tushare response: %s", res)
+	return res
+}
+
+func getTsCode(code string) any {
+	if strutil.HasPrefixAny(code, []string{"US", "us", "gb_"}) {
+		code = strings.Replace(code, "gb_", "", 1)
+		code = strings.Replace(code, "us", "", 1)
+		return code
+	}
+	return code
+}
+
+func getStockType(code string) string {
+	if strutil.HasSuffixAny(code, []string{"SZ", "SH", "sh", "sz"}) {
+		return "daily"
+	}
+	if strutil.HasSuffixAny(code, []string{"HK", "hk"}) {
+		return "hk_daily"
+	}
+	if strutil.HasPrefixAny(code, []string{"US", "us", "gb_"}) {
+		return "us_daily"
+	}
+	return ""
+}

backend/data/tushare_data_api_test.go

@@ -0,0 +1,29 @@
+package data
+
+import (
+	"go-stock/backend/db"
+	"testing"
+)
+
+// @Author spark
+// @Date 2025/2/17 12:44
+// @Desc
+// -----------------------------------------------------------------------------------
+func TestGetDaily(t *testing.T) {
+	db.Init("../../data/stock.db")
+	tushareApi := NewTushareApi(GetSettingConfig())
+	res := tushareApi.GetDaily("00927.HK", "20250101", "20250217", 30)
+	t.Log(res)
+
+}
+
+func TestGetUSDaily(t *testing.T) {
+	db.Init("../../data/stock.db")
+	tushareApi := NewTushareApi(GetSettingConfig())
+
+	res := tushareApi.GetDaily("gb_AAPL", "20250101", "20250217", 30)
+	t.Log(res)
+
+	//
+
+}

backend/data/utils_test.go

@@ -0,0 +1,47 @@
+package data
+
+import (
+	"github.com/duke-git/lancet/v2/slice"
+	"go-stock/backend/logger"
+	"os"
+	"testing"
+)
+
+// TestRemoveNonPrintable tests the RemoveAllBlankChar function.
+func TestRemoveNonPrintable(t *testing.T) {
+	//tests := []struct {
+	//	input    string
+	//	expected string
+	//}{
+	//	{"新 希 望", "新希望"},
+	//	{"", ""},
+	//	{"Hello, World!", "Hello, World!"},
+	//	{"\x00\x01\x02", ""},
+	//	{"Hello\x00World", "HelloWorld"},
+	//	{"\x1F\x20\x7E\x7F", " \x7E"},
+	//}
+
+	//for _, test := range tests {
+	//	actual := RemoveAllBlankChar(test.input)
+	//	if actual != test.expected {
+	//		t.Errorf("RemoveAllBlankChar(%q) = %q; expected %q", test.input, actual, test.expected)
+	//	}
+	//}
+	txt := "新 希 望"
+	txt2 := RemoveAllBlankChar(txt)
+	logger.SugaredLogger.Infof("RemoveAllBlankChar(%s)", txt2)
+	logger.SugaredLogger.Infof("RemoveAllBlankChar(%s)", txt)
+
+}
+
+func TestConvertStockCodeToTushareCode(t *testing.T) {
+	logger.SugaredLogger.Infof("ConvertStockCodeToTushareCode(%s)", ConvertStockCodeToTushareCode("sz000802"))
+	logger.SugaredLogger.Infof("ConvertTushareCodeToStockCode(%s)", ConvertTushareCodeToStockCode("000802.SZ"))
+}
+func TestReplaceSensitiveWords(t *testing.T) {
+	txt := "新 希 望习近平"
+	txt2 := ReplaceSensitiveWords(txt)
+	logger.SugaredLogger.Infof("ReplaceSensitiveWords(%s)", txt2)
+
+	os.WriteFile("words.txt", []byte(slice.Join(SensitiveWords, "\n")), 0644)
+}

backend/db/db.go

@@ -1,13 +1,14 @@
 package db
 
 import (
+	"log"
+	"os"
+	"time"
+
 	"github.com/glebarez/sqlite"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	"gorm.io/plugin/dbresolver"
-	"log"
-	"os"
-	"time"
 )
 
 var Dao *gorm.DB
@@ -26,7 +27,7 @@ func Init(sqlitePath string) {
 	var openDb *gorm.DB
 	var err error
 	if sqlitePath == "" {
-		sqlitePath = "data/stock.db?cache=shared&mode=rwc&_journal_mode=WAL"
+		sqlitePath = "data/stock.db?cache_size=-524288&journal_mode=WAL"
 	}
 	openDb, err = gorm.Open(sqlite.Open(sqlitePath), &gorm.Config{
 		Logger:                                   dbLogger,
@@ -48,8 +49,8 @@ func Init(sqlitePath string) {
 	if err != nil {
 		log.Fatalf("openDb.DB error is  %s", err.Error())
 	}
-	dbCon.SetMaxIdleConns(10)
-	dbCon.SetMaxOpenConns(100)
+	dbCon.SetMaxIdleConns(4)
+	dbCon.SetMaxOpenConns(10)
 	dbCon.SetConnMaxLifetime(time.Hour)
 	Dao = openDb
 }

backend/models/models.go

@@ -0,0 +1,954 @@
+package models
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/plugin/soft_delete"
+)
+
+// @Author spark
+// @Date 2025/2/6 15:25
+// @Desc
+//-----------------------------------------------------------------------------------
+
+type GitHubReleaseVersion struct {
+	Url       string `json:"url"`
+	AssetsUrl string `json:"assets_url"`
+	UploadUrl string `json:"upload_url"`
+	HtmlUrl   string `json:"html_url"`
+	Id        int    `json:"id"`
+	Author    struct {
+		Login             string `json:"login"`
+		Id                int    `json:"id"`
+		NodeId            string `json:"node_id"`
+		AvatarUrl         string `json:"avatar_url"`
+		GravatarId        string `json:"gravatar_id"`
+		Url               string `json:"url"`
+		HtmlUrl           string `json:"html_url"`
+		FollowersUrl      string `json:"followers_url"`
+		FollowingUrl      string `json:"following_url"`
+		GistsUrl          string `json:"gists_url"`
+		StarredUrl        string `json:"starred_url"`
+		SubscriptionsUrl  string `json:"subscriptions_url"`
+		OrganizationsUrl  string `json:"organizations_url"`
+		ReposUrl          string `json:"repos_url"`
+		EventsUrl         string `json:"events_url"`
+		ReceivedEventsUrl string `json:"received_events_url"`
+		Type              string `json:"type"`
+		UserViewType      string `json:"user_view_type"`
+		SiteAdmin         bool   `json:"site_admin"`
+	} `json:"author"`
+	NodeId          string    `json:"node_id"`
+	TagName         string    `json:"tag_name"`
+	TargetCommitish string    `json:"target_commitish"`
+	Name            string    `json:"name"`
+	Draft           bool      `json:"draft"`
+	Prerelease      bool      `json:"prerelease"`
+	CreatedAt       time.Time `json:"created_at"`
+	PublishedAt     time.Time `json:"published_at"`
+	Assets          []struct {
+		Url      string `json:"url"`
+		Id       int    `json:"id"`
+		NodeId   string `json:"node_id"`
+		Name     string `json:"name"`
+		Label    string `json:"label"`
+		Uploader struct {
+			Login             string `json:"login"`
+			Id                int    `json:"id"`
+			NodeId            string `json:"node_id"`
+			AvatarUrl         string `json:"avatar_url"`
+			GravatarId        string `json:"gravatar_id"`
+			Url               string `json:"url"`
+			HtmlUrl           string `json:"html_url"`
+			FollowersUrl      string `json:"followers_url"`
+			FollowingUrl      string `json:"following_url"`
+			GistsUrl          string `json:"gists_url"`
+			StarredUrl        string `json:"starred_url"`
+			SubscriptionsUrl  string `json:"subscriptions_url"`
+			OrganizationsUrl  string `json:"organizations_url"`
+			ReposUrl          string `json:"repos_url"`
+			EventsUrl         string `json:"events_url"`
+			ReceivedEventsUrl string `json:"received_events_url"`
+			Type              string `json:"type"`
+			UserViewType      string `json:"user_view_type"`
+			SiteAdmin         bool   `json:"site_admin"`
+		} `json:"uploader"`
+		ContentType        string    `json:"content_type"`
+		State              string    `json:"state"`
+		Size               int       `json:"size"`
+		DownloadCount      int       `json:"download_count"`
+		CreatedAt          time.Time `json:"created_at"`
+		UpdatedAt          time.Time `json:"updated_at"`
+		BrowserDownloadUrl string    `json:"browser_download_url"`
+	} `json:"assets"`
+	TarballUrl string `json:"tarball_url"`
+	ZipballUrl string `json:"zipball_url"`
+	Body       string `json:"body"`
+	Tag        Tag    `json:"tag"`
+	Commit     Commit `json:"commit"`
+}
+
+type Tag struct {
+	Ref    string `json:"ref"`
+	NodeId string `json:"node_id"`
+	Url    string `json:"url"`
+	Object struct {
+		Sha  string `json:"sha"`
+		Type string `json:"type"`
+		Url  string `json:"url"`
+	} `json:"object"`
+}
+
+type Commit struct {
+	Sha     string `json:"sha"`
+	NodeId  string `json:"node_id"`
+	Url     string `json:"url"`
+	HtmlUrl string `json:"html_url"`
+	Author  struct {
+		Name  string    `json:"name"`
+		Email string    `json:"email"`
+		Date  time.Time `json:"date"`
+	} `json:"author"`
+	Committer struct {
+		Name  string    `json:"name"`
+		Email string    `json:"email"`
+		Date  time.Time `json:"date"`
+	} `json:"committer"`
+	Tree struct {
+		Sha string `json:"sha"`
+		Url string `json:"url"`
+	} `json:"tree"`
+	Message string `json:"message"`
+	Parents []struct {
+		Sha     string `json:"sha"`
+		Url     string `json:"url"`
+		HtmlUrl string `json:"html_url"`
+	} `json:"parents"`
+	Verification struct {
+		Verified   bool        `json:"verified"`
+		Reason     string      `json:"reason"`
+		Signature  interface{} `json:"signature"`
+		Payload    interface{} `json:"payload"`
+		VerifiedAt interface{} `json:"verified_at"`
+	} `json:"verification"`
+}
+
+type AIResponseResult struct {
+	gorm.Model
+	ChatId    string                `json:"chatId"`
+	ModelName string                `json:"modelName"`
+	StockCode string                `json:"stockCode"`
+	StockName string                `json:"stockName"`
+	Question  string                `json:"question"`
+	Content   string                `json:"content"`
+	IsDel     soft_delete.DeletedAt `gorm:"softDelete:flag"`
+}
+
+func (receiver AIResponseResult) TableName() string {
+	return "ai_response_result"
+}
+
+// AIResponseResultQuery 分页查询参数
+type AIResponseResultQuery struct {
+	Page      int    `form:"page" json:"page"`           // 页码
+	PageSize  int    `form:"pageSize" json:"pageSize"`   // 每页大小
+	ChatId    string `form:"chatId" json:"chatId"`       // 聊天ID筛选
+	ModelName string `form:"modelName" json:"modelName"` // 模型名称筛选
+	StockCode string `form:"stockCode" json:"stockCode"` // 股票代码筛选
+	StockName string `form:"stockName" json:"stockName"` // 股票名称筛选
+	Question  string `form:"question" json:"question"`   // 问题内容模糊搜索
+	StartDate string `form:"startDate" json:"startDate"` // 开始日期
+	EndDate   string `form:"endDate" json:"endDate"`     // 结束日期
+}
+
+// AIResponseResultPageResp 分页查询响应
+type AIResponseResultPageResp struct {
+	Code    int                      `json:"code"`
+	Message string                   `json:"message"`
+	Data    AIResponseResultPageData `json:"data"`
+}
+
+type AIResponseResultPageData struct {
+	List       []AIResponseResult `json:"list"`
+	Total      int64              `json:"total"`
+	Page       int                `json:"page"`
+	PageSize   int                `json:"pageSize"`
+	TotalPages int                `json:"totalPages"`
+}
+
+type VersionInfo struct {
+	gorm.Model
+	Version           string                `json:"version"`
+	Content           string                `json:"content"`
+	Icon              string                `json:"icon"`
+	Alipay            string                `json:"alipay"`
+	Wxpay             string                `json:"wxpay"`
+	Wxgzh             string                `json:"wxgzh"`
+	BuildTimeStamp    int64                 `json:"buildTimeStamp"`
+	OfficialStatement string                `json:"officialStatement"`
+	IsDel             soft_delete.DeletedAt `gorm:"softDelete:flag"`
+}
+
+func (receiver VersionInfo) TableName() string {
+	return "version_info"
+}
+
+type StockInfoHK struct {
+	gorm.Model
+	Code     string                `json:"code"`
+	Name     string                `json:"name"`
+	FullName string                `json:"fullName"`
+	EName    string                `json:"eName"`
+	IsDel    soft_delete.DeletedAt `gorm:"softDelete:flag"`
+	BKName   string                `json:"bk_name"`
+	BKCode   string                `json:"bk_code"`
+}
+
+func (receiver StockInfoHK) TableName() string {
+	return "stock_base_info_hk"
+}
+
+type StockInfoUS struct {
+	gorm.Model
+	Code     string                `json:"code"`
+	Name     string                `json:"name"`
+	FullName string                `json:"fullName"`
+	EName    string                `json:"eName"`
+	Exchange string                `json:"exchange"`
+	Type     string                `json:"type"`
+	IsDel    soft_delete.DeletedAt `gorm:"softDelete:flag"`
+	BKName   string                `json:"bk_name"`
+	BKCode   string                `json:"bk_code"`
+}
+
+func (receiver StockInfoUS) TableName() string {
+	return "stock_base_info_us"
+}
+
+type Resp struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Error   struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+		Param   string `json:"param"`
+		Type    string `json:"type"`
+	} `json:"error"`
+}
+
+type PromptTemplate struct {
+	ID        int `gorm:"primarykey"`
+	CreatedAt time.Time
+	UpdatedAt time.Time
+	Name      string `json:"name"`
+	Content   string `json:"content"`
+	Type      string `json:"type"`
+}
+
+func (p PromptTemplate) TableName() string {
+	return "prompt_templates"
+}
+
+type Prompt struct {
+	ID      int    `json:"ID"`
+	Name    string `json:"name"`
+	Content string `json:"content"`
+	Type    string `json:"type"`
+}
+
+type Telegraph struct {
+	gorm.Model
+	Time            string          `json:"time"`
+	DataTime        *time.Time      `json:"dataTime" gorm:"index"`
+	Title           string          `json:"title" gorm:"index"`
+	Content         string          `json:"content" gorm:"index"`
+	SubjectTags     []string        `json:"subjects" gorm:"-:all"`
+	StocksTags      []string        `json:"stocks" gorm:"-:all"`
+	IsRed           bool            `json:"isRed" gorm:"index"`
+	Url             string          `json:"url"`
+	Source          string          `json:"source" gorm:"index"`
+	TelegraphTags   []TelegraphTags `json:"tags" gorm:"-:migration;foreignKey:TelegraphId"`
+	SentimentResult string          `json:"sentimentResult" gorm:"index"`
+}
+type TelegraphTags struct {
+	gorm.Model
+	TagId       uint `json:"tagId"`
+	TelegraphId uint `json:"telegraphId"`
+}
+
+func (t TelegraphTags) TableName() string {
+	return "telegraph_tags"
+}
+
+type Tags struct {
+	gorm.Model
+	Name string `json:"name"`
+	Type string `json:"type"`
+}
+
+func (p Tags) TableName() string {
+	return "tags"
+}
+
+func (p Telegraph) TableName() string {
+	return "telegraph_list"
+}
+
+type SinaStockInfo struct {
+	Symbol        string `json:"symbol"`
+	Name          string `json:"name"`
+	Engname       string `json:"engname"`
+	Tradetype     string `json:"tradetype"`
+	Lasttrade     string `json:"lasttrade"`
+	Prevclose     string `json:"prevclose"`
+	Open          string `json:"open"`
+	High          string `json:"high"`
+	Low           string `json:"low"`
+	Volume        string `json:"volume"`
+	Currentvolume string `json:"currentvolume"`
+	Amount        string `json:"amount"`
+	Ticktime      string `json:"ticktime"`
+	Buy           string `json:"buy"`
+	Sell          string `json:"sell"`
+	High52Week    string `json:"high_52week"`
+	Low52Week     string `json:"low_52week"`
+	Eps           string `json:"eps"`
+	Dividend      string `json:"dividend"`
+	StocksSum     string `json:"stocks_sum"`
+	Pricechange   string `json:"pricechange"`
+	Changepercent string `json:"changepercent"`
+	MarketValue   string `json:"market_value"`
+	PeRatio       string `json:"pe_ratio"`
+}
+
+type LongTigerRankData struct {
+	ACCUMAMOUNT      float64 `json:"ACCUM_AMOUNT"`
+	BILLBOARDBUYAMT  float64 `json:"BILLBOARD_BUY_AMT"`
+	BILLBOARDDEALAMT float64 `json:"BILLBOARD_DEAL_AMT"`
+	BILLBOARDNETAMT  float64 `json:"BILLBOARD_NET_AMT"`
+	BILLBOARDSELLAMT float64 `json:"BILLBOARD_SELL_AMT"`
+	CHANGERATE       float64 `json:"CHANGE_RATE"`
+	CLOSEPRICE       float64 `json:"CLOSE_PRICE"`
+	DEALAMOUNTRATIO  float64 `json:"DEAL_AMOUNT_RATIO"`
+	DEALNETRATIO     float64 `json:"DEAL_NET_RATIO"`
+	EXPLAIN          string  `json:"EXPLAIN"`
+	EXPLANATION      string  `json:"EXPLANATION"`
+	FREEMARKETCAP    float64 `json:"FREE_MARKET_CAP"`
+	SECUCODE         string  `json:"SECUCODE" gorm:"index"`
+	SECURITYCODE     string  `json:"SECURITY_CODE"`
+	SECURITYNAMEABBR string  `json:"SECURITY_NAME_ABBR"`
+	SECURITYTYPECODE string  `json:"SECURITY_TYPE_CODE"`
+	TRADEDATE        string  `json:"TRADE_DATE" gorm:"index"`
+	TURNOVERRATE     float64 `json:"TURNOVERRATE"`
+}
+
+func (l LongTigerRankData) TableName() string {
+	return "long_tiger_rank"
+}
+
+type TVNews struct {
+	Id         string `json:"id"`
+	Title      string `json:"title"`
+	Published  int    `json:"published"`
+	Urgency    int    `json:"urgency"`
+	Permission string `json:"permission"`
+	StoryPath  string `json:"storyPath"`
+	Provider   struct {
+		Id     string `json:"id"`
+		Name   string `json:"name"`
+		LogoId string `json:"logo_id"`
+	} `json:"provider"`
+}
+type TVNewsDetail struct {
+	ShortDescription string `json:"shortDescription"`
+	Tags             []struct {
+		Title string `json:"title"`
+		Args  []struct {
+			Id    string `json:"id"`
+			Value string `json:"value"`
+		} `json:"args"`
+	} `json:"tags"`
+	Copyright string `json:"copyright"`
+	Id        string `json:"id"`
+	Title     string `json:"title"`
+	Published int    `json:"published"`
+	Urgency   int    `json:"urgency"`
+	StoryPath string `json:"storyPath"`
+}
+
+type XUEQIUHot struct {
+	Data struct {
+		Items     []HotItem `json:"items"`
+		ItemsSize int       `json:"items_size"`
+	} `json:"data"`
+	ErrorCode        int    `json:"error_code"`
+	ErrorDescription string `json:"error_description"`
+}
+
+type HotItem struct {
+	Type         int         `json:"type" md:"-"`
+	Code         string      `json:"code" md:"股票代码"`
+	Name         string      `json:"name" md:"股票名称"`
+	Value        float64     `json:"value" md:"热度"`
+	Increment    int         `json:"increment" md:"热度变化"`
+	RankChange   int         `json:"rank_change" md:"排名变化"`
+	HasExist     interface{} `json:"has_exist" md:"-"`
+	Symbol       string      `json:"symbol" md:"-"`
+	Percent      float64     `json:"percent" md:"涨跌幅(%)"`
+	Current      float64     `json:"current" md:"股价"`
+	Chg          float64     `json:"chg" md:"股价变化"`
+	Exchange     string      `json:"exchange" md:"交易所代码"`
+	StockType    int         `json:"stock_type" md:"-"`
+	SubType      string      `json:"sub_type" md:"-"`
+	Ad           int         `json:"ad" md:"-"`
+	AdId         interface{} `json:"ad_id" md:"-"`
+	ContentId    interface{} `json:"content_id" md:"-"`
+	Page         interface{} `json:"page" md:"-"`
+	Model        interface{} `json:"model" md:"-"`
+	Location     interface{} `json:"location" md:"-"`
+	TradeSession interface{} `json:"trade_session" md:"-"`
+	CurrentExt   interface{} `json:"current_ext" md:"-"`
+	PercentExt   interface{} `json:"percent_ext" md:"-"`
+}
+
+type HotEvent struct {
+	PicSize     interface{} `json:"pic_size"`
+	Tag         string      `json:"tag"`
+	Id          int         `json:"id"`
+	Pic         string      `json:"pic"`
+	Hot         int         `json:"hot"`
+	StatusCount int         `json:"status_count"`
+	Content     string      `json:"content"`
+}
+
+type GDP struct {
+	REPORTDATE           string  `json:"REPORT_DATE" md:"报告时间"`
+	TIME                 string  `json:"TIME" md:"报告期"`
+	DOMESTICLPRODUCTBASE float64 `json:"DOMESTICL_PRODUCT_BASE" md:"国内生产总值(亿元)"`
+	SUMSAME              float64 `json:"SUM_SAME" md:"国内生产总值同比增长(%)"`
+	FIRSTPRODUCTBASE     float64 `json:"FIRST_PRODUCT_BASE" md:"第一产业(亿元)"`
+	FIRSTSAME            int     `json:"FIRST_SAME" md:"第一产业同比增长(%)"`
+	SECONDPRODUCTBASE    float64 `json:"SECOND_PRODUCT_BASE" md:"第二产业(亿元)"`
+	SECONDSAME           float64 `json:"SECOND_SAME" md:"第二产业同比增长(%)"`
+	THIRDPRODUCTBASE     float64 `json:"THIRD_PRODUCT_BASE" md:"第三产业(亿元)"`
+	THIRDSAME            float64 `json:"THIRD_SAME" md:"第三产业同比增长(%)"`
+}
+type CPI struct {
+	REPORTDATE         string  `json:"REPORT_DATE" md:"报告时间"`
+	TIME               string  `json:"TIME" md:"报告期"`
+	NATIONALBASE       float64 `json:"NATIONAL_BASE" md:"全国当月"`
+	NATIONALSAME       float64 `json:"NATIONAL_SAME" md:"全国当月同比增长(%)"`
+	NATIONALSEQUENTIAL float64 `json:"NATIONAL_SEQUENTIAL" md:"全国当月环比增长(%)"`
+	NATIONALACCUMULATE float64 `json:"NATIONAL_ACCUMULATE" md:"全国当月累计"`
+	CITYBASE           float64 `json:"CITY_BASE" md:"城市当月"`
+	CITYSAME           float64 `json:"CITY_SAME" md:"城市当月同比增长(%)"`
+	CITYSEQUENTIAL     float64 `json:"CITY_SEQUENTIAL" md:"城市当月环比增长(%)"`
+	CITYACCUMULATE     int     `json:"CITY_ACCUMULATE" md:"城市当月累计"`
+	RURALBASE          float64 `json:"RURAL_BASE" md:"农村当月"`
+	RURALSAME          float64 `json:"RURAL_SAME" md:"农村当月同比增长(%)"`
+	RURALSEQUENTIAL    int     `json:"RURAL_SEQUENTIAL" md:"农村当月环比增长(%)"`
+	RURALACCUMULATE    float64 `json:"RURAL_ACCUMULATE" md:"农村当月累计"`
+}
+type PPI struct {
+	REPORTDATE     string  `json:"REPORT_DATE" md:"报告时间"`
+	TIME           string  `json:"TIME" md:"报告期"`
+	BASE           float64 `json:"BASE" md:"当月"`
+	BASESAME       float64 `json:"BASE_SAME" md:"当月同比增长(%)"`
+	BASEACCUMULATE float64 `json:"BASE_ACCUMULATE" md:"累计"`
+}
+type PMI struct {
+	REPORTDATE string  `md:"报告时间" json:"REPORT_DATE"`
+	TIME       string  `md:"报告期" json:"TIME"`
+	MAKEINDEX  float64 `md:"制造业指数" json:"MAKE_INDEX"`
+	MAKESAME   float64 `md:"制造业指数同比增长(%)" json:"MAKE_SAME"`
+	NMAKEINDEX float64 `md:"非制造业" json:"NMAKE_INDEX"`
+	NMAKESAME  float64 `md:"非制造业同比增长(%)" json:"NMAKE_SAME"`
+}
+
+type DCResp struct {
+	Version string `json:"version"`
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	Code    int    `json:"code"`
+}
+
+type GDPResult struct {
+	Pages int   `json:"pages"`
+	Data  []GDP `json:"data"`
+	Count int   `json:"count"`
+}
+type CPIResult struct {
+	Pages int   `json:"pages"`
+	Data  []CPI `json:"data"`
+	Count int   `json:"count"`
+}
+
+type PPIResult struct {
+	Pages int   `json:"pages"`
+	Data  []PPI `json:"data"`
+	Count int   `json:"count"`
+}
+type PMIResult struct {
+	Pages int   `json:"pages"`
+	Data  []PMI `json:"data"`
+	Count int   `json:"count"`
+}
+type GDPResp struct {
+	DCResp
+	GDPResult GDPResult `json:"result"`
+}
+
+type CPIResp struct {
+	DCResp
+	CPIResult CPIResult `json:"result"`
+}
+
+type PPIResp struct {
+	DCResp
+	PPIResult PPIResult `json:"result"`
+}
+type PMIResp struct {
+	DCResp
+	PMIResult PMIResult `json:"result"`
+}
+
+type OldSettings struct {
+	gorm.Model
+	TushareToken           string `json:"tushareToken"`
+	LocalPushEnable        bool   `json:"localPushEnable"`
+	DingPushEnable         bool   `json:"dingPushEnable"`
+	DingRobot              string `json:"dingRobot"`
+	UpdateBasicInfoOnStart bool   `json:"updateBasicInfoOnStart"`
+	RefreshInterval        int64  `json:"refreshInterval"`
+
+	OpenAiEnable      bool    `json:"openAiEnable"`
+	OpenAiBaseUrl     string  `json:"openAiBaseUrl"`
+	OpenAiApiKey      string  `json:"openAiApiKey"`
+	OpenAiModelName   string  `json:"openAiModelName"`
+	OpenAiMaxTokens   int     `json:"openAiMaxTokens"`
+	OpenAiTemperature float64 `json:"openAiTemperature"`
+	OpenAiApiTimeOut  int     `json:"openAiApiTimeOut"`
+	Prompt            string  `json:"prompt"`
+	CheckUpdate       bool    `json:"checkUpdate"`
+	QuestionTemplate  string  `json:"questionTemplate"`
+	CrawlTimeOut      int64   `json:"crawlTimeOut"`
+	KDays             int64   `json:"kDays"`
+	EnableDanmu       bool    `json:"enableDanmu"`
+	BrowserPath       string  `json:"browserPath"`
+	EnableNews        bool    `json:"enableNews"`
+	DarkTheme         bool    `json:"darkTheme"`
+	BrowserPoolSize   int     `json:"browserPoolSize"`
+	EnableFund        bool    `json:"enableFund"`
+	EnablePushNews    bool    `json:"enablePushNews"`
+	SponsorCode       string  `json:"sponsorCode"`
+}
+
+func (receiver OldSettings) TableName() string {
+	return "settings"
+}
+
+type ReutersNews struct {
+	StatusCode int    `json:"statusCode"`
+	Message    string `json:"message"`
+	Result     struct {
+		ParentSectionName string `json:"parent_section_name"`
+		Pagination        struct {
+			Size         int    `json:"size"`
+			ExpectedSize int    `json:"expected_size"`
+			TotalSize    int    `json:"total_size"`
+			Orderby      string `json:"orderby"`
+		} `json:"pagination"`
+		DateModified time.Time `json:"date_modified"`
+		FetchType    string    `json:"fetch_type"`
+		Articles     []struct {
+			Id                          string    `json:"id"`
+			CanonicalUrl                string    `json:"canonical_url"`
+			Website                     string    `json:"website"`
+			Web                         string    `json:"web"`
+			Native                      string    `json:"native"`
+			UpdatedTime                 time.Time `json:"updated_time"`
+			PublishedTime               time.Time `json:"published_time"`
+			ArticleType                 string    `json:"article_type"`
+			DisplayMyNews               bool      `json:"display_my_news"`
+			DisplayNewsletterSignup     bool      `json:"display_newsletter_signup"`
+			DisplayNotifications        bool      `json:"display_notifications"`
+			DisplayRelatedMedia         bool      `json:"display_related_media"`
+			DisplayRelatedOrganizations bool      `json:"display_related_organizations"`
+			ContentCode                 string    `json:"content_code"`
+			Source                      struct {
+				Name         string `json:"name"`
+				OriginalName string `json:"original_name"`
+			} `json:"source"`
+			Title            string `json:"title"`
+			BasicHeadline    string `json:"basic_headline"`
+			Distributor      string `json:"distributor"`
+			Description      string `json:"description"`
+			PrimaryMediaType string `json:"primary_media_type,omitempty"`
+			PrimaryTag       struct {
+				ShortBio    string `json:"short_bio"`
+				Description string `json:"description"`
+				Slug        string `json:"slug"`
+				Text        string `json:"text"`
+				TopicUrl    string `json:"topic_url"`
+				CanFollow   bool   `json:"can_follow,omitempty"`
+				IsTopic     bool   `json:"is_topic,omitempty"`
+			} `json:"primary_tag"`
+			WordCount   int `json:"word_count"`
+			ReadMinutes int `json:"read_minutes"`
+			Kicker      struct {
+				Path  string   `json:"path"`
+				Names []string `json:"names"`
+				Name  string   `json:"name,omitempty"`
+			} `json:"kicker"`
+			AdTopics  []string `json:"ad_topics"`
+			Thumbnail struct {
+				Url                   string    `json:"url"`
+				Caption               string    `json:"caption,omitempty"`
+				Type                  string    `json:"type"`
+				ResizerUrl            string    `json:"resizer_url"`
+				Location              string    `json:"location,omitempty"`
+				Id                    string    `json:"id"`
+				Authors               string    `json:"authors,omitempty"`
+				AltText               string    `json:"alt_text"`
+				Width                 int       `json:"width"`
+				Height                int       `json:"height"`
+				Subtitle              string    `json:"subtitle"`
+				Slug                  string    `json:"slug,omitempty"`
+				UpdatedAt             time.Time `json:"updated_at"`
+				Company               string    `json:"company,omitempty"`
+				PurchaseLicensingPath string    `json:"purchase_licensing_path,omitempty"`
+			} `json:"thumbnail"`
+			Authors []struct {
+				Id        string `json:"id,omitempty"`
+				Name      string `json:"name"`
+				FirstName string `json:"first_name,omitempty"`
+				LastName  string `json:"last_name,omitempty"`
+				Company   string `json:"company"`
+				Thumbnail struct {
+					Url        string `json:"url"`
+					Type       string `json:"type"`
+					ResizerUrl string `json:"resizer_url"`
+				} `json:"thumbnail"`
+				SocialLinks []struct {
+					Site string `json:"site"`
+					Url  string `json:"url"`
+				} `json:"social_links,omitempty"`
+				Byline      string `json:"byline"`
+				Description string `json:"description,omitempty"`
+				TopicUrl    string `json:"topic_url,omitempty"`
+				Role        string `json:"role,omitempty"`
+			} `json:"authors"`
+			DisplayTime   time.Time `json:"display_time"`
+			ThumbnailDark struct {
+				Url        string    `json:"url"`
+				Type       string    `json:"type"`
+				ResizerUrl string    `json:"resizer_url"`
+				Id         string    `json:"id"`
+				AltText    string    `json:"alt_text"`
+				Width      int       `json:"width"`
+				Height     int       `json:"height"`
+				Subtitle   string    `json:"subtitle"`
+				UpdatedAt  time.Time `json:"updated_at"`
+			} `json:"thumbnail_dark,omitempty"`
+		} `json:"articles"`
+		Section struct {
+			Id          string `json:"id"`
+			AdUnitCode  string `json:"ad_unit_code"`
+			Website     string `json:"website"`
+			Name        string `json:"name"`
+			PageTitle   string `json:"page_title"`
+			CanFollow   bool   `json:"can_follow"`
+			Language    string `json:"language"`
+			Type        string `json:"type"`
+			Advertising struct {
+				Sponsored string `json:"sponsored"`
+			} `json:"advertising"`
+			VideoPlaylistId  string `json:"video_playlistId"`
+			MobileAdUnitPath string `json:"mobile_ad_unit_path"`
+			AdUnitPath       string `json:"ad_unit_path"`
+			CollectionAlias  string `json:"collection_alias"`
+			SectionAbout     string `json:"section_about"`
+			Title            string `json:"title"`
+			Personalization  struct {
+				Id        string `json:"id"`
+				Type      string `json:"type"`
+				ShowTags  bool   `json:"show_tags"`
+				CanFollow bool   `json:"can_follow"`
+			} `json:"personalization"`
+		} `json:"section"`
+		AdUnitPath   string `json:"ad_unit_path"`
+		ResponseTime int64  `json:"response_time"`
+	} `json:"result"`
+	Id string `json:"_id"`
+}
+
+type InteractiveAnswer struct {
+	PageNo      int                        `json:"pageNo"`
+	PageSize    int                        `json:"pageSize"`
+	TotalRecord int                        `json:"totalRecord"`
+	TotalPage   int                        `json:"totalPage"`
+	Results     []InteractiveAnswerResults `json:"results"`
+	Count       bool                       `json:"count"`
+}
+
+type InteractiveAnswerResults struct {
+	EsId             string   `json:"esId" md:"-"`
+	IndexId          string   `json:"indexId" md:"-"`
+	ContentType      int      `json:"contentType" md:"-"`
+	Trade            []string `json:"trade"  md:"行业名称"`
+	MainContent      string   `json:"mainContent" md:"投资者提问"`
+	StockCode        string   `json:"stockCode" md:"股票代码"`
+	Secid            string   `json:"secid" md:"-"`
+	CompanyShortName string   `json:"companyShortName" md:"股票名称"`
+	CompanyLogo      string   `json:"companyLogo,omitempty" md:"-"`
+	BoardType        []string `json:"boardType" md:"-"`
+	PubDate          string   `json:"pubDate" md:"发布时间"`
+	UpdateDate       string   `json:"updateDate" md:"-"`
+	Author           string   `json:"author" md:"-"`
+	AuthorName       string   `json:"authorName" md:"-"`
+	PubClient        string   `json:"pubClient" md:"-"`
+	AttachedId       string   `json:"attachedId" md:"-"`
+	AttachedContent  string   `json:"attachedContent" md:"上市公司回复"`
+	AttachedAuthor   string   `json:"attachedAuthor" md:"-"`
+	AttachedPubDate  string   `json:"attachedPubDate" md:"回复时间"`
+	Score            float64  `json:"score" md:"-"`
+	TopStatus        int      `json:"topStatus" md:"-"`
+	PraiseCount      int      `json:"praiseCount" md:"-"`
+	PraiseStatus     bool     `json:"praiseStatus" md:"-"`
+	FavoriteStatus   bool     `json:"favoriteStatus" md:"-"`
+	AttentionCompany bool     `json:"attentionCompany" md:"-"`
+	IsCheck          string   `json:"isCheck" md:"-"`
+	QaStatus         int      `json:"qaStatus" md:"-"`
+	PackageDate      string   `json:"packageDate" md:"-"`
+	RemindStatus     bool     `json:"remindStatus" md:"-"`
+	InterviewLive    bool     `json:"interviewLive" md:"-"`
+}
+
+type CailianpressWeb struct {
+	Total int `json:"total"`
+	List  []struct {
+		Title   string `json:"title" md:"资讯标题"`
+		Ctime   int    `json:"ctime" md:"资讯时间"`
+		Content string `json:"content" md:"资讯内容"`
+		Author  string `json:"author" md:"资讯发布者"`
+	} `json:"list"`
+}
+
+type BKDict struct {
+	gorm.Model  `md:"-"`
+	BkCode      string `json:"bkCode" md:"行业/板块代码"`
+	BkName      string `json:"bkName" md:"行业/板块名称"`
+	FirstLetter string `json:"firstLetter" md:"first_letter"`
+	FubkCode    string `json:"fubkCode" md:"fubk_code"`
+	PublishCode string `json:"publishCode" md:"publish_code"`
+}
+
+func (b BKDict) TableName() string {
+	return "bk_dict"
+}
+
+type WordAnalyze struct {
+	gorm.Model
+	DataTime *time.Time `json:"dataTime" gorm:"index;autoCreateTime"`
+	WordFreqWithWeight
+}
+
+// WordFreqWithWeight 词频统计结果，包含权重信息
+type WordFreqWithWeight struct {
+	Word      string
+	Frequency int
+	Weight    float64
+	Score     float64
+}
+
+// SentimentResult 情感分析结果类型
+type SentimentResult struct {
+	Score         float64       // 情感得分
+	Category      SentimentType // 情感类别
+	PositiveCount int           // 正面词数量
+	NegativeCount int           // 负面词数量
+	Description   string        // 情感描述
+}
+
+type SentimentResultAnalyze struct {
+	gorm.Model
+	DataTime *time.Time `json:"dataTime" gorm:"index;autoCreateTime"`
+	SentimentResult
+}
+
+// SentimentType 情感类型枚举
+type SentimentType int
+
+type HotStrategy struct {
+	ChgEffect bool               `json:"chgEffect"`
+	Code      int                `json:"code"`
+	Data      []*HotStrategyData `json:"data"`
+	Message   string             `json:"message"`
+}
+
+type HotStrategyData struct {
+	Chg       float64 `json:"chg" md:"平均涨幅(%)"`
+	Code      string  `json:"code" md:"-"`
+	HeatValue int     `json:"heatValue" md:"热度值"`
+	Market    string  `json:"market" md:"-"`
+	Question  string  `json:"question" md:"选股策略"`
+	Rank      int     `json:"rank" md:"-"`
+}
+
+type NtfyNews struct {
+	Id      string   `json:"id"`
+	Time    int      `json:"time"`
+	Expires int      `json:"expires"`
+	Event   string   `json:"event"`
+	Topic   string   `json:"topic"`
+	Title   string   `json:"title"`
+	Message string   `json:"message"`
+	Tags    []string `json:"tags"`
+	Icon    string   `json:"icon"`
+}
+
+type THSHotStrategy struct {
+	Result struct {
+		Num  int `json:"num"`
+		List []struct {
+			Author struct {
+				Avatar   string `json:"avatar"`
+				UserName string `json:"userName"`
+				UserId   int    `json:"userId"`
+			} `json:"author"`
+			Property struct {
+				Id          int         `json:"id"`
+				Name        string      `json:"name"`
+				Query       string      `json:"query"`
+				Logic       string      `json:"logic"`
+				BuyPosition interface{} `json:"buyPosition"`
+				Ctime       string      `json:"ctime"`
+				Tags        []string    `json:"tags"`
+				WinRate     string      `json:"winRate"`
+				AnnualYield string      `json:"annualYield"`
+				Type        int         `json:"type"`
+			} `json:"property"`
+			Interaction struct {
+				CommentNum  int  `json:"commentNum"`
+				CollectNum  int  `json:"collectNum"`
+				IsCollected bool `json:"isCollected"`
+				IsSubscribe int  `json:"isSubscribe"`
+				IsPublish   int  `json:"isPublish"`
+				Pid         int  `json:"pid"`
+			} `json:"interaction"`
+		} `json:"list"`
+	} `json:"result"`
+}
+
+type StockMoneyDataResp struct {
+	Rc     int            `json:"rc"`
+	Rt     int            `json:"rt"`
+	Svr    int            `json:"svr"`
+	Lt     int            `json:"lt"`
+	Full   int            `json:"full"`
+	Dlmkts string         `json:"dlmkts"`
+	Data   StockMoneyData `json:"data"`
+}
+
+type StockMoneyData struct {
+	Total int                  `json:"total"`
+	Diff  []StockMoneyDataDiff `json:"diff"`
+}
+
+type StockMoneyDataDiff struct {
+	F1   int     `json:"f1" md:"-"`
+	F12  string  `json:"f12" md:"股票代码"`
+	F13  int     `json:"f13" md:"-"`
+	F14  string  `json:"f14" md:"股票名称"`
+	F2   float64 `json:"f2" md:"最新价"`
+	F3   float64 `json:"f3" md:"今日涨跌幅(%)"`
+	F62  float64 `json:"f62" md:"今日主力净额(元)"`
+	F184 float64 `json:"f184" md:"今日主力净占比(%)"`
+	F66  float64 `json:"f66" md:"今日超大单净额(元)"`
+	F69  float64 `json:"f69" md:"今日超大单净占比(%)"`
+	F72  float64 `json:"f72" md:"今日大单净额(元)"`
+	F75  float64 `json:"f75" md:"今日大单净占比(%)"`
+	F78  float64 `json:"f78" md:"今日中单净额(元)"`
+	F81  float64 `json:"f81" md:"今日中单净占比(%)"`
+	F84  float64 `json:"f84" md:"今日小单净额(元)"`
+	F87  float64 `json:"f87" md:"今日小单净占比(%)"`
+	F124 int     `json:"f124" md:"f124"`
+	F100 string  `json:"f100" md:"所属板块"`
+	F265 string  `json:"f265" md:"板块代码"`
+}
+
+type StockConceptInfoResp struct {
+	Version string                 `json:"version"`
+	Result  StockConceptInfoResult `json:"result"`
+	Success bool                   `json:"success"`
+	Message string                 `json:"message"`
+	Code    int                    `json:"code"`
+}
+
+type StockConceptInfoResult struct {
+	Pages int                `json:"pages"`
+	Data  []StockConceptInfo `json:"data"`
+	Count int                `json:"count"`
+}
+
+type StockConceptInfo struct {
+	SECUCODE            string  `json:"SECUCODE" md:"完整股票代码"`
+	SECURITYCODE        string  `json:"SECURITY_CODE" md:"股票代码"`
+	SECURITYNAMEABBR    string  `json:"SECURITY_NAME_ABBR" md:"股票名称"`
+	NEWBOARDCODE        string  `json:"NEW_BOARD_CODE" md:"板块/概念代码"`
+	BOARDNAME           string  `json:"BOARD_NAME" md:"板块/概念名称"`
+	SELECTEDBOARDREASON string  `json:"SELECTED_BOARD_REASON" md:"板块/概念描述"`
+	ISPRECISE           string  `json:"IS_PRECISE" md:"-"`
+	BOARDRANK           int     `json:"BOARD_RANK" md:"-"`
+	BOARDYIELD          float64 `json:"BOARD_YIELD" md:"板块/概念涨跌幅(%)"`
+	DERIVEBOARDCODE     string  `json:"DERIVE_BOARD_CODE" md:"-"`
+}
+
+type AiRecommendStocks struct {
+	gorm.Model
+	DataTime                 *time.Time `json:"dataTime" gorm:"index;autoCreateTime"`
+	ModelName                string     `json:"modelName" md:"模型名称"`
+	StockCode                string     `json:"stockCode" md:"股票代码"`
+	StockName                string     `json:"stockName" md:"股票名称"`
+	BkCode                   string     `json:"bkCode" md:"行业/板块代码"`
+	BkName                   string     `json:"bkName" md:"行业/板块名称"`
+	StockPrice               string     `json:"stockPrice" md:"推荐时股票价格"`
+	StockCurrentPrice        string     `json:"stockCurrentPrice" md:"当前价格"`
+	StockCurrentPriceTime    string     `json:"stockCurrentPriceTime" md:"当前价格时间"`
+	StockClosePrice          string     `json:"stockClosePrice" md:"推荐时股票收盘价格"`
+	StockPrePrice            string     `json:"stockPrePrice" md:"前一交易日股票价格"`
+	RecommendReason          string     `json:"recommendReason" md:"推荐理由/驱动因素/逻辑"`
+	RecommendBuyPrice        string     `json:"recommendBuyPrice" md:"ai建议买入价"`
+	RecommendStopProfitPrice string     `json:"recommendStopProfitPrice" md:"ai建议止盈价"`
+	RecommendStopLossPrice   string     `json:"recommendStopLossPrice" md:"ai建议止损价"`
+	RiskRemarks              string     `json:"riskRemarks" md:"风险提示"`
+	Remarks                  string     `json:"remarks" md:"备注"`
+}
+
+func (receiver AiRecommendStocks) TableName() string { return "ai_recommend_stocks" }
+
+type AiRecommendStocksQuery struct {
+	Page      int    `form:"page" json:"page"`           // 页码
+	PageSize  int    `form:"pageSize" json:"pageSize"`   // 每页大小
+	StockCode string `form:"stockCode" json:"stockCode"` // 股票代码筛选
+	StockName string `form:"stockName" json:"stockName"` // 股票名称筛选
+	BkCode    string `form:"bkCode" json:"bkCode"`       // 板块代码筛选
+	BkName    string `form:"bkName" json:"bkName"`       // 板块名称筛选
+	StartDate string `form:"startDate" json:"startDate"` // 开始日期
+	EndDate   string `form:"endDate" json:"endDate"`     // 结束日期
+}
+
+type AiRecommendStocksPageResp struct {
+	Code    int                       `json:"code"`
+	Message string                    `json:"message"`
+	Data    AiRecommendStocksPageData `json:"data"`
+}
+
+type AiRecommendStocksPageData struct {
+	List       []AiRecommendStocks `json:"list"`
+	Total      int64               `json:"total"`
+	Page       int                 `json:"page"`
+	PageSize   int                 `json:"pageSize"`
+	TotalPages int                 `json:"totalPages"`
+}

backend/models/models_test.go

@@ -0,0 +1,49 @@
+package models
+
+import (
+	"encoding/json"
+	"github.com/duke-git/lancet/v2/strutil"
+	"go-stock/backend/db"
+	"go-stock/backend/logger"
+	"os"
+	"testing"
+)
+
+// @Author spark
+// @Date 2025/2/22 16:09
+// @Desc
+// -----------------------------------------------------------------------------------
+type StockInfoHKResp struct {
+	Code       int              `json:"code"`
+	Status     string           `json:"status"`
+	StockInfos *[]StockInfoData `json:"data"`
+}
+
+type StockInfoData struct {
+	C string `json:"c"`
+	N string `json:"n"`
+	T string `json:"t"`
+	E string `json:"e"`
+}
+
+func TestStockInfoHK(t *testing.T) {
+	db.Init("../../data/stock.db")
+	db.Dao.AutoMigrate(&StockInfoHK{})
+	bs, _ := os.ReadFile("../../build/hk.json")
+	v := &StockInfoHKResp{}
+	err := json.Unmarshal(bs, v)
+	if err != nil {
+		return
+	}
+	hks := &[]StockInfoHK{}
+	for i, data := range *v.StockInfos {
+		logger.SugaredLogger.Infof("第%d条数据: %+v", i, data)
+		hk := &StockInfoHK{
+			Code:  strutil.PadStart(data.C, 5, "0") + ".HK",
+			EName: data.N,
+		}
+		*hks = append(*hks, *hk)
+	}
+	db.Dao.Create(&hks)
+
+}

backend/util/html_to_markdown.go

@@ -0,0 +1,221 @@
+package util
+
+// @Author spark
+// @Date 2025/7/15 14:08
+// @Desc
+//-----------------------------------------------------------------------------------
+
+import (
+	"bytes"
+	"fmt"
+	"golang.org/x/net/html"
+	"strings"
+)
+
+// HTMLNode 表示HTML文档中的一个节点
+type HTMLNode struct {
+	Type     html.NodeType
+	Data     string
+	Attr     []html.Attribute
+	Children []*HTMLNode
+}
+
+// HTMLToMarkdown 将HTML转换为Markdown
+func HTMLToMarkdown(htmlContent string) (string, error) {
+	doc, err := html.Parse(strings.NewReader(htmlContent))
+	if err != nil {
+		return "", err
+	}
+
+	root := parseHTMLNode(doc)
+	var buf bytes.Buffer
+	convertNode(&buf, root, 0)
+
+	return buf.String(), nil
+}
+
+// parseHTMLNode 递归解析HTML节点
+func parseHTMLNode(n *html.Node) *HTMLNode {
+	node := &HTMLNode{
+		Type: n.Type,
+		Data: n.Data,
+		Attr: n.Attr,
+	}
+
+	for c := n.FirstChild; c != nil; c = c.NextSibling {
+		node.Children = append(node.Children, parseHTMLNode(c))
+	}
+
+	return node
+}
+
+// convertNode 递归转换节点为Markdown
+func convertNode(buf *bytes.Buffer, node *HTMLNode, depth int) {
+	switch node.Type {
+	case html.ElementNode:
+		convertElementNode(buf, node, depth)
+	case html.TextNode:
+		// 处理文本节点，去除多余的空白
+		text := strings.TrimSpace(node.Data)
+		if text != "" {
+			buf.WriteString(text)
+		}
+	}
+
+	// 递归处理子节点
+	for _, child := range node.Children {
+		convertNode(buf, child, depth+1)
+	}
+
+	// 处理需要在结束标签后添加内容的元素
+	switch node.Data {
+	case "p", "h1", "h2", "h3", "h4", "h5", "h6", "li":
+		buf.WriteString("\n\n")
+	case "blockquote":
+		buf.WriteString("\n")
+	}
+}
+
+// convertElementNode 转换元素节点为Markdown
+func convertElementNode(buf *bytes.Buffer, node *HTMLNode, depth int) {
+	switch node.Data {
+	case "h1":
+		buf.WriteString("# ")
+	case "h2":
+		buf.WriteString("## ")
+	case "h3":
+		buf.WriteString("### ")
+	case "h4":
+		buf.WriteString("#### ")
+	case "h5":
+		buf.WriteString("##### ")
+	case "h6":
+		buf.WriteString("###### ")
+	case "p":
+		// 段落标签不需要特殊标记，直接处理内容
+	case "strong", "b":
+		buf.WriteString("**")
+	case "em", "i":
+		buf.WriteString("*")
+	case "u":
+		buf.WriteString("<u>")
+	case "s", "del":
+		buf.WriteString("~~")
+	case "a":
+		//href := getAttrValue(node.Attr, "href")
+		buf.WriteString("[")
+	case "img":
+		src := getAttrValue(node.Attr, "src")
+		alt := getAttrValue(node.Attr, "alt")
+		buf.WriteString(fmt.Sprintf("![%s](%s)", alt, src))
+	case "ul":
+		// 无序列表不需要特殊标记，子项会处理
+	case "ol":
+		// 有序列表不需要特殊标记，子项会处理
+	case "li":
+		if isParentListType(node, "ul") {
+			buf.WriteString("- ")
+		} else {
+			// 计算当前列表项的序号
+			index := 1
+			if parent := findParentList(node); parent != nil {
+				for i, sibling := range parent.Children {
+					if sibling == node {
+						index = i + 1
+						break
+					}
+				}
+			}
+			buf.WriteString(fmt.Sprintf("%d. ", index))
+		}
+	case "blockquote":
+		buf.WriteString("> ")
+	case "code":
+		if isParentPre(node) {
+			// 父节点是pre，使用代码块
+			buf.WriteString("\n```\n")
+		} else {
+			// 行内代码
+			buf.WriteString("`")
+		}
+	case "pre":
+		// 前置代码块由子节点code处理
+	case "br":
+		buf.WriteString("\n")
+	case "hr":
+		buf.WriteString("\n---\n")
+	}
+
+	// 处理闭合标签
+	if needsClosingTag(node.Data) {
+		defer func() {
+			switch node.Data {
+			case "strong", "b":
+				buf.WriteString("**")
+			case "em", "i":
+				buf.WriteString("*")
+			case "u":
+				buf.WriteString("</u>")
+			case "s", "del":
+				buf.WriteString("~~")
+			case "a":
+				href := getAttrValue(node.Attr, "href")
+				buf.WriteString(fmt.Sprintf("](%s)", href))
+			case "code":
+				if isParentPre(node) {
+					buf.WriteString("\n```\n")
+				} else {
+					buf.WriteString("`")
+				}
+			}
+		}()
+	}
+}
+
+// getAttrValue 获取属性值
+func getAttrValue(attrs []html.Attribute, key string) string {
+	for _, attr := range attrs {
+		if attr.Key == key {
+			return attr.Val
+		}
+	}
+	return ""
+}
+
+// isParentListType 检查父节点是否为指定类型的列表
+func isParentListType(node *HTMLNode, listType string) bool {
+	parent := findParentList(node)
+	return parent != nil && parent.Data == listType
+}
+
+// findParentList 查找父列表节点
+func findParentList(node *HTMLNode) *HTMLNode {
+	// 简化实现，实际应该递归查找父节点
+	if node.Type == html.ElementNode && (node.Data == "ul" || node.Data == "ol") {
+		return node
+	}
+	return nil
+}
+
+// isParentPre 检查父节点是否为pre
+func isParentPre(node *HTMLNode) bool {
+	if len(node.Children) == 0 {
+		return false
+	}
+	for _, child := range node.Children {
+		if child.Type == html.ElementNode && child.Data == "pre" {
+			return true
+		}
+	}
+	return false
+}
+
+// needsClosingTag 判断元素是否需要闭合标签
+func needsClosingTag(tag string) bool {
+	switch tag {
+	case "img", "br", "hr", "input", "meta", "link":
+		return false
+	default:
+		return true
+	}
+}

backend/util/html_to_markdown_test.go

@@ -0,0 +1,6 @@
+package util
+
+// @Author spark
+// @Date 2025/7/15 14:08
+// @Desc
+//-----------------------------------------------------------------------------------

backend/util/struct_to_markdown.go

@@ -0,0 +1,286 @@
+package util
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/strutil"
+	"reflect"
+	"strings"
+)
+
+// MarkdownTable 生成结构体或结构体切片的Markdown表格表示
+func MarkdownTable(v interface{}) string {
+	value := reflect.ValueOf(v)
+	if value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+
+	// 处理单个结构体
+	if value.Kind() == reflect.Struct {
+		return markdownSingleStruct(value)
+	}
+
+	// 处理结构体切片/数组
+	if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
+		if value.Len() == 0 {
+			return "切片/数组为空"
+		}
+		return markdownStructSlice(value)
+	}
+
+	return "输入必须是结构体、结构体指针、结构体切片或数组"
+}
+
+func MarkdownTableWithTitle(title string, v interface{}) string {
+	value := reflect.ValueOf(v)
+	if value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+
+	// 处理单个结构体
+	if value.Kind() == reflect.Struct {
+		return markdownSingleStruct(value)
+	}
+
+	// 处理结构体切片/数组
+	if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
+		if value.Len() == 0 {
+			return "\n## " + title + "\n" + "无数据" + "\n"
+		}
+		return "\n## " + title + "\n" + markdownStructSlice(value) + "\n"
+	}
+
+	return "\n## " + title + "\n" + "无数据" + "\n"
+}
+
+// 处理单个结构体
+func markdownSingleStruct(value reflect.Value) string {
+	t := value.Type()
+	var b strings.Builder
+
+	// 表头
+	b.WriteString("|")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if shouldSkip(field) {
+			continue
+		}
+		b.WriteString(fmt.Sprintf(" %s |", getFieldName(field)))
+	}
+	b.WriteString("\n")
+
+	// 分隔线
+	b.WriteString("|")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if shouldSkip(field) {
+			continue
+		}
+		b.WriteString(" --- |")
+	}
+	b.WriteString("\n")
+
+	// 数据行
+	b.WriteString("|")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if shouldSkip(field) {
+			continue
+		}
+		fieldValue := value.Field(i)
+		b.WriteString(fmt.Sprintf(" %s |", formatValue(fieldValue)))
+	}
+	b.WriteString("\n")
+
+	return b.String()
+}
+
+// 处理结构体切片/数组
+func markdownStructSlice(value reflect.Value) string {
+	if value.Len() == 0 {
+		return "切片/数组为空"
+	}
+
+	firstElem := value.Index(0)
+	if firstElem.Kind() == reflect.Ptr {
+		firstElem = firstElem.Elem()
+	}
+	if firstElem.Kind() != reflect.Struct {
+		return "切片/数组元素必须是结构体或结构体指针"
+	}
+
+	t := firstElem.Type()
+	var b strings.Builder
+
+	// 表头
+	b.WriteString("|")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if shouldSkip(field) {
+			continue
+		}
+		b.WriteString(fmt.Sprintf(" %s |", getFieldName(field)))
+	}
+	b.WriteString("\n")
+
+	// 分隔线
+	b.WriteString("|")
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		if shouldSkip(field) {
+			continue
+		}
+		b.WriteString(" --- |")
+	}
+	b.WriteString("\n")
+
+	// 多行数据
+	for i := 0; i < value.Len(); i++ {
+		elem := value.Index(i)
+		if elem.Kind() == reflect.Ptr {
+			elem = elem.Elem()
+		}
+
+		b.WriteString("|")
+		for j := 0; j < t.NumField(); j++ {
+			field := t.Field(j)
+			if shouldSkip(field) {
+				continue
+			}
+			fieldValue := elem.Field(j)
+			b.WriteString(fmt.Sprintf(" %s |", formatValue(fieldValue)))
+		}
+		b.WriteString("\n")
+	}
+
+	return b.String()
+}
+
+// 判断是否应该跳过该字段
+func shouldSkip(field reflect.StructField) bool {
+	return field.Tag.Get("md") == "-"
+}
+
+// 获取字段的Markdown表头名称
+func getFieldName(field reflect.StructField) string {
+	name := field.Tag.Get("md")
+	if name == "" || name == "-" {
+		return field.Name
+	}
+	return name
+}
+
+// 格式化字段值为字符串
+func formatValue(value reflect.Value) string {
+	if !value.IsValid() {
+		return "n/a"
+	}
+
+	// 处理指针
+	if value.Kind() == reflect.Ptr {
+		if value.IsNil() {
+			return "nil"
+		}
+		return formatValue(value.Elem())
+	}
+
+	// 处理结构体
+	if value.Kind() == reflect.Struct {
+		var fields []string
+		for i := 0; i < value.NumField(); i++ {
+			field := value.Type().Field(i)
+			if shouldSkip(field) {
+				continue
+			}
+			fieldValue := value.Field(i)
+			fields = append(fields, fmt.Sprintf("%s: %s", getFieldName(field), formatValue(fieldValue)))
+		}
+		return "{" + strings.Join(fields, ", ") + "}"
+	}
+
+	// 处理切片/数组
+	if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
+		var items []string
+		for i := 0; i < value.Len(); i++ {
+			items = append(items, formatValue(value.Index(i)))
+		}
+		return "[" + strings.Join(items, ", ") + "]"
+	}
+
+	// 处理映射
+	if value.Kind() == reflect.Map {
+		var items []string
+		for _, key := range value.MapKeys() {
+			keyStr := formatValue(key)
+			valueStr := formatValue(value.MapIndex(key))
+			items = append(items, fmt.Sprintf("%s: %s", keyStr, valueStr))
+		}
+		return "{" + strings.Join(items, ", ") + "}"
+	}
+
+	// 基本类型
+	return fmt.Sprintf("%s", strutil.RemoveNonPrintable(convertor.ToString(value.Interface())))
+}
+
+// 示例结构体
+type Address struct {
+	City    string `md:"城市"`
+	Country string `md:"国家"`
+}
+
+type User struct {
+	Name    string   `md:"姓名"`
+	Age     int      `md:"年龄"`
+	Email   string   `md:"邮箱"`
+	Address Address  `md:"地址"`
+	Phones  []string `md:"电话"`
+	Active  bool     `md:"活跃状态"`
+}
+
+func main() {
+	// 示例使用：单个结构体
+	user := User{
+		Name:  "张三",
+		Age:   30,
+		Email: "zhangsan@example.com",
+		Address: Address{
+			City:    "北京",
+			Country: "中国",
+		},
+		Phones: []string{"13800138000", "13900139000"},
+		Active: true,
+	}
+
+	fmt.Println("单个结构体转换:")
+	fmt.Println(MarkdownTable(user))
+	fmt.Println()
+
+	// 示例使用：结构体切片
+	users := []User{
+		{
+			Name:  "张三",
+			Age:   30,
+			Email: "zhangsan@example.com",
+			Address: Address{
+				City:    "北京",
+				Country: "中国",
+			},
+			Phones: []string{"13800138000"},
+			Active: true,
+		},
+		{
+			Name:  "李四",
+			Age:   25,
+			Email: "lisi@example.com",
+			Address: Address{
+				City:    "上海",
+				Country: "中国",
+			},
+			Phones: []string{"13900139000", "13700137000"},
+			Active: false,
+		},
+	}
+
+	fmt.Println("结构体切片转换:")
+	fmt.Println(MarkdownTable(users))
+}

backend/util/struct_to_markdown_test.go

@@ -0,0 +1,54 @@
+package util
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMd(t *testing.T) {
+	// 示例使用：单个结构体
+	user := User{
+		Name:  "张三",
+		Age:   30,
+		Email: "zhangsan@example.com",
+		Address: Address{
+			City:    "北京",
+			Country: "中国",
+		},
+		Phones: []string{"13800138000", "13900139000"},
+		Active: true,
+	}
+
+	fmt.Println("单个结构体转换:")
+	fmt.Println(MarkdownTable(user))
+	fmt.Println()
+
+	// 示例使用：结构体切片
+	users := []User{
+		{
+			Name:  "张三",
+			Age:   30,
+			Email: "zhangsan@example.com",
+			Address: Address{
+				City:    "北京",
+				Country: "中国",
+			},
+			Phones: []string{"13800138000"},
+			Active: true,
+		},
+		{
+			Name:  "李四",
+			Age:   25,
+			Email: "lisi@example.com",
+			Address: Address{
+				City:    "上海",
+				Country: "中国",
+			},
+			Phones: []string{"13900139000", "13700137000"},
+			Active: false,
+		},
+	}
+
+	fmt.Println("结构体切片转换:")
+	fmt.Println(MarkdownTable(users))
+}