♻️ refactor(llm): 重构 LLM 服务架构，引入中间件与组件化适配器 (#2073)

* ♻️ refactor(llm): 重构 LLM 服务架构，引入中间件与组件化适配器

- 【重构】LLM 服务核心架构：
    - 引入中间件管道，统一处理请求生命周期（重试、密钥选择、日志、网络请求）。
    - 适配器重构为组件化设计，分离配置映射、消息转换、响应解析和工具序列化逻辑。
    - 移除 `with_smart_retry` 装饰器，其功能由中间件接管。
    - 移除 `LLMToolExecutor`，工具执行逻辑集成到 `ToolInvoker`。
- 【功能】增强配置系统：
    - `LLMGenerationConfig` 采用组件化结构（Core, Reasoning, Visual, Output, Safety, ToolConfig）。
    - 新增 `GenConfigBuilder` 提供语义化配置构建方式。
    - 新增 `LLMEmbeddingConfig` 用于嵌入专用配置。
    - `CommonOverrides` 迁移并更新至新配置结构。
- 【功能】强化工具系统：
    - 引入 `ToolInvoker` 实现更灵活的工具执行，支持回调与结构化错误。
    - `function_tool` 装饰器支持动态 Pydantic 模型创建和依赖注入 (`ToolParam`, `RunContext`)。
    - 平台原生工具支持 (`GeminiCodeExecution`, `GeminiGoogleSearch`, `GeminiUrlContext`)。
- 【功能】高级生成与嵌入：
    - `generate_structured` 方法支持 In-Context Validation and Repair (IVR) 循环和 AutoCoT (思维链) 包装。
    - 新增 `embed_query` 和 `embed_documents` 便捷嵌入 API。
    - `OpenAIImageAdapter` 支持 OpenAI 兼容的图像生成。
    - `SmartAdapter` 实现模型名称智能路由。
- 【重构】消息与类型系统：
    - `LLMContentPart` 扩展支持更多模态和代码执行相关内容。
    - `LLMMessage` 和 `LLMResponse` 结构更新，支持 `content_parts` 和思维链签名。
    - 统一 `LLMErrorCode` 和用户友好错误消息，提供更详细的网络/代理错误提示。
    - `pyproject.toml` 移除 `bilireq`，新增 `json_repair`。
- 【优化】日志与调试：
    - 引入 `DebugLogOptions`，提供细粒度日志脱敏控制。
    - 增强日志净化器，处理更多敏感数据和长字符串。
- 【清理】删除废弃模块：
    - `zhenxun/services/llm/memory.py`
    - `zhenxun/services/llm/executor.py`
    - `zhenxun/services/llm/config/presets.py`
    - `zhenxun/services/llm/types/content.py`
    - `zhenxun/services/llm/types/enums.py`
    - `zhenxun/services/llm/tools/__init__.py`
    - `zhenxun/services/llm/tools/manager.py`

* 📦️ build(deps): 移除 bilireq 并添加 json_repair 依赖

* 🐛 (llm): 移除图片生成模型能力预检查

* ♻️ refactor(llm.session): 重构记忆系统以分离存储和策略

* 🐛 fix(reload_setting): 重载配置时清除LLM缓存

* ✨ feat(llm): 支持结构化生成函数接收 UniMessage

* ✨ feat(search): 为搜索功能默认启用 Gemini Google Search 工具

* 🚨 auto fix by pre-commit hooks

---------

Co-authored-by: webjoin111 <455457521@qq.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

.dockerignore

@@ -0,0 +1,20 @@
+.devcontainer/
+.github/
+.vscode/
+.idea/
+.pytest_cache/
+.ruff_cache/
+.venv/
+docs_image/
+k8s/
+tests/
+.dockerignore
+.editorconfig
+.gitignore
+.pre-commit-config.yaml
+.prettier*
+.env.dev
+docker-compose.yml
+Dockerfile
+LICENSE
+*.md

.env.dev

@@ -1,16 +0,0 @@
-
-
-SUPERUSERS=[""]
-
-COMMAND_START=[""]
-
-SESSION_RUNNING_EXPRESSION="别急呀,小真寻要宕机了!QAQ"
-
-NICKNAME=["真寻", "小真寻", "绪山真寻", "小寻子"]
-
-SESSION_EXPIRE_TIMEOUT=30
-
-DEBUG=False
-# 服务器和端口
-HOST = 127.0.0.1
-PORT = 8080

.env.example

@@ -0,0 +1,93 @@
+SUPERUSERS=[""]
+
+COMMAND_START=[""]
+
+SESSION_RUNNING_EXPRESSION="别急呀,小真寻要宕机了!QAQ"
+
+NICKNAME=["真寻", "小真寻", "绪山真寻", "小寻子"]
+
+SESSION_EXPIRE_TIMEOUT=00:00:30
+
+ALCONNA_USE_COMMAND_START=True
+
+# ws连接密钥,若bot能被公网访问则建议打开该注释并设置该配置项
+# ONEBOT_ACCESS_TOKEN=""
+
+# 全局图片统一使用bytes发送，当真寻与协议端不在同一服务器上时为True
+IMAGE_TO_BYTES = True
+
+# 回复消息时自称
+SELF_NICKNAME="小真寻"
+
+# 官bot appid:bot账号
+QBOT_ID_DATA = '{
+    
+}'
+
+# 数据库配置
+# 示例: "postgres://user:password@127.0.0.1:5432/database"
+# 示例: "mysql://user:password@127.0.0.1:3306/database"
+# 示例: "sqlite:data/db/zhenxun.db"   在data目录下建立db文件夹
+DB_URL = ""
+
+# NONE: 不使用缓存, MEMORY: 使用内存缓存, REDIS: 使用Redis缓存
+CACHE_MODE = NONE
+
+# REDIS配置，使用REDIS替换Cache内存缓存
+# REDIS地址
+# REDIS_HOST = "127.0.0.1"
+# REDIS端口
+# REDIS_PORT = 6379
+# REDIS密码
+# REDIS_PASSWORD = ""
+# REDIS过期时间
+# REDIS_EXPIRE = 600
+
+# 系统代理
+# SYSTEM_PROXY = "http://127.0.0.1:7890"
+
+PLATFORM_SUPERUSERS = '
+  {
+    "qq": [""],
+    "dodo": [""]
+  }
+'
+
+DRIVER=~fastapi+~httpx+~websockets
+
+
+# LOG_LEVEL = DEBUG
+# 服务器和端口
+HOST = 127.0.0.1
+PORT = 8080
+
+# kook adapter toekn
+# kaiheila_bots =[{"token": ""}]
+
+# # discode adapter
+# DISCORD_BOTS='
+# [
+#   {
+#     "token": "",
+#     "intent": {
+#       "guild_messages": true,
+#       "direct_messages": true
+#     },
+#     "application_commands": {"*": ["*"]}
+#   }
+# ]
+# '
+# DISCORD_PROXY=''
+
+# # dodo adapter
+# DODO_BOTS='
+# [
+#   {
+#     "client_id": "",
+#     "token": ""
+#   }
+# ]
+# '
+
+# application_commands的{"*": ["*"]}代表将全部应用命令注册为全局应用命令
+# {"admin": ["123", "456"]}则代表将admin命令注册为id是123、456服务器的局部命令，其余命令不注册

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,98 @@
+name: Bug 反馈
+title: "Bug: "
+description: 提交 Bug 反馈以帮助我们改进代码
+labels: [ "bug" ]
+body:
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: 提交前检查项
+      description: 在提交问题之前，请确认以下事项：
+      options:
+        - label: 我已搜索相关的 issue，但没有找到类似的问题
+          required: true
+        - label: 我已更新到最新版本(包括但不限于真寻本体，插件以及相关依赖)，问题仍然存在
+          required: true
+        - label: 我已仔细阅读文档，确认我的配置正确
+          required: true
+
+  - type: dropdown
+    id: env-os
+    attributes:
+      label: 操作系统
+      description: 选择运行 zhenxun_bot 的系统
+      options:
+        - Windows
+        - MacOS
+        - Linux
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: env-python-ver
+    attributes:
+      label: Python 版本
+      description: 填写运行 zhenxun_bot 的 Python 版本
+      placeholder: e.g. 3.11.0
+    validations:
+      required: true
+
+  - type: input
+    id: env-zhenxun-ver
+    attributes:
+      label: zhenxun_bot 版本
+      description: 填写 zhenxun_bot 版本
+      placeholder: e.g. 0.1.0
+    validations:
+      required: true
+
+  - type: input
+    id: env-adapter
+    attributes:
+      label: 适配器
+      description: 填写使用的适配器以及版本
+      placeholder: e.g. OneBot v11 2.2.2
+    validations:
+      required: true
+
+  - type: input
+    id: env-protocol
+    attributes:
+      label: 协议端
+      description: 填写连接 zhenxun_bot 的协议端及版本
+      placeholder: e.g. NapCat V4.0.3
+    validations:
+      required: true
+
+  - type: textarea
+    id: describe
+    attributes:
+      label: 描述问题
+      description: 清晰简洁地说明问题是什么
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: 复现步骤
+      description: 提供能复现此问题的详细操作步骤
+      placeholder: |
+        1. 首先……
+        2. 然后……
+        3. 发生……
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: 期望的结果
+      description: 清晰简洁地描述你期望发生的事情
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: 截图或日志（请勿包含敏感信息如密码、令牌等）
+      description: 提供有助于诊断问题的任何日志和截图

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/document.yml

@@ -0,0 +1,18 @@
+name: 文档改进
+title: "Docs: 描述"
+description: 文档错误及改进意见反馈
+labels: ["documentation"]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: 描述问题或主题
+    validations:
+      required: true
+
+  - type: textarea
+    id: improve
+    attributes:
+      label: 需做出的修改
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,27 @@
+name: 功能建议
+title: "Feature: 功能描述"
+description: 提出关于项目新功能的想法
+labels: [ "enhancement" ]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: 希望能解决的问题
+      description: 在使用中遇到什么问题而需要新的功能？
+    validations:
+      required: true
+
+  - type: textarea
+    id: feature
+    attributes:
+      label: 描述所需要的功能
+      description: 请说明需要的功能或解决方法
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: 我有能力且愿意为这个功能贡献代码
+      options:
+        - label: 我有能力且愿意为这个功能贡献代码

.github/actions/setup-python/action.yml

@@ -0,0 +1,40 @@
+name: Setup Python
+description: Setup Python
+
+inputs:
+  python-version:
+    description: Python version
+    required: false
+    default: "3.10"
+  env-dir:
+    description: Environment directory
+    required: false
+    default: "."
+  no-root:
+    description: Do not install package in the environment
+    required: false
+    default: "false"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install poetry
+      run: pipx install poetry
+      shell: bash
+
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+        cache: "poetry"
+        cache-dependency-path: |
+          ./poetry.lock
+          ${{ inputs.env-dir }}/poetry.lock
+
+    - run: |
+        cd ${{ inputs.env-dir }}
+        if [ "${{ inputs.no-root }}" = "true" ]; then
+          poetry install --all-extras --no-root
+        else
+          poetry install --all-extras
+        fi
+      shell: bash

.github/release-drafter.yml

@@ -0,0 +1,77 @@
+template: $CHANGES
+name-template: "v$RESOLVED_VERSION"
+tag-template: "v$RESOLVED_VERSION"
+exclude-labels:
+  - reverted
+  - no-changelog
+  - skip-changelog
+  - invalid
+autolabeler:
+  - label: "bug"
+    title:
+      - "/:bug:.+/"
+      - "/🐛.+/"
+  - label: "enhancement"
+    title:
+      - "/:sparkles:.+/"
+      - "/✨.+/"
+  - label: "ci"
+    files:
+      - .github/**/*
+  - label: "breaking-change"
+    title:
+      - "/.+!:.+/"
+  - label: "documentation"
+    files:
+      - "*.md"
+  - label: "dependencies"
+    files:
+      - "pyproject.toml"
+      - "requirements.txt"
+      - "poetry.lock"
+    title:
+      - "/:wrench:.+/"
+      - "/🔧.+/"
+  - label: "resources"
+    files:
+      - resources/**/*
+categories:
+  - title: 💥 破坏性变更
+    labels:
+      - breaking-change
+  - title: 🚀 新功能
+    labels:
+      - enhancement
+  - title: 🐛 Bug 修复
+    labels:
+      - bug
+  - title: 📝 文档更新
+    labels:
+      - documentation
+  - title: 👻 自动化程序
+    labels:
+      - chore
+      - internal
+      - maintenance
+  - title: 🚦 测试
+    labels:
+      - test
+      - tests
+  - title: 📦 依赖更新
+    labels:
+      - dependencies
+    collapse-after: 15
+  - title: 💫 杂项
+change-template: "- $TITLE @$AUTHOR (#$NUMBER)"
+change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks.
+version-resolver:
+  major:
+    labels:
+      - "major"
+  minor:
+    labels:
+      - "minor"
+  patch:
+    labels:
+      - "patch"
+  default: patch

.github/workflows/bot_check.yml

@@ -0,0 +1,84 @@
+name: 检查bot是否运行正常
+
+on:
+  push:
+    branches: ["main"]
+    paths:
+      - zhenxun/**
+      - tests/**
+      - .github/workflows/bot_check.yml
+      - bot.py
+  pull_request:
+    branches: ["main"]
+    paths:
+      - zhenxun/**
+      - tests/**
+      - .github/workflows/bot_check.yml
+      - bot.py
+
+jobs:
+  bot-check:
+    runs-on: ubuntu-latest
+    name: bot check
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python
+        id: setup_python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install Poetry
+        run: pip install poetry
+
+      # Poetry cache depends on OS, Python version and Poetry version.
+      - name: Cache Poetry cache
+        id: cache-poetry
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pypoetry
+          key: poetry-cache-${{ runner.os }}-${{ steps.setup_python.outputs.python-version }}-${{ hashFiles('pyproject.toml') }}
+
+      - name: Cache playwright cache
+        id: cache-playwright
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/ms-playwright
+          key: playwright-cache-${{ runner.os }}-${{ steps.setup_python.outputs.python-version }}
+
+      - name: Cache Data cache
+        uses: actions/cache@v3
+        with:
+          path: data
+          key: data-cache-${{ runner.os }}-${{ steps.setup_python.outputs.python-version }}
+
+      - name: Install dependencies
+        if: steps.cache-poetry.outputs.cache-hit != 'true'
+        run: |
+          rm -rf poetry.lock
+          poetry source remove aliyun
+          poetry install --no-root
+
+      - name: Install playwright
+        if: steps.cache-playwright.outputs.cache-hit != 'true'
+        run: |
+          poetry run sudo apt-get update
+          poetry run sudo apt-get install -y libgstreamer-plugins-base1.0-0 libgstreamer1.0-0 gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-libav flite x264 libx264-dev
+          poetry run pip install playwright
+          poetry run playwright install-deps
+          poetry run playwright install
+
+      - name: Run tests
+        run: poetry run pytest --cov=zhenxun --cov-report xml
+
+      - name: Check bot run
+        id: bot_check_run
+        run: |
+          mv scripts/bot_check.py bot_check.py
+          sed -i "s|^.*\?DB_URL.*|DB_URL=\"${{ env.DB_URL }}\"|g" .env.dev
+          sed -i "s/^.*\?LOG_LEVEL.*/LOG_LEVEL=${{ env.LOG_LEVEL }}/g" .env.dev
+          poetry run python3 bot_check.py
+        env:
+          DB_URL: "sqlite://:memory:"
+          LOG_LEVEL: DEBUG

.github/workflows/codeql.yml

@@ -0,0 +1,91 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Code Security Analysis"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '45 21 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: python
+            build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+
+          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+          # queries: security-extended,security-and-quality
+
+      # If the analyze step fails for one of the languages you are analyzing with
+      # "We were unable to automatically build your code", modify the matrix above
+      # to set the build mode to "manual" for that language. Then modify this step
+      # to build your code.
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+      - if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          echo 'If you are using a "manual" build mode for one or more of the' \
+            'languages you are analyzing, replace this with the commands to build' \
+            'your code, for example:'
+          echo '  make bootstrap'
+          echo '  make release'
+          exit 1
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/linting.yml

@@ -0,0 +1,11 @@
+name: Sequential Lint and Type Check
+
+on: [push, pull_request]
+
+jobs:
+  ruff-call:
+    uses: ./.github/workflows/ruff.yml
+
+  pyright-call:
+    needs: ruff-call
+    uses: ./.github/workflows/pyright.yml

.github/workflows/publish-docker.yml

@@ -0,0 +1,58 @@
+#
+name: Create and publish a Docker image
+
+# Configures this workflow to run on demand via workflow_dispatch.
+on:
+  workflow_dispatch:
+
+# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+      #
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
+      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see [Usage](https://github.com/docker/build-push-action#usage) in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+      
+      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see [Using artifact attestations to establish provenance for builds](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds).
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true

.github/workflows/pyright.yml

@@ -0,0 +1,55 @@
+name: Pyright Lint
+
+on:
+  workflow_call:
+
+  workflow_dispatch:
+    inputs:
+      python-version:
+        description: "Python version"
+        required: false
+        type: choice
+        options:
+          - "all"
+          - "3.10"
+          - "3.11"
+          - "3.12"
+        default: "all"
+      debug-mode:
+        description: "enable debug mode"
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  pyright:
+    name: Pyright Lint
+    runs-on: ubuntu-latest
+    concurrency:
+      group: pyright-${{ github.ref }}-${{ matrix.env }}
+      cancel-in-progress: true
+    strategy:
+      matrix:
+        env: [pydantic-v1, pydantic-v2]
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python environment
+        uses: ./.github/actions/setup-python
+        with:
+          env-dir: ./envs/${{ matrix.env }}
+          no-root: true
+
+      - run: |
+          (cd ./envs/${{ matrix.env }} && echo "$(poetry env info --path)/bin" >> $GITHUB_PATH)
+          if [ "${{ matrix.env }}" = "pydantic-v1" ]; then
+            sed -i 's/PYDANTIC_V2 = true/PYDANTIC_V2 = false/g' ./pyproject.toml
+          fi
+        shell: bash
+
+      - name: Run Pyright Check
+        uses: jakebailey/pyright-action@v2
+        with:
+          pylance-version: latest-release

.github/workflows/release_draft.yml

@@ -0,0 +1,18 @@
+name: Release Drafter
+
+on:
+  push:
+    branches:
+      - main
+      - dev
+  pull_request:
+    types: [opened, reopened, synchronize]
+
+jobs:
+  update_release_draft:
+    name: Update Release Draft
+    runs-on: ubuntu-latest
+    steps:
+      - uses: release-drafter/release-drafter@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}

.github/workflows/ruff.yml

@@ -0,0 +1,20 @@
+name: Ruff Lint
+
+on:
+  workflow_call:
+
+jobs:
+  ruff:
+    name: Ruff Lint
+    runs-on: ubuntu-latest
+    concurrency:
+      group: ruff-${{ github.ref }}
+      cancel-in-progress: true
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Ruff
+        uses: astral-sh/ruff-action@v3
+      - name: Run Ruff Check
+        run: ruff check

.github/workflows/sync-to-aliyun.yml

@@ -0,0 +1,26 @@
+name: Force Sync to Aliyun
+on:
+  push:
+    branches: ["main"]
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Configure Git
+        run: |
+          git config --global http.postBuffer 524288000  
+          git config --global core.compression 0
+
+      - name: Add aliyun remote
+        run: |
+          git remote add aliyun https://${{secrets.ALIYUN_ACCOUNT}}:${{secrets.ALIYUN_PASSWORD}}@codeup.aliyun.com/67a361cf556e6cdab537117a/zhenxun-org/zhenxun_bot.git
+          git fetch aliyun main --force  # 强制更新本地引用
+
+      - name: Force push
+        run: git push --progress --force aliyun HEAD:main

.github/workflows/update_version_pr.yml

@@ -0,0 +1,73 @@
+name: Update Version
+
+on:
+  push:
+    paths:
+      - .github/workflows/update_version_pr.yml
+      - zhenxun/**
+      - resources/**
+      - bot.py
+    branches:
+      - main
+      - dev
+
+jobs:
+  update-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GH_TOKEN }}
+
+      - name: Read current version
+        id: read_version
+        run: |
+          version_line=$(grep '__version__' __version__)
+          version=$(echo $version_line | sed -E 's/__version__:\s*v([0-9]+\.[0-9]+\.[0-9]+)(-.+)?/\1/')
+          echo "Current version: $version"
+          echo "current_version=$version" >> $GITHUB_OUTPUT
+
+      - name: Check for version file changes
+        id: check_diff
+        run: |
+          if git diff --name-only HEAD~1 HEAD | grep -q '__version__'; then
+            echo "Version file has changes"
+            echo "version_changed=true" >> $GITHUB_OUTPUT
+          else
+            echo "Version file has no changes"
+            echo "version_changed=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Get commit hash
+        id: get_commit_hash
+        run: echo "commit_hash=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+      - name: Update version file
+        id: update_version
+        if: steps.check_diff.outputs.version_changed == 'false'
+        run: |
+          current_version="${{ steps.read_version.outputs.current_version }}"
+          commit_hash="${{ steps.get_commit_hash.outputs.commit_hash }}"
+          new_version="v${current_version}-${commit_hash}"
+          echo "new_version=$new_version" >> $GITHUB_OUTPUT
+          echo "Updating version to: $new_version"
+          echo "__version__: $new_version" > __version__
+
+      - name: Check updated version
+        if: steps.check_diff.outputs.version_changed == 'false'
+        run: cat __version__
+
+      - name: Create or update PR
+        if: steps.check_diff.outputs.version_changed == 'false'
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GH_TOKEN }}
+          branch: create-pr/update_version
+          title: ":tada: chore(version): 自动更新版本到 ${{ steps.update_version.outputs.new_version }}"
+          body: "This PR updates the version file."
+          commit-message: ":tada: chore(version): Update version to ${{ steps.update_version.outputs.new_version }}"
+          add-paths: __version__
+          author: "AkashiCoin <i@loli.vet>"
+          committer: "${{ github.actor }} <${{ github.actor_id }}+${{ github.actor }}@users.noreply.github.com>"
+          labels: automated-update

.gitignore

@@ -32,6 +32,7 @@ MANIFEST
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
 *.spec
+!resources.spec
 
 # Installer logs
 pip-log.txt
@@ -113,6 +114,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+.env.dev
 
 # Spyder project settings
 .spyderproject
@@ -138,9 +140,11 @@ dmypy.json
 # Cython debug symbols
 cython_debug/
 
-test.py
-server_ip.py
-member_activity_handle.py
-Yu-Gi-Oh/
-csgo/
-fantasy_card/
+data/
+log/
+backup/
+.idea/
+resources/
+.vscode/launch.json
+
+./.env.dev

.markdownlint.yaml

@@ -0,0 +1,4 @@
+MD013: false
+MD024: # 重复标题
+  siblings_only: true
+MD033: false # 允许 html

.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+default_install_hook_types: [pre-commit]
+ci:
+  autofix_commit_msg: ":rotating_light: auto fix by pre-commit hooks"
+  autofix_prs: true
+  autoupdate_branch: main
+  autoupdate_schedule: monthly
+  autoupdate_commit_msg: ":arrow_up: auto update by pre-commit hooks"
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.2
+    hooks:
+      - id: ruff
+        args: [--fix]
+        stages: [pre-commit]
+      - id: ruff-format
+        stages: [pre-commit]

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "charliermarsh.ruff",
+    "esbenp.prettier-vscode",
+    "ms-python.python",
+    "ms-python.vscode-pylance"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,65 @@
+{
+  "C_Cpp.errorSquiggles": "enabled",
+  "terminal.integrated.env.linux": {
+    "PYTHONPATH": "${workspaceFolder}${pathSeparator}${env:PYTHONPATH}"
+  },
+  "cSpell.words": [
+    "aiofiles",
+    "Alconna",
+    "arclet",
+    "Arparma",
+    "displayname",
+    "flmt",
+    "getbbox",
+    "gitcode",
+    "GITEE",
+    "hibiapi",
+    "httpx",
+    "jsdelivr",
+    "kaiheila",
+    "lolicon",
+    "Mahiro",
+    "nonebot",
+    "onebot",
+    "pixiv",
+    "qbot",
+    "Setu",
+    "tobytes",
+    "ujson",
+    "unban",
+    "Uninfo",
+    "userinfo",
+    "webui",
+    "zhenxun"
+  ],
+  "python.analysis.autoImportCompletions": true,
+  "python.testing.pytestArgs": ["tests"],
+  "python.testing.unittestEnabled": false,
+  "python.testing.pytestEnabled": true,
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.wordBasedSuggestions": "allDocuments",
+    "editor.formatOnType": true,
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "explicit",
+      "source.organizeImports": "explicit"
+    }
+  },
+  "ruff.format.preview": false,
+  "isort.check": true,
+  "ruff.importStrategy": "useBundled",
+  "ruff.organizeImports": false,
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[yaml]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[markdown]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,87 @@
+# zhenxun_bot 贡献者公约
+
+## 我们的承诺
+
+身为社区成员、贡献者和负责人，我们承诺使社区参与者不受骚扰，无论其年龄、体型、可见或不可见的缺陷、族裔、性征、性别认同和表达、经验水平、教育程度、社会与经济地位、国籍、相貌、种族、种姓、肤色、宗教信仰、性倾向或性取向如何。
+
+我们承诺以有助于建立开放、友善、多样化、包容、健康社区的方式行事和互动。
+
+## 我们的准则
+
+有助于为我们的社区创造积极环境的行为例子包括但不限于：
+
+* 表现出对他人的同情和善意
+* 尊重不同的主张、观点和感受
+* 提出和大方接受建设性意见
+* 承担责任并向受我们错误影响的人道歉
+* 注重社区共同诉求，而非个人得失
+
+不当行为例子包括：
+
+* 使用情色化的语言或图像，及性引诱或挑逗
+* 嘲弄、侮辱或诋毁性评论，以及人身或政治攻击
+* 公开或私下的骚扰行为
+* 未经他人明确许可，公布他人的私人信息，如物理或电子邮件地址
+* 其他有理由认定为违反职业操守的不当行为
+
+## 责任和权力
+
+社区负责人有责任解释和落实我们所认可的行为准则，并妥善公正地对他们认为不当、威胁、冒犯或有害的任何行为采取纠正措施。
+
+社区负责人有权力和责任删除、编辑或拒绝或拒绝与本行为准则不相符的评论（comment）、提交（commits）、代码、维基（wiki）编辑、议题（issues）或其他贡献，并在适当时机知采取措施的理由。
+
+## 适用范围
+
+本行为准则适用于所有社区场合，也适用于在公共场所代表社区时的个人。
+
+代表社区的情形包括使用官方电子邮件地址、通过官方社交媒体帐户发帖或在线上或线下活动中担任指定代表。
+
+## 监督
+
+辱骂、骚扰或其他不可接受的行为可通过 775757368@qq.com 向负责监督的社区负责人报告。
+所有投诉都将得到及时和公平的审查和调查。
+
+所有社区负责人都有义务尊重任何事件报告者的隐私和安全。
+
+## 处理方针
+
+社区负责人将遵循下列社区处理方针来明确他们所认定违反本行为准则的行为的处理方式：
+
+### 1. 纠正
+
+**社区影响**：使用不恰当的语言或其他在社区中被认定为不符合职业道德或不受欢迎的行为。
+
+**处理意见**：由社区负责人发出非公开的书面警告，明确说明违规行为的性质，并解释举止如何不妥。或将要求公开道歉。
+
+### 2. 警告
+
+**社区影响**：单个或一系列违规行为。
+
+**处理意见**：警告并对连续性行为进行处理。在指定时间内，不得与相关人员互动，包括主动与行为准则执行者互动。这包括避免在社区场所和外部渠道中的互动。违反这些条款可能会导致临时或永久封禁。
+
+### 3. 临时封禁
+
+**社区影响**: 严重违反社区准则，包括持续的不当行为。
+
+**处理意见**: 在指定时间内，暂时禁止与社区进行任何形式的互动或公开交流。在此期间，不得与相关人员进行公开或私下互动，包括主动与行为准则执行者互动。违反这些条款可能会导致永久封禁。
+
+### 4. 永久封禁
+
+**社区影响**：行为模式表现出违反社区准则，包括持续的不当行为、骚扰个人或攻击或贬低某个类别的个体。
+
+**处理意见**：永久禁止在社区内进行任何形式的公开互动。
+
+## 参见
+
+本行为准则改编自 [Contributor Covenant][homepage] 2.1 版, 参见 [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]。
+
+社区处理方针灵感来源于 [Mozilla's code of conduct enforcement ladder][Mozilla CoC]。
+
+有关本行为准则的常见问题的答案，参见 [https://www.contributor-covenant.org/faq][FAQ]。
+其他语言翻译参见 [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,95 @@
+# zhenxun_bot 贡献指南
+
+首先，感谢你愿意为 zhenxun_bot 贡献自己的一份力量！
+
+本指南旨在引导你更规范地向 zhenxun_bot 提交贡献，请务必认真阅读。
+
+## 提交 Issue
+
+在提交 Issue 前，我们建议你先查看 [已有的 Issues](https://github.com/HibiKier/zhenxun_bot/issues)，以防重复提交。
+
+### 报告问题、故障与漏洞
+
+如果你在使用过程中发现问题并确信是由 zhenxun_bot 引起的，欢迎提交 Issue。
+
+请使用我们提供的 **Bug 反馈** 模板，并尽可能详细地描述：
+
+- 问题描述
+- 重现步骤
+- 你的环境信息（如操作系统、依赖版本等）
+
+### 建议功能
+
+如果你有新的功能需求或改进建议，欢迎提出。
+
+请使用 **功能建议** 模板，并详细描述你所需要的特性，可能的话可以提出你认为可行的解决方案。
+
+### 文档相关
+
+如果你觉得文档有误或缺乏更新，欢迎提出。
+
+请使用 **文档改进** 模板，并详细描述问题或主题，希望我们做出的修改
+
+## Pull Request
+
+### 分支管理
+
+请从 `main` 分支创建新功能分支，例如：
+
+- 新功能：`feature/功能描述`
+- 问题修复：`bugfix/问题描述`
+
+### 代码风格
+
+zhenxun_bot 使用 `pre-commit` 进行代码格式化和检查，请在提交前确保代码通过检查。
+
+```bash
+# 在安装项目依赖后安装 pre-commit 钩子
+pre-commit install
+```
+
+> 未通过 `pre-commit` 检查的代码将无法合并。
+
+### Commit 规范
+
+请确保你的每一个 commit 都能清晰地描述其意图，一个 commit 尽量只有一个目的。
+
+我们建议遵循 [gitmoji](https://gitmoji.dev/) 的 commit message 格式，在创建 commit 时请牢记这一点。
+
+### 工作流程概述
+
+`main` 分支为 zhenxun_bot 的主分支，在任何情况下都请不要直接修改 `main` 分支，而是创建一个目标分支为 `main` 的 Pull Request 来提交修改。Pull Request 标题请尽量清晰，以便维护者进行审核。
+
+如果你不是 zhenxun_bot 团队的成员，可在 fork 本仓库后，向本仓库的 `main` 分支发起 Pull Request，注意遵循先前提到的 commit message 规范创建 commit。我们将在 code review 通过后合并你的贡献。
+
+### 撰写文档
+
+如果你对文档有改进建议，欢迎提交 Pull Request 或者 Issue。
+
+[//]: # (我们使用 Markdown 编写文档，建议遵循以下规范：)
+
+[//]: # ()
+[//]: # (1. 中文与英文、数字、半角符号之间需要有空格。例：`zhenxun_bot 是一个高效的聊天机器人。`)
+
+[//]: # (2. 若非英文整句，使用全角标点符号。例：`现在你可以看到机器人回复你：“Hello，世界！”。`)
+
+[//]: # (3. 直引号`「」`和弯引号`“”`都可接受，但同一份文件里应使用同种引号。)
+
+[//]: # (4. **不要使用斜体**，你不需要一种与粗体不同的强调。)
+
+[//]: # (5. 文档中应以“我们”指代开发者，以“用户”指代机器人的使用者。)
+
+[//]: # ()
+[//]: # (如果你需要编辑器检查 Markdown 规范，可以在 VSCode 中安装 `markdownlint` 扩展。)
+
+### 参与开发
+
+zhenxun_bot 的代码风格遵循 [PEP 8](https://www.python.org/dev/peps/pep-0008/) 与 [PEP 484](https://www.python.org/dev/peps/pep-0484/) 规范，请确保你的代码风格和项目已有的代码保持一致，变量命名清晰，有适当的注释与测试代码。
+
+> 暂未搭建测试框架，因此暂不要求添加测试代码。
+
+## 项目沟通
+
+如有关于贡献流程的疑问或需要进一步指导，请通过 [QQ群](https://jq.qq.com/?_wv=1027&k=u8PgBkMZ) 联系我们。
+
+再次感谢你的贡献！

Dockerfile

@@ -0,0 +1,67 @@
+FROM python:3.11-bookworm AS requirements-stage
+
+WORKDIR /tmp
+
+ENV POETRY_HOME="/opt/poetry" PATH="${PATH}:/opt/poetry/bin"
+
+RUN curl -sSL https://install.python-poetry.org | python - -y && \
+  poetry self add poetry-plugin-export
+
+COPY ./pyproject.toml ./poetry.lock* /tmp/
+
+RUN poetry export \
+      -f requirements.txt \
+      --output requirements.txt \
+      --without-hashes \
+      --without-urls
+
+FROM python:3.11-bookworm AS build-stage
+
+WORKDIR /wheel
+
+COPY --from=requirements-stage /tmp/requirements.txt /wheel/requirements.txt
+
+# RUN python3 -m pip config set global.index-url https://mirrors.aliyun.com/pypi/simple
+
+RUN pip wheel --wheel-dir=/wheel --no-cache-dir --requirement /wheel/requirements.txt
+
+FROM python:3.11-bookworm AS metadata-stage
+
+WORKDIR /tmp
+
+RUN --mount=type=bind,source=./.git/,target=/tmp/.git/ \
+  git describe --tags --exact-match > /tmp/VERSION 2>/dev/null \
+  || git rev-parse --short HEAD > /tmp/VERSION \
+  && echo "Building version: $(cat /tmp/VERSION)"
+
+FROM python:3.11-slim-bookworm
+
+WORKDIR /app/zhenxun
+
+ENV TZ=Asia/Shanghai PYTHONUNBUFFERED=1
+#COPY ./scripts/docker/start.sh /start.sh
+#RUN chmod +x /start.sh
+
+EXPOSE 8080
+
+RUN apt update && \
+    apt install -y --no-install-recommends curl fontconfig fonts-noto-color-emoji \
+    && apt clean \
+    && fc-cache -fv \
+    && apt-get purge -y --auto-remove curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制依赖项和应用代码
+COPY --from=build-stage /wheel /wheel
+COPY . .
+
+RUN pip install --no-cache-dir --no-index --find-links=/wheel -r /wheel/requirements.txt && rm -rf /wheel
+
+RUN playwright install --with-deps chromium \
+  && rm -rf /var/lib/apt/lists/* /tmp/*
+
+COPY --from=metadata-stage /tmp/VERSION /app/VERSION
+
+VOLUME ["/app/zhenxun/data", "/app/zhenxun/resources", "/app/zhenxun/log"]
+
+CMD ["python", "bot.py"]

README.md

@@ -1,204 +1,156 @@
-<div align=center><img width="320" height="320" src="https://raw.githubusercontent.com/HibiKier/zhenxun_bot/main/logo.png"/></div>
+<!-- markdownlint-disable MD033 MD041 -->
+<div align=center>
 
-![maven](https://img.shields.io/badge/python-3.8%2B-blue)
-![maven](https://img.shields.io/badge/nonebot-2.0.0-yellow)
-![maven](https://img.shields.io/badge/go--cqhttp-1.0.0-red)
+<img width="250" height="312" src=./docs_image/tt.jpg alt="zhenxun_bot"/>
 
-# 绪山真寻Bot
-****
-此项目基于 Nonebot2 和 go-cqhttp 开发，以 postgresql 作为数据库的QQ群娱乐机器人
-## 关于
-用爱发电，某些功能学习借鉴了大佬们的代码，因为绪山真寻实在太可爱了因此开发了
-绪山真寻bot，实现了一些对群友的娱乐功能和实用功能（大概）。
+</div>
 
-如果该项目的图片等等侵犯猫豆腐老师权益请联系我删除！  
+<div align=center>
+<a href="./LICENSE">
+    <img src="https://img.shields.io/badge/license-AGPL3.0-FE7D37" alt="license">
+</a>
+<a href="https://www.python.org">
+    <img src="https://img.shields.io/badge/Python-3.10%20%7C%203.11%20%7C%203.12-blue" alt="python">
+</a>
+<a href="https://nonebot.dev/">
+    <img src="https://img.shields.io/badge/nonebot-v2.1.3-EA5252" alt="nonebot">
+</a>
+<a href="https://onebot.dev/">
+  <img src="https://img.shields.io/badge/OneBot-v11-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="onebot">
+</a>
+<a href="https://onebot.dev/">
+  <img src="https://img.shields.io/badge/OneBot-v12-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="onebot">
+</a>
+<a href="https://bot.q.qq.com/wiki/">
+  <img src="https://img.shields.io/badge/QQ-Bot-lightgrey?style=social&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMTIuODIgMTMwLjg5Ij48ZyBkYXRhLW5hbWU9IuWbvuWxgiAyIj48ZyBkYXRhLW5hbWU9IuWbvuWxgiAxIj48cGF0aCBkPSJNNTUuNjMgMTMwLjhjLTcgMC0xMy45LjA4LTIwLjg2IDAtMTkuMTUtLjI1LTMxLjcxLTExLjQtMzQuMjItMzAuMy00LjA3LTMwLjY2IDE0LjkzLTU5LjIgNDQuODMtNjYuNjQgMi0uNTEgNS4yMS0uMzEgNS4yMS0xLjYzIDAtMi4xMy4xNC0yLjEzLjE0LTUuNTcgMC0uODktMS4zLTEuNDYtMi4yMi0yLjMxLTYuNzMtNi4yMy03LjY3LTEzLjQxLTEtMjAuMTggNS40LTUuNTIgMTEuODctNS40IDE3LjgtLjU5IDYuNDkgNS4yNiA2LjMxIDEzLjA4LS44NiAyMS0uNjguNzQtMS43OCAxLjYtMS43OCAyLjY3djQuMjFjMCAxLjM1IDIuMiAxLjYyIDQuNzkgMi4zNSAzMS4wOSA4LjY1IDQ4LjE3IDM0LjEzIDQ1IDY2LjM3LTEuNzYgMTguMTUtMTQuNTYgMzAuMjMtMzIuNyAzMC42My04LjAyLjE5LTE2LjA3LS4wMS0yNC4xMy0uMDF6IiBmaWxsPSIjMDI5OWZlIi8+PHBhdGggZD0iTTMxLjQ2IDExOC4zOGMtMTAuNS0uNjktMTYuOC02Ljg2LTE4LjM4LTE3LjI3LTMtMTkuNDIgMi43OC0zNS44NiAxOC40Ni00Ny44MyAxNC4xNi0xMC44IDI5Ljg3LTEyIDQ1LjM4LTMuMTkgMTcuMjUgOS44NCAyNC41OSAyNS44MSAyNCA0NS4yOS0uNDkgMTUuOS04LjQyIDIzLjE0LTI0LjM4IDIzLjUtNi41OS4xNC0xMy4xOSAwLTE5Ljc5IDAiIGZpbGw9IiNmZWZlZmUiLz48cGF0aCBkPSJNNDYuMDUgNzkuNThjLjA5IDUgLjIzIDkuODItNyA5Ljc3LTcuODItLjA2LTYuMS01LjY5LTYuMjQtMTAuMTktLjE1LTQuODItLjczLTEwIDYuNzMtOS44NHM2LjM3IDUuNTUgNi41MSAxMC4yNnoiIGZpbGw9IiMxMDlmZmUiLz48cGF0aCBkPSJNODAuMjcgNzkuMjdjLS41MyAzLjkxIDEuNzUgOS42NC01Ljg4IDEwLTcuNDcuMzctNi44MS00LjgyLTYuNjEtOS41LjItNC4zMi0xLjgzLTEwIDUuNzgtMTAuNDJzNi41OSA0Ljg5IDYuNzEgOS45MnoiIGZpbGw9IiMwODljZmUiLz48L2c+PC9nPjwvc3ZnPg==" alt="QQ">
+</a>
+<a href="https://github.com/psf/black">
+  <img src="https://img.shields.io/badge/code%20style-black-000000.svg?logo=python&logoColor=edb641" alt="black">
+</a>
+<a href="https://github.com/Microsoft/pyright">
+  <img src="https://img.shields.io/badge/types-pyright-797952.svg?logo=python&logoColor=edb641" alt="pyright">
+</a>
+<a href="https://github.com/astral-sh/ruff">
+  <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="ruff">
+</a>
+</div>
 
-如果希望有个地方讨论绪山真寻Bot，或者有问题或建议，可以发送issues或加入[ <strong>[是真寻酱哒](https://jq.qq.com/?_wv=1027&k=u8PgBkMZ) </strong>]
+<div align=center>
 
-## 声明
-此项目仅用于学习交流，请勿用于非法用途
+[![tencent-qq](https://img.shields.io/badge/%E7%BE%A4-是真寻酱哒-red?style=logo=tencent-qq)](https://qm.qq.com/q/mRNtLSl6uc)
+[![tencent-qq](https://img.shields.io/badge/%E7%BE%A4-真寻的技术群-c73e7e?style=logo=tencent-qq)](https://qm.qq.com/q/YYYt5rkMYc)
 
-## Gitee
+</div>
 
-# [Gitee](https://gitee.com/two_Dimension/zhenxun_bot)
+<div align=center>
 
-## 未完成的文档
+[文档](https://zhenxun-org.github.io/zhenxun_bot/)
 
-# [传送门](https://hibikier.github.io/zhenxun_bot/)
+</div>
 
-## 真寻的帮助
-请对真寻说: '真寻帮助' or '管理员帮助' or '超级用户帮助' or '真寻帮助 指令'
+<div align=center>
 
-## 普通帮助图片
-![x](https://github.com/HibiKier/zhenxun_bot/blob/0.0.8.2/docs_image/3238573864-836268675-E2FFBB2AC143EAF4DDDF150438508721.png)
+## 绪山真寻 Bot
 
-## Web UI
-[zhenxun_bot_webui](https://github.com/HibiKier/zhenxun_bot_webui)
+</div>
 
-## 一键安装脚本
-[zhenxun_bot-deploy](https://github.com/AkashiCoin/zhenxun_bot-deploy)
+<div align=center>
 
-## 提供符合真寻标准的插件仓库
+“真寻是<strong>[椛椛](https://github.com/FloatTech/ZeroBot-Plugin)</strong>的好朋友！”
 
-[AkashiCoin/nonebot_plugins_zhenxun_bot](https://github.com/AkashiCoin/nonebot_plugins_zhenxun_bot)
+🎉 喜欢真寻，于是真寻就来了！🎉
 
-## 来点优点？
+本项目符合 [OneBot](https://github.com/howmanybots/onebot) 标准，可基于以下项目与机器人框架/平台进行交互
 
-  * 实现了许多功能，且提供了大量功能管理命令
-  * 通过Config配置项将所有插件配置统计保存至config.yaml，利于统一用户修改
-  * 方便增删插件，原生nonebot2 matcher，不需要额外修改，仅仅通过简单的配置属性就可以生成`帮助图片`和`帮助信息`
-  * 提供了cd，阻塞，每日次数等限制，仅仅通过简单的属性就可以生成一个限制，例如：`__plugin_cd_limit__`
-  * __..... 更多详细请通过`传送门`查看文档！__
+|                           项目地址                            | 平台 |         核心作者         | 备注 |
+| :-----------------------------------------------------------: | :--: | :----------------------: | :--: |
+|       [LLOneBot](https://github.com/LLOneBot/LLOneBot)        | NTQQ |        linyuchen         | 可用 |
+|         [Napcat](https://github.com/NapNeko/NapCatQQ)         | NTQQ |         NapNeko          | 可用 |
+| [Lagrange.Core](https://github.com/LagrangeDev/Lagrange.Core) | NTQQ | LagrangeDev/Linwenxuan04 | 可用 |
 
+</div>
+
+<div align=center>
+
+<img width="100%" src="https://starify.komoridevs.icu/api/starify?owner=HibiKier&repo=zhenxun_bot" alt="starify" />
+
+<img src="https://api.star-history.com/svg?repos=HibiKier/zhenxun_bot&type=Timeline" alt="Star Trend" width="800" />
+
+</div>
+
+## 🤝 帮助页面
 
-## 功能列表
 <details>
-<summary>已实现的功能</summary>
-
-### 已实现的常用功能
-- [x] 昵称系统（群与群与私聊分开.）
-- [x] 图灵AI（会把'你'等关键字替换为你的昵称），且带有 [AnimeThesaurus](https://github.com/Kyomotoi/AnimeThesaurus)，够味
-- [x] 签到/我的签到/好感度排行/好感度总排行（影响色图概率和开箱次数，支持配置）
-- [x] 发送某文件夹下的随机图片（支持自定义，默认：美图，萝莉，壁纸）
-- [x] 色图（这不是基础功能嘛喂）
-- [x] coser
-- [x] 黑白草图生成器
-- [x] 鸡汤/语录
-- [x] 骂我（钉宫语音）
-- [x] 戳一戳（概率发送美图，钉宫语音或者戳回去）
-- [x] 模拟开箱/我的开箱/群开箱统计/我的金色/设置cookie（csgo，内置爬虫脚本，需要提前抓取数据和图片，需要session，可能需要代理，阿里云服务器等ip也许已经被ban了（我无代理访问失败），如果访问太多账号API调用可能被禁止访问api！）
-- [x] 鲁迅说过
-- [x] 构造假消息（自定义的分享链接）
-- [x] 商店/我的金币/购买道具/使用道具
-- [x] 8种手游抽卡 (查看 [nonebot_plugin_gamedraw](https://github.com/HibiKier/nonebot_plugin_gamedraw))
-- [x] 我有一个朋友想问问..（借鉴pcrbot插件）
-- [x] 原神黄历
-- [x] 原神今日素材
-- [x] 原神资源查询  (借鉴[Genshin_Impact_bot](https://github.com/H-K-Y/Genshin_Impact_bot)插件)
-- [x] 原神便笺查询
-- [x] 原神玩家查询
-- [x] 原神树脂提醒
-- [x] 原神签到/自动签到
-- [x] 金币红包
-- [x] 微博热搜
-- [x] B站主播/UP/番剧订阅
-
-- [x] pil对图片的一些操作
-- [x] BUFF饰品底价查询（需要session）
-- [x] 天气查询
-- [x] 疫情查询
-- [x] bt磁力搜索（咳咳，这功能我想dddd）
-- [x] reimu搜索（上车） (使用[XUN_Langskip](https://github.com/Angel-Hair/XUN_Bot)的插件)
-- [x] 靠图识番  (使用[XUN_Langskip](https://github.com/Angel-Hair/XUN_Bot)的插件)
-- [x] 以图搜图 (使用[nonebot_plugin_picsearcher](https://github.com/synodriver/nonebot_plugin_picsearcher)插件)
-- [x] 搜番
-- [x] 点歌  [nonebot_plugin_songpicker2](https://github.com/maxesisn/nonebot_plugin_songpicker2)插件（删除了选歌和评论）
-- [x] epic免费游戏
-- [x] p站排行榜
-- [x] p站搜图
-- [x] 翻译（日英韩）
-- [x] pix图库（一个自己的图库，含有增删查改，黑名单等命令）
-
-- [x] 查看当前群欢迎消息
-- [x] 查看该群自己的权限
-- [x] 我的信息（只是为了看看什么时候入群）
-- [x] 更新信息（如果继续更新的话）
-- [x] go-cqhttp最新版下载和上传（不需要请删除）
-- [x] 撤回
-- [x] 滴滴滴-（用户对超级用户发送消息）
-- [x] 金币红包/金币排行
-- [x] 俄罗斯轮盘/胜场排行/败场排行/欧洲人排行/慈善家排行
-- [x] 网易云热评
-- [x] 念首古诗
-- [x] 获取b站视频封面
-- [x] 通过PID获取图片
-- [x] 功能统计可视化
-
-- [x] 关于
-
-### 已实现的管理员功能
-- [x] 更新群组成员信息
-- [x] 95%的群功能开关
-- [x] 查看群内被动技能状态
-- [x] 自定义群欢迎消息（是真寻的不是管家的！）
-- [x] .ban/.unban（支持设置ban时长）= 黑白名单
-- [x] 刷屏禁言相关：刷屏检测设置/设置禁言时长/设置检测次数
-- [x] 上传图片/连续上传图片 （上传图片至指定图库）
-- [x] 移动图片  （同上）
-- [x] 删除图片  （同上）
-- [x] 群内B站订阅
-- [x] 群词条
-- [x] 休息吧/醒来
-
-### 已实现的超级用户功能
-- [x] 添加/删除权限（是真寻的管理员权限，不是群管理员）
-- [x] 开启/关闭指定群的广播通知
-- [x] 广播
-- [x] 自检（检查系统状态）
-- [x] 所有群组/所有好友
-- [x] 退出指定群
-- [x] 更新好友信息/更新群信息
-- [x] /t（对用户进行回复或发送消息）
-- [x] 上传/删除/修改商品（需要编写对应的商品功能）
-- [x] 节日红包发送
-- [x] 修改群权限
-- [x] ban
-- [x] 更新色图
-- [x] 更新价格/更加图片（csgo开箱）
-- [x] 重载原神/方舟/赛马娘/坎公骑冠剑卡池
-- [x] 更新原神今日素材/更新原神资源信息
-- [x] PIX相关操作
-- [x] 检查更新真寻
-- [x] 重启
-- [x] 添加/删除/查看群白名单
-- [x] 功能开关(更多设置)
-- [x] 功能状态
-- [x] b了
-- [x] 执行sql
-- [x] 重载配置
-- [x] 清理临时数据
-- [x] 增删群认证
-- [x] 同意/拒绝好友/群聊请求
-- [x] 配置重载
-
-#### 超级用户的被动技能
-- [x] 邀请入群提醒(别人邀请真寻入群)
-- [x] 添加好友提醒(别人添加真寻好友)
-
-### 已实现的被动技能
-- [x] 进群欢迎消息
-- [x] 群早晚安
-- [x] 每日开箱重置提醒
-- [x] b站转发解析（解析b站分享信息，支持bv，bilibili链接，b站手机端转发卡片，cv，b23.tv），且5分钟内不解析相同url
-- [x] 丢人爬（爬表情包）
-- [x] epic通知（每日发送epic免费游戏链接）
-- [x] 原神黄历提醒
-- [x] 复读
-
-### 已实现的看不见的技能！
-- [x] 刷屏禁言检测
-- [x] 功能调用统计
-- [x] 检测恶意触发命令（将被最高权限ban掉30分钟，只有最高权限(9级)可以进行unban）
-- [x] 自动同意好友请求，加群请求将会提醒管理员，退群提示，加群欢迎等等
-- [x] 群聊时间检测（当群聊最后一人发言时间大于当前36小时后将关闭该群所有通知（即被动技能））
-- [x] 群管理员监控，自动为新晋管理员增加权限，为失去群管理员的用户删除权限
-- [x] 群权限系统
-- [x] 定时更新权限
-- [x] 自动配置重载
+<summary>点击展开查看图片</summary>
+  <img width="300" height="auto" src="./docs_image/zhenxun_help.png" alt="zhenxun_help"/>
+  <img width="300" height="auto" src="./docs_image/html_help.png" alt="html_help"/>
+  <img width="300" height="auto" src="./docs_image/help.png" alt="help"/>
 </details>
 
-## 详细配置请前往文档，以下为最简部署和配置，如果你有基础并学习过nonebot2的话
+## 📦 这是一份扩展
 
+### 1. 体验一下？
 
-## 简单部署
+这是一个免费的，版本为 dev 的 zhenxun，你可以通过 [napcat](https://github.com/NapNeko/NapCatQQ) 或 [拉格朗日](https://github.com/LagrangeDev/Lagrange.Core) 以及 [matcha](https://github.com/A-kirami/matcha) 等直接连接用于体验与测试  
+（球球了测试君！）
 
+```text
+Url: ws://test.zhenxun.org:8080/onebot/v11/ws
+AccessToken: PUBLIC_ZHENXUN_TEST
+
+注：你无法获得超级用户权限
 ```
 
-# 配置gocq
+### 2. 额外扩展
 
-在 https://github.com/Mrs4s/go-cqhttp 下载Releases最新版本，运行后选择反向代理，
-  后将gocq的配置文件config.yml中的universal改为universal: ws://127.0.0.1:8080/onebot/v11/ws
+<div align=center>
+  
+“不要害怕，你的背后还有千千万万的 <strong>伙伴</strong> 啊！”
 
+|                                项目名称                                | 主要用途 |                      仓库作者                       |                         备注                          |
+| :--------------------------------------------------------------------: | :------: | :-------------------------------------------------: | :---------------------------------------------------: |
+|      [插件库](https://github.com/zhenxun-org/zhenxun_bot_plugins)      |   插件   |    [zhenxun-org](https://github.com/zhenxun-org)    |                 原 plugins 文件夹插件                 |
+| [插件索引库](https://github.com/zhenxun-org/zhenxun_bot_plugins_index) |   插件   |    [zhenxun-org](https://github.com/zhenxun-org)    |                    扩展插件索引库                     |
+|    [一键安装](https://github.com/soloxiaoye2022/zhenxun_bot-deploy)    |   安装   | [soloxiaoye2022](https://github.com/soloxiaoye2022) |                        第三方                         |
+|          [WebUi](https://github.com/zhenxun-org/zhenxun_bot)           |   管理   |       [hibikier](https://github.com/HibiKier)       | 基于真寻 WebApi 的 webui 实现 [预览](#-webui界面展示) |
+|  [安卓 app(WebUi)](https://github.com/YuS1aN/zhenxun_bot_android_ui)   |   安装   |         [YuS1aN](https://github.com/YuS1aN)         |                        第三方                         |
+
+</div>
+
+## 🥰 ~~来点优点？~~ 可爱难道还不够吗
+
+- 实现了许多功能，且提供了大量功能管理命令，进行了多平台适配，兼容 nb2 商店插件
+- 拥有完善可用的 webui
+- 通过 Config 配置项将所有插件配置统一保存至 config.yaml，利于统一用户修改
+- 方便增删插件，原生 nonebot2 matcher，不需要额外修改，仅仅通过简单的配置属性就可以生成`帮助图片`和`帮助信息`
+- 提供了 cd，阻塞，每日次数等限制，仅仅通过简单的属性就可以生成一个限制，例如：`PluginCdBlock` 等
+- **更多详细请通过 [传送门](https://zhenxun-org.github.io/zhenxun_bot/) 查看文档！**
+
+## 🐣 小白整合
+
+如果你系统是 **Windows** 且不想下载 Python  
+可以使用整合包（Python3.10+zhenxun+webui）
+
+文档地址：[整合包文档](https://zhenxun-org.github.io/zhenxun_bot/beginner)
+
+<details>
+<summary>下载地址</summary>
+
+- **百度云：**  
+  https://pan.baidu.com/s/1MKGOoIgQW1qom_KT3rNhlg?pwd=t7iz
+
+- **夸克网盘：**  
+  https://pan.quark.cn/s/b4dc6cb8fb08  
+  访问码：Yi46
+
+- **Google Drive：**  
+  https://drive.google.com/drive/folders/1dcTWhPZhSt9WqLehyjF6Gj0CXQCS4OWh?usp=drive_link
+
+</details>
+
+## 🛠️ 简单部署
+
+```bash
 # 获取代码
 git clone https://github.com/HibiKier/zhenxun_bot.git
 
@@ -209,283 +161,269 @@ cd zhenxun_bot
 pip install poetry      # 安装 poetry
 poetry install          # 安装依赖
 
-# 进行基础配置
-####请查看 配置 部分####
-
 # 开始运行
-poetry shell            # 进入虚拟环境
-python bot.py
+poetry run python bot.py
 ```
 
-## 简单配置
+## 📝 简单配置
+
+> [!TIP]
+> config.yaml 需要启动一次 Bot 后生成
+
+1.在 .env.dev 文件中填写你的机器人配置项
 
-```
-1.在.env.dev文件中
+2.在 data/config.yaml 文件中修改你需要修改的插件配置项
 
-  SUPERUSERS = [""]   # 填写你的QQ
+<details>
+<summary>数据库地址（DB_URL）配置说明</summary>
+
+DB_URL 是基于 Tortoise ORM 的数据库连接字符串，用于指定项目所使用的数据库。以下是 DB_URL 的组成部分以及示例：
+
+格式为： `<数据库类型>://<用户名>:<密码>@<主机>:<端口>/<数据库名>?<参数>`
+
+- 数据库类型：表示数据库类型，例如 postgres、mysql、sqlite 等。
+- 用户名：数据库的用户名，例如 root。
+- 密码：数据库的密码，例如 123456。
+- 主机：数据库的主机地址，例如 127.0.0.1（本地）或远程服务器 IP。
+- 端口：数据库的端口号，例如：PostgreSQL：5432, MySQL：3306
+- 数据库名：指定要使用的数据库名称，例如 zhenxun。
+- 参数（可选）：用于传递额外的配置，例如字符集设置。
 
-2.在configs/config.py文件中
-  * 数据库配置
+</details>
 
-3.在configs/config.yaml文件中 # 该文件需要启动一次后生成
-  * 修改插件配置项
+## 📋 功能列表
 
-```
+> [!NOTE]
+> 真寻原 `plugins` 插件文件夹已迁移至 [插件仓库](https://github.com/zhenxun-org/zhenxun_bot_plugins) ，现在本体仅保留核心功能
 
+<details>
+<summary>内置功能</summary>
 
-## 使用Docker
-__Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
-#### GitHub：[Sakuracio/zxenv](https://github.com/Sakuracio/zxenv)
-#### DockerHub：[hibikier/zhenxun_bot](https://hub.docker.com/r/hibikier/zhenxun_bot)
+### 🔧 基础功能
 
+- 昵称系统（群与群与私聊分开）
+- 签到/我的签到/好感度排行/好感度总排行（影响色图概率和开箱次数，支持配置）
+- 商店/我的金币/购买道具/使用道具/金币排行（完整的商店添加/购买/使用流程）
+- 查看当前群欢迎消息
+- 个人信息查看（群组内权限，聊天频率等）
+- 消息撤回
+- 功能统计可视化
+- 关于
+- 三种样式的帮助菜单
 
+### 🛠️ 管理员功能
 
-## 更新
+- 管理员帮助
+- 更新群组成员信息
+- 95%的群功能开关
+- 查看群内被动技能状态
+- 自定义群欢迎消息（是真寻的不是管家的！）
+- ban/unban（支持设置 ban 时长）= 群组及用户的黑名单
+- 休息吧/醒来（群组内真寻状态）
 
-### 2022/5/3 \[v0.1.5.2]
+### 🧑‍💼 超级用户功能
 
-* 商品使用函数可以添加特定参数，例如：user_id, group_id, ShopParam等以及自己提供的参数
-* 添加商品注册装饰器shop_register
-* 修复商品函数kwargs无法获取参数值
+- 超级用户帮助
+- 添加/删除权限（是真寻的管理员权限，不是群管理员）
+- 群组管理，退群指令等
+- 广播
+- 自检（检查系统状态）
+- 所有群组/所有好友
+- 退出指定群
+- 更新好友信息/更新群信息
+- 修改群权限
+- 检查更新
+- 重启
+- 添加/删除/查看群白名单
+- 功能开关(更多设置)
+- 功能状态
+- 执行 SQL
+- 重载配置
+- 清理临时数据
+- 增删群认证
+- 同意/拒绝好友/群聊请求
+- 添加/移除/更新插件/插件商店（plugins 库以及扩展库）
+- WebUI API（对真寻前端的支持）
 
-### 2022/5/1
+#### 🛡️ 超级用户的被动技能
 
-* 删除了`group_last_chat`插件（该功能可由`chat_history`替代
-* 新增敏感词检测（全新反击系统，是时候重拳出击了
+- 邀请入群提醒(别人邀请真寻入群，可配置自动同意)
 
-### 2022/4/26 \[v0.5.1.0]
+- 添加好友提醒(别人添加真寻好友，可配置自动同意)
 
-* 修复了群白名单无法正确添加
-* 优化了管理员帮助图片，背景图层将位于最下层
-* 修复了树脂140时不断提醒（未测试
-* 新增了消息记录的消息排行
-* WebUI新增CPU，内存，磁盘监控
-* WebUI新增资源文件夹统计可视化
+### 🤖 被动技能
 
-### 2022/4/12
+- 群早晚安
 
-* 修复b了命令私聊出错
+### 👻 看不见的技能
 
-### 2022/4/10 \[v0.1.4.7]
+- 功能调用统计
+- 聊天记录统计
+- 检测恶意触发命令（将被最高权限 ban 掉 30 分钟，只有最高权限(9 级)可以进行 unban）
+- 自动同意好友/群组请求，加群请求将会提醒管理员，退群提示，加群欢迎等等
+- 群聊时间检测（当群聊最后一人发言时间大于当前 48 小时后将关闭该群所有通知（即被动技能））
+- 群管理员监控，自动为新晋管理员增加权限，为失去群管理员的用户删除权限
+- 群权限系统
+- 定时更新权限
+- 自动配置重载
+- 强制入群保护
+- 自定备份（可配置）
+- 笨蛋检测（当使用功能名称当指令时真寻会跳出来狠狠嘲笑并帮助）
 
-* 新增消息记录模块
-* 丰富处理请求操作提示
-* web ui新增配置项修改
+</details>
 
-### 2022/4/9
+## 💖 赞助
 
-* fix: 更新问题，戳一戳图片路径问题 [@pull/144](https://github.com/HibiKier/zhenxun_bot/pull/144)
+<details>
+<summary>爱发电</summary>
+<a href="https://afdian.com/a/HibiKier">
+<img width="365px" height="450px" src=./docs_image/afd.jpg>
+</a>
+</details>
 
-### 2022/4/8
+### 赞助名单
 
-* 修复原神玩家查询
+(可以告诉我你的 **github** 地址，我偷偷换掉 0v|)
 
-### 2022/4/6
+[Zer](https://afdian.com/u/6bccdb2a60b411ec9ad452540025c377) [爱发电用户\_HTjk](https://afdian.com/u/6c7d0208064511ec8d7b52540025c377) [shenghuo2](https://afdian.com/u/bca13286102111eda2a052540025c377) [术樱](https://afdian.com/u/414da63a09a311ec8eb752540025c377) [飞火](https://afdian.com/u/404135f48ed711ec962152540025c377) [shenqi](https://afdian.net/u/fa923a8cfe3d11eba61752540025c377) [A_Kyuu](https://afdian.net/u/b83954fc2c1211eba9eb52540025c377) [疯狂混沌](https://afdian.net/u/789a2f9200cd11edb38352540025c377) [投冥](https://afdian.net/a/144514mm) [茶喵](https://afdian.net/u/fd22382eac4d11ecbfc652540025c377) [AemokpaTNR](https://afdian.net/u/1169bb8c8a9611edb0c152540025c377) [爱发电用户\_wrxn](https://afdian.net/u/4aa03d20db4311ecb1e752540025c377) [qqw](https://afdian.net/u/b71db4e2cc3e11ebb76652540025c377) [溫一壺月光下酒](https://afdian.net/u/ad667a5c650c11ed89bf52540025c377) [伝木](https://afdian.net/u/246b80683f9511edba7552540025c377) [阿奎](https://afdian.net/u/da41f72845d511ed930d52540025c377) [醉梦尘逸](https://afdian.net/u/bc11d2683cd011ed99b552540025c377) [Abc](https://afdian.net/u/870dc10a3cd311ed828852540025c377) [本喵无敌哒](https://afdian.net/u/dffaa9005bc911ebb69b52540025c377) [椎名冬羽](https://afdian.net/u/ca1ebd64395e11ed81b452540025c377) [kaito](https://afdian.net/u/a055e20a498811eab1f052540025c377) [笑柒 XIAO_Q7](https://afdian.net/u/4696db5c529111ec84ea52540025c377) [请问一份爱多少钱](https://afdian.net/u/f57ef6602dbd11ed977f52540025c377) [咸鱼鱼鱼鱼](https://afdian.net/u/8e39b9a400e011ed9f4a52540025c377) [Kafka](https://afdian.net/u/41d66798ef6911ecbc5952540025c377) [墨然](https://afdian.net/u/8aa5874a644d11eb8a6752540025c377) [爱发电用户\_T9e4](https://afdian.net/u/2ad1bb82f3a711eca22852540025c377) [笑柒 XIAO_Q7](https://afdian.net/u/4696db5c529111ec84ea52540025c377) [noahzark](https://afdian.net/a/noahzark) [腊条](https://afdian.net/u/f739c4d69eca11eba94b52540025c377) [ze roller](https://afdian.net/u/0e599e96257211ed805152540025c377) [爱发电用户\_4jrf](https://afdian.net/u/6b2cdcc817c611ed949152540025c377) [爱发电用户\_TBsd](https://afdian.net/u/db638b60217911ed9efd52540025c377) [烟寒若雨](https://afdian.net/u/067bd2161eec11eda62b52540025c377) [ln](https://afdian.net/u/b51914ba1c6611ed8a4e52540025c377) [爱发电用户\_b9S4](https://afdian.net/u/3d8f30581a2911edba6d52540025c377) [爱发电用户\_c58s](https://afdian.net/u/a6ad8dda195e11ed9a4152540025c377) [爱发电用户\_eNr9](https://afdian.net/u/05fdb41c0c9a11ed814952540025c377) [MangataAkihi](https://github.com/Sakuracio) [炀](https://afdian.net/u/69b76e9ec77b11ec874f52540025c377) [爱发电用户\_Bc6j](https://afdian.net/u/8546be24f44111eca64052540025c377) [大魔王](https://github.com/xipesoy) [CopilotLaLaLa](https://github.com/CopilotLaLaLa) [嘿小欧](https://afdian.net/u/daa4bec4f24911ec82e552540025c377) [回忆的秋千](https://afdian.net/u/e315d9c6f14f11ecbeef52540025c377) [十年くん](https://github.com/shinianj) [哇](https://afdian.net/u/9b266244f23911eca19052540025c377) [yajiwa](https://github.com/yajiwa) [爆金币](https://afdian.net/u/0d78879ef23711ecb22452540025c377)...
 
-* update search_type [@pull/143](https://github.com/HibiKier/zhenxun_bot/pull/143)
+### 特别赞助
 
-### 2022/4/5 \[v0.1.4.6]
+<div align=center>
+    
+<img width="60%" src="https://edgeone.ai/media/34fe3a45-492d-4ea4-ae5d-ea1087ca7b4b.png" />
 
-* 修复web修改插件后帮助图片生成错误
+[亚洲最佳CDN、边缘和安全解决方案 - Tencent EdgeOne](https://edgeone.ai/zh?from=github)
 
-### 2022/4/4 \[v0.1.4.5]
+**本项目 CDN 加速及安全防护由 Tencent EdgeOne 赞助**
 
-* 替换了bt搜索URL
-* 优化使用playwright的相关代码
-* 原神玩家查询新增层岩巨渊探索
-* 修复原神便笺角色头像黑框
-* 修复同意群聊请求错误
-* 提供webui方面的api
-* 新增web-ui（前端简易管理页面插件）插件
+</div>
 
-### 2022/3/21
+## 📜 贡献指南
 
-* 修复statistics_handle.py乱码
+欢迎查看我们的 [贡献指南](CONTRIBUTING.md) 和 [行为守则](CODE_OF_CONDUCT.md) 以了解如何参与贡献。
 
-### 2022/3/18 \[v0.1.4.4]
+## ❔ 需要帮助？
 
-* 修复戳一戳无法功能关闭与ban禁用
-* 新增图片搜索 search_image
+> [!TIP]
+> 发起 [issue](https://github.com/zhenxun-org/zhenxun_bot/issues/new/choose) 前，我们希望你能够阅读过或者了解 [提问的智慧](https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way/blob/main/README-zh_CN.md)
+>
+> - 善用[搜索引擎](https://www.google.com/)
+> - 查阅 issue 中是否有类似问题，如果没有请按照模板发起 issue
 
-### 2022/3/7
+欢迎前往 [issue](https://github.com/zhenxun-org/zhenxun_bot/issues/new/choose) 中提出你遇到的问题，或者加入我们的 [用户群](https://qm.qq.com/q/mRNtLSl6uc) 或 [技术群](https://qm.qq.com/q/YYYt5rkMYc)与我们联系
 
-* 优化增删权限插件
+## 🛠️ 进度追踪
 
-### 2022/3/6
+Project [zhenxun_bot](https://github.com/users/HibiKier/projects/2)
 
-* 修复树脂提醒无法开启
-* 修复p搜图片路径错误
+## 🌟 特别感谢
 
-### 2022/3/3 \[v0.1.4.3]
+首席设计师：[酥酥/coldly-ss](https://github.com/coldly-ss)
 
-* 修复手动同意群聊请求依旧退出
+LOGO 设计：[FrostN0v0](https://github.com/FrostN0v0)
 
-### 2022/3/1 \[v0.1.4.2]
+## 🙏 感谢
 
-* 0.1.4内容
-
-### 2022/2/27 \[v0.1.4.1]
-
-* 优化抽卡
-
-### 2022/2/25 \[v0.1.4]
-
-* PIX提供配置MAX_ONCE_NUM2FORWARD：当单次发送图片超过指定张数且在群聊时，将转为合并消息
-* 修复点歌无法正确发送
-* 修复我有一个朋友有时文本会包含CQ码
-* 修复群欢消息被动控制文本未删除 [@pull/124](https://github.com/HibiKier/zhenxun_bot/pull/124)
-* message_builder.image不再提供参数：abspath
-
-### 2022/2/23
-
-* 插件状态将从已加载插件模块中读取
-* 修复b站订阅插件订阅失败问题
-* 修复重启命令无法使用
-
-### 2022/2/21 \[v0.1.3.2]
-
-* 群权限为-1时，超级用户发送的命令依旧生效
-* 当群权限为-1时，被动技能也将不会发送
-* 修复功能开关，b站转发解析，复读 ignore无法使用
-* 修复色图下载文件名与路径错误
-* 修复被动技能提醒有时无法删除控制文本
-
-
-### 2022/2/20 \[v0.1.3.1]
-
-* 修复pix下载临时文件目录错误
-* 修复AI，天气，发送图片ignore导致无法使用
-* 修复纯文本被动技能提醒有时无法删除控制文本
-
-### 2022/2/19 \[v0.1.3] (nonebot beta2！)
-
-* 由于nonebot升级版本，提供更新建议（__该次升级将会导致nonebot.beta1以下的插件无法使用__
-  * 保证services，utils，configs，plugins，basic_plugins，文件夹均为最新
-  * 根目录有pyproject.toml与poetry.lock
-  * 执行命令：
-    * pip3 install poetry
-    * poetry install
-    * poetry shell
-    * playwright install chromium
-    * python3 bot.py
-
-
-* 适配nonebot.beta2
-* 删除图片搜索 nonebot_plugin_picsearcher
-* 替换cos api
-* 原神签到树脂提醒新增绑定群里，在某群绑定uid就会在某群发送提醒信息（有好友则私聊，需要重新绑定uid
-* 修改update_info.json
-* 修复原神资源查询下载数据失败时导致报错
-* 优化BuildImage.circle()锯齿问题 [@pull/109](https://github.com/HibiKier/zhenxun_bot/pull/109)
-* epic restful 替换 [@pull/119](https://github.com/HibiKier/zhenxun_bot/pull/119)
-* fix: 修复远古时期残留的epic推送问题 [@pull/122](https://github.com/HibiKier/zhenxun_bot/pull/122)
-
-### 2022/2/11
-
-* 修复pix不使用反代无法下载图片
-
-### 2022/2/10 \[v0.1.1]
-
-* 修复购买道具出错
-
-### 2022/2/9 \[v0.1]
-
-* 新增原神自动签到和手动签到
-* 新增原神树脂提醒
-* 新增手动重载Config.yaml命令以及重载配置定时任务（极少部分帮助或配置可能需要重启
-* 修改了发送本地图库的matcher，改为on_message
-* register_use可以通过返回值发送消息
-* 修复修改商品时限制时间出错
-* 修复超时商品依旧可以被购买
-
-### 2022/1/16 \[v0.0.9.0]
-
-* Ai提供文本敏感词过滤器
-* 疫情插件适配新版腾讯API
-* 修复/t回复带空格切分
-* 修复原神玩家查询缺少渊下宫和稻妻家园以及角色不完全
-* 修复方法 text2image 中 padding 和 font 无法对纯文本生效
-* 修复签到图片中信息并未使用配置文件中的色图概率
-* 修改原神大地图合成方式，改为先压缩再合成
-* bag_user弃用字段props（该字段会在下次更新删除），使用新字段property
-* 数据库中所有belonging_group统一修改为group_id
-* 商店将registered_use和register_goods更名为register_use何register_goods
-* 商品注册提供了kwargs参数提供：
-    * bot 
-    * event
-    * 特殊字段
-      * “send_success_msg”(发送成功的交互信息->即：使用道具 {name} {num} 次成功)
-      * “_max_num_limit”(该道具单次使用的最多个数，默认1)
-
-### 2022/1/5 \[v0.0.8.2]
-
-* 提供金币消费hook，可在plugins2settings.yaml中配置该功能需要消费的金币
-* 商店插件将作为内置插件移动至basic_plugins
-* 商店插件通过export提供了方法，不需要修改商店插件代码添加商品数据和生效方法
-* 修改了hook插件顺序，主要以auth_hook为主
-* 修改商店图片样式
-* 取消每次启动更新城市列表（首次除外），采用定时更新，加快bot启动速度
-* 取消每次启动时截取今日素材，采用调用时截取保存，加快bot启动速度
-* 更新色图时当图片404时会删除并替换
-* 疫情消息回复改为图片
-* 修复商店折扣和限时时间无法生效
-* 修复原神玩家查询尘歌壶缺少图片
-
-### 2021/12/26
-
-* 修复群词条问题 空格 会被录入导致不断回复
-* 修复米游社app替换api导致无法正常查询
-
-### 2021/12/24
-
-* 支持国际疫情数据查询 [@pull/99](https://github.com/HibiKier/zhenxun_bot/pull/99)
-
-### 2021/12/20
-
-* 只有发布小于存储时间的新动态/视频的时候才获取并推送 [@pull/96](https://github.com/HibiKier/zhenxun_bot/pull/96)
-
-### 2021/12/16 \[v0.0.7.0]
-
-* 提供了真寻群聊功能总开关和对应默认配置项，命令：休息吧 醒来
-* 新增原神玩家查询，原神便笺查询
-* 群功能管理提供全部开启/关闭命令：开启/关闭全部功能
-* 提供主要数据自动备份，且提供自定义配置项
-* 提供命令：关于，用于介绍Bot之类的
-* 新增命令exec，用于执行sql语句
-* 签到提供参数 "all"，用于签到所有群聊
-* Ban提醒提供cd
-* 本地图库提供配置项SHOW_ID，用于设置发送图片时是否显示id
-* 色图和PIX提供配置项SHOW_INFO，用于设置发送图片时是否显示图片信息
-* 所有被动技能提供了进群默认状态配置项
-* 修复添加权限第二种添加形式无法正确添加正确的权限
-* 修复签到获取好感度卡时金币不会增加
-* 修复当红包数量不合法时依旧扣除金币
-* 修复金币红包再次使用塞红包时无法正确退回上次未开完的金币
-* 修复 滴滴滴- 只包含图片时不会发送至管理员
-* 修复添加权限等级错误
-* 修复群词条以bot名称为开头时无法正确触发
-* 修改了权限插件加载顺序防止小概率优先加载权限插件引起报错
-* 本地图库新图库会统一建立在resource/img/image_management文件夹下，如果该文件夹内未找到图库，会从上级目录查找（即：resource/img/）
-
-<br>
-
-__..... 更多更新信息请查看文档__
-
-
-## Todo
-- [ ] web管理
-
-## 感谢
 [botuniverse / onebot](https://github.com/botuniverse/onebot) ：超棒的机器人协议  
-[Mrs4s / go-cqhttp](https://github.com/Mrs4s/go-cqhttp) ：cqhttp的golang实现，轻量、原生跨平台.  
-[nonebot / nonebot2](https://github.com/nonebot/nonebot2) ：跨平台Python异步机器人框架  
-[Angel-Hair / XUN_Bot](https://github.com/Angel-Hair/XUN_Bot) ：一个基于NoneBot和酷Q的功能性QQ机器人  
-[pcrbot / cappuccilo_plugins](https://github.com/pcrbot/cappuccilo_plugins) ：hoshino插件合集  
+[Mrs4s / go-cqhttp](https://github.com/Mrs4s/go-cqhttp) ：cqhttp 的 golang 实现，轻量、原生跨平台.  
+[nonebot / nonebot2](https://github.com/nonebot/nonebot2) ：跨平台 Python 异步机器人框架  
+[Angel-Hair / XUN_Bot](https://github.com/Angel-Hair/XUN_Bot) ：一个基于 NoneBot 和酷 Q 的功能性 QQ 机器人  
+[pcrbot / cappuccilo_plugins](https://github.com/pcrbot/cappuccilo_plugins) ：hoshino 插件合集  
 [MeetWq /nonebot-plugin-withdraw](https://github.com/MeetWq/nonebot-plugin-withdraw) ：A simple withdraw plugin for Nonebot2  
-[maxesisn / nonebot_plugin_songpicker2](https://github.com/maxesisn/nonebot_plugin_songpicker2) ：适用于nonebot2的点歌插件  
+[maxesisn / nonebot_plugin_songpicker2](https://github.com/maxesisn/nonebot_plugin_songpicker2) ：适用于 nonebot2 的点歌插件  
 [nonepkg / nonebot-plugin-manager](https://github.com/nonepkg/nonebot-plugin-manager) ：Nonebot Plugin Manager base on import hook  
-[H-K-Y / Genshin_Impact_bot](https://github.com/H-K-Y/Genshin_Impact_bot) ：原神bot，这是一个基于nonebot和HoshinoBot的原神娱乐及信息查询插件  
-[NothAmor / nonebot2_luxun_says](https://github.com/NothAmor/nonebot2_luxun_says) ：基于nonebot2机器人框架的鲁迅说插件  
-[Kyomotoi / AnimeThesaurus](https://github.com/Kyomotoi/AnimeThesaurus) ：一个~~特二刺螈~~（文爱）的适用于任何bot的词库  
-[Ailitonia / omega-miya](https://github.com/Ailitonia/omega-miya) ：基于nonebot2的qq机器人  
-[KimigaiiWuyi / GenshinUID]("https://github.com/KimigaiiWuyi/GenshinUID") ：一个基于HoshinoBot/NoneBot2的原神UID查询插件
+[H-K-Y / Genshin_Impact_bot](https://github.com/H-K-Y/Genshin_Impact_bot) ：原神 bot，这是一个基于 nonebot 和 HoshinoBot 的原神娱乐及信息查询插件  
+[NothAmor / nonebot2_luxun_says](https://github.com/NothAmor/nonebot2_luxun_says) ：基于 nonebot2 机器人框架的鲁迅说插件  
+[Kyomotoi / AnimeThesaurus](https://github.com/Kyomotoi/AnimeThesaurus) ：一个~~特二刺螈~~（文爱）的适用于任何 bot 的词库  
+[Ailitonia / omega-miya](https://github.com/Ailitonia/omega-miya) ：基于 nonebot2 的 qq 机器人  
+[KimigaiiWuyi / GenshinUID](https://github.com/KimigaiiWuyi/GenshinUID) ：一个基于 HoshinoBot/NoneBot2 的原神 UID 查询插件
+
+## 📊 统计与活跃贡献者
+
+<a href="https://next.ossinsight.io/widgets/official/compose-last-28-days-stats?repo_id=368008334" target="_blank" style="display: block" align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://next.ossinsight.io/widgets/official/compose-last-28-days-stats/thumbnail.png?repo_id=368008334&image_size=auto&color_scheme=dark" width="800" height="auto">
+    <img alt="Performance Stats of HibiKier/zhenxun_bot - Last 28 days" src="https://next.ossinsight.io/widgets/official/compose-last-28-days-stats/thumbnail.png?repo_id=368008334&image_size=auto&color_scheme=light" width="800" height="auto">
+  </picture>
+</a>
+<a href="https://next.ossinsight.io/widgets/official/compose-recent-active-contributors?repo_id=368008334&limit=30" target="_blank" style="display: block" align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://next.ossinsight.io/widgets/official/compose-recent-active-contributors/thumbnail.png?repo_id=368008334&limit=30&image_size=auto&color_scheme=dark" width="800" height="auto">
+    <img alt="Active Contributors of HibiKier/zhenxun_bot - Last 28 days" src="https://next.ossinsight.io/widgets/official/compose-recent-active-contributors/thumbnail.png?repo_id=368008334&limit=30&image_size=auto&color_scheme=light" width="800" height="auto">
+  </picture>
+</a>
+
+## 👨‍💻 开发者
+
+感谢以下开发者对 绪山真寻 Bot 作出的贡献：
+
+<a href="https://github.com/HibiKier/zhenxun_bot/graphs/contributors" style="display: block" align="center">
+  <img src="https://contrib.rocks/image?repo=HibiKier/zhenxun_bot&max=1000" alt="contributors"/>
+</a>
+
+## 📸 WebUI 界面展示（仅展示默认主题下的 pc 端）
+
+<div style="display: flex; flex-wrap: wrap; justify-content: space-between;">
+
+#### 登录界面
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-login.jpg)
+
+#### API 设置
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-api.jpg)
+
+#### 仪表盘
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-dashboard.jpg)
+
+#### 仪表盘（展开）
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-dashboard1.jpg)
+
+#### 控制台
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-command.jpg)
+
+#### 插件列表
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-plugin.jpg)
+
+#### 插件列表（配置项）
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-plugin1.jpg)
+
+#### 插件商店
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-store.jpg)
+
+#### 好友/群组管理
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-manage.jpg)
+
+#### 请求管理
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-manage1.jpg)
+
+#### 数据库管理
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-database.jpg)
+
+### 文件管理
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-system.jpg)
+
+### 文件管理（文本查看）
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-system1.jpg)
+
+### 文件管理（图片查看）
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-system2.jpg)
+
+### 关于
+
+![x](https://github.com/zhenxun-org/zhenxun_bot/blob/main/docs_image/pc-about.jpg)
+
+</div>

__version__

@@ -1 +1 @@
-__version__: v0.1.5.1
+__version__: v0.2.4-da6d5b4

basic_plugins/admin_bot_manage/__init__.py

@@ -1,30 +0,0 @@
-from configs.config import Config
-import nonebot
-
-
-Config.add_plugin_config(
-    "admin_bot_manage:custom_welcome_message",
-    "SET_GROUP_WELCOME_MESSAGE_LEVEL [LEVEL]",
-    2,
-    name="群管理员操作",
-    help_="设置群欢迎消息权限",
-    default_value=2,
-)
-
-Config.add_plugin_config(
-    "admin_bot_manage:switch_rule",
-    "CHANGE_GROUP_SWITCH_LEVEL [LEVEL]",
-    2,
-    help_="开关群功能权限",
-    default_value=2,
-)
-
-Config.add_plugin_config(
-    "admin_bot_manage",
-    "ADMIN_DEFAULT_AUTH",
-    5,
-    help_="默认群管理员权限",
-    default_value=5
-)
-
-nonebot.load_plugins("basic_plugins/admin_bot_manage")

basic_plugins/admin_bot_manage/_data_source.py

@@ -1,323 +0,0 @@
-from typing import List
-from nonebot.adapters.onebot.v11.message import MessageSegment
-from services.log import logger
-from configs.path_config import DATA_PATH
-from utils.message_builder import image
-from utils.utils import get_bot, get_matchers
-from pathlib import Path
-from models.group_member_info import GroupInfoUser
-from datetime import datetime
-from services.db_context import db
-from models.level_user import LevelUser
-from configs.config import Config
-from utils.manager import group_manager, plugins2settings_manager, plugins_manager
-from utils.image_utils import BuildImage
-from utils.http_utils import AsyncHttpx
-import asyncio
-import time
-import os
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-async def group_current_status(group_id: int) -> str:
-    """
-    获取当前所有通知的开关
-    :param group_id: 群号
-    """
-    rst = "[被动技能 状态]\n"
-    _data = group_manager.get_task_data()
-    for task in _data.keys():
-        rst += f'{_data[task]}: {"√" if await group_manager.check_group_task_status(group_id, task) else "×"}\n'
-    return rst.strip()
-
-
-custom_welcome_msg_json = (
-    Path() / "data" / "custom_welcome_msg" / "custom_welcome_msg.json"
-)
-
-
-async def custom_group_welcome(
-    msg: str, imgs: List[str], user_id: int, group_id: int
-) -> str:
-    """
-    替换群欢迎消息
-    :param msg: 欢迎消息文本
-    :param imgs: 欢迎消息图片，只取第一张
-    :param user_id: 用户id，用于log记录
-    :param group_id: 群号
-    """
-    img_result = ""
-    img = imgs[0] if imgs else ""
-    result = ""
-    if (DATA_PATH / f"custom_welcome_msg/{group_id}.jpg").exists():
-        (DATA_PATH / f"custom_welcome_msg/{group_id}.jpg").unlink()
-    if not custom_welcome_msg_json.exists():
-        custom_welcome_msg_json.parent.mkdir(parents=True, exist_ok=True)
-        data = {}
-    else:
-        try:
-            data = json.load(open(custom_welcome_msg_json, "r"))
-        except FileNotFoundError:
-            data = {}
-    try:
-        if msg:
-            data[str(group_id)] = str(msg)
-            json.dump(
-                data, open(custom_welcome_msg_json, "w"), indent=4, ensure_ascii=False
-            )
-            logger.info(f"USER {user_id} GROUP {group_id} 更换群欢迎消息 {msg}")
-            result += msg
-        if img:
-            await AsyncHttpx.download_file(
-                img, DATA_PATH / "custom_welcome_msg" / f"{group_id}.jpg"
-            )
-            img_result = image(DATA_PATH / "custom_welcome_msg" / f"{group_id}.jpg")
-            logger.info(f"USER {user_id} GROUP {group_id} 更换群欢迎消息图片")
-    except Exception as e:
-        logger.error(f"GROUP {group_id} 替换群消息失败 e:{e}")
-        return "替换群消息失败.."
-    return f"替换群欢迎消息成功：\n{result}" + img_result
-
-
-task_data = None
-
-
-async def change_group_switch(cmd: str, group_id: int, is_super: bool = False):
-    global task_data
-    """
-    修改群功能状态
-    :param cmd: 功能名称
-    :param group_id: 群号
-    :param is_super: 是否位超级用户，超级用户用于私聊开关功能状态
-    """
-    if not task_data:
-        task_data = group_manager.get_task_data()
-    group_help_file = DATA_PATH / "group_help" / f"{group_id}.png"
-    status = cmd[:2]
-    cmd = cmd[2:]
-    type_ = "plugin"
-    modules = plugins2settings_manager.get_plugin_module(cmd, True)
-    if cmd == "全部被动":
-        for task in task_data:
-            if status == "开启":
-                if not await group_manager.check_group_task_status(group_id, task):
-                    await group_manager.open_group_task(group_id, task)
-            else:
-                if await group_manager.check_group_task_status(group_id, task):
-                    await group_manager.close_group_task(group_id, task)
-        if group_help_file.exists():
-            group_help_file.unlink()
-        return f"已 {status} 全部被动技能！"
-    if cmd == "全部功能":
-        for f in plugins2settings_manager.get_data():
-            if status == "开启":
-                group_manager.unblock_plugin(f, group_id)
-            else:
-                group_manager.block_plugin(f, group_id)
-        return f"已 {status} 全部功能！"
-    if cmd in [task_data[x] for x in task_data.keys()]:
-        type_ = "task"
-        modules = [x for x in task_data.keys() if task_data[x] == cmd]
-    for module in modules:
-        if is_super:
-            module = f"{module}:super"
-        if status == "开启":
-            if type_ == "task":
-                if await group_manager.check_group_task_status(group_id, module):
-                    return f"被动 {task_data[module]} 正处于开启状态！不要重复开启."
-                await group_manager.open_group_task(group_id, module)
-            else:
-                if group_manager.get_plugin_status(module, group_id):
-                    return f"功能 {cmd} 正处于开启状态！不要重复开启."
-                group_manager.unblock_plugin(module, group_id)
-        else:
-            if type_ == "task":
-                if not await group_manager.check_group_task_status(group_id, module):
-                    return f"被动 {task_data[module]} 正处于关闭状态！不要重复关闭."
-                await group_manager.close_group_task(group_id, module)
-            else:
-                if not group_manager.get_plugin_status(module, group_id):
-                    return f"功能 {cmd} 正处于关闭状态！不要重复关闭."
-                group_manager.block_plugin(module, group_id)
-    if group_help_file.exists():
-        group_help_file.unlink()
-    if is_super:
-        for file in os.listdir(DATA_PATH / "group_help"):
-            file = DATA_PATH / "group_help" / file
-            file.unlink()
-    else:
-        _help_image = DATA_PATH / "group_help" / f"{group_id}.png"
-        if _help_image.exists():
-            _help_image.unlink()
-    return f"{status} {cmd} 功能！"
-
-
-def set_plugin_status(cmd: str, block_type: str = "all"):
-    """
-    设置插件功能状态（超级用户使用）
-    :param cmd: 功能名称
-    :param block_type: 限制类型, 'all': 私聊+群里, 'private': 私聊, 'group': 群聊
-    """
-    status = cmd[:2]
-    cmd = cmd[2:]
-    module = plugins2settings_manager.get_plugin_module(cmd)
-    if status == "开启":
-        plugins_manager.unblock_plugin(module)
-    else:
-        plugins_manager.block_plugin(module, block_type=block_type)
-    for file in os.listdir(DATA_PATH / "group_help"):
-        file = DATA_PATH / "group_help" / file
-        file.unlink()
-
-
-async def get_plugin_status():
-    """
-    获取功能状态
-    """
-    return await asyncio.get_event_loop().run_in_executor(None, _get_plugin_status)
-
-
-def _get_plugin_status() -> MessageSegment:
-    """
-    合成功能状态图片
-    """
-    rst = "\t功能\n"
-    flag_str = "状态".rjust(4) + "\n"
-    tmp_name = []
-    for matcher in get_matchers():
-        if matcher.plugin_name not in tmp_name:
-            tmp_name.append(matcher.plugin_name)
-            module = matcher.plugin_name
-            flag = plugins_manager.get_plugin_block_type(module)
-            flag = flag.upper() + " CLOSE" if flag else "OPEN"
-            try:
-                plugin_name = plugins_manager.get(module)["plugin_name"]
-                if (
-                    "[Hidden]" in plugin_name
-                    or "[Admin]" in plugin_name
-                    or "[Superuser]" in plugin_name
-                ):
-                    continue
-                rst += f"{plugin_name}"
-            except KeyError:
-                rst += f"{module}"
-            if plugins_manager.get(module)["error"]:
-                rst += "[ERROR]"
-            rst += "\n"
-            flag_str += f"{flag}\n"
-    height = len(rst.split("\n")) * 24
-    a = BuildImage(250, height, font_size=20)
-    a.text((10, 10), rst)
-    b = BuildImage(200, height, font_size=20)
-    b.text((10, 10), flag_str)
-    A = BuildImage(500, height)
-    A.paste(a)
-    A.paste(b, (270, 0))
-    return image(b64=A.pic2bs4())
-
-
-async def update_member_info(group_id: int, remind_superuser: bool = False) -> bool:
-    """
-    更新群成员信息
-    :param group_id: 群号
-    :param remind_superuser: 失败信息提醒超级用户
-    """
-    bot = get_bot()
-    _group_user_list = await bot.get_group_member_list(group_id=group_id)
-    _error_member_list = []
-    _exist_member_list = []
-    # try:
-    for user_info in _group_user_list:
-        if user_info["card"] == "":
-            nickname = user_info["nickname"]
-        else:
-            nickname = user_info["card"]
-        async with db.transaction():
-            # 更新权限
-            if (
-                user_info["role"]
-                in [
-                    "owner",
-                    "admin",
-                ]
-                and not await LevelUser.is_group_flag(user_info["user_id"], group_id)
-            ):
-                await LevelUser.set_level(
-                    user_info["user_id"],
-                    user_info["group_id"],
-                    Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH"),
-                )
-            if str(user_info["user_id"]) in bot.config.superusers:
-                await LevelUser.set_level(
-                    user_info["user_id"], user_info["group_id"], 9
-                )
-            user = await GroupInfoUser.get_member_info(
-                user_info["user_id"], user_info["group_id"]
-            )
-            if user:
-                if user.user_name != nickname:
-                    await user.update(user_name=nickname).apply()
-                    logger.info(
-                        f"用户{user_info['user_id']} 所属{user_info['group_id']} 更新群昵称成功"
-                    )
-                _exist_member_list.append(int(user_info["user_id"]))
-                continue
-            join_time = datetime.strptime(
-                time.strftime(
-                    "%Y-%m-%d %H:%M:%S", time.localtime(user_info["join_time"])
-                ),
-                "%Y-%m-%d %H:%M:%S",
-            )
-            if await GroupInfoUser.add_member_info(
-                user_info["user_id"],
-                user_info["group_id"],
-                nickname,
-                join_time,
-            ):
-                _exist_member_list.append(int(user_info["user_id"]))
-                logger.info(f"用户{user_info['user_id']} 所属{user_info['group_id']} 更新成功")
-            else:
-                _error_member_list.append(
-                    f"用户{user_info['user_id']} 所属{user_info['group_id']} 更新失败\n"
-                )
-    _del_member_list = list(
-        set(_exist_member_list).difference(
-            set(await GroupInfoUser.get_group_member_id_list(group_id))
-        )
-    )
-    if _del_member_list:
-        for del_user in _del_member_list:
-            if await GroupInfoUser.delete_member_info(del_user, group_id):
-                logger.info(f"退群用户{del_user} 所属{group_id} 已删除")
-            else:
-                logger.info(f"退群用户{del_user} 所属{group_id} 删除失败")
-    if _error_member_list and remind_superuser:
-        result = ""
-        for error_user in _error_member_list:
-            result += error_user
-        await bot.send_private_msg(
-            user_id=int(list(bot.config.superusers)[0]), message=result[:-1]
-        )
-    return True
-
-
-def set_group_bot_status(group_id: int, status: bool) -> str:
-    """
-    设置群聊bot开关状态
-    :param group_id: 群号
-    :param status: 状态
-    """
-    if status:
-        if group_manager.check_group_bot_status(group_id):
-            return "我还醒着呢！"
-        group_manager.turn_on_group_bot_status(group_id)
-        return "呜..醒来了..."
-    else:
-        group_manager.shutdown_group_bot_status(group_id)
-        # for x in group_manager.get_task_data():
-        #     group_manager.close_group_task(group_id, x)
-        return "那我先睡觉了..."

basic_plugins/admin_bot_manage/admin_config.py

@@ -1,37 +0,0 @@
-from nonebot import on_notice
-from services.log import logger
-from nonebot.adapters.onebot.v11 import GroupAdminNoticeEvent
-from models.level_user import LevelUser
-from models.group_member_info import GroupInfoUser
-from configs.config import Config
-
-
-__zx_plugin_name__ = "群管理员变动监测 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-admin_notice = on_notice(priority=5)
-
-
-@admin_notice.handle()
-async def _(event: GroupAdminNoticeEvent):
-    try:
-        nickname = (
-            await GroupInfoUser.get_member_info(event.user_id, event.group_id)
-        ).user_name
-    except AttributeError:
-        nickname = event.user_id
-    if event.sub_type == "set":
-        await LevelUser.set_level(
-            event.user_id,
-            event.group_id,
-            Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH"),
-        )
-        logger.info(
-            f"为新晋管理员 {nickname}({event.user_id}) "
-            f"添加权限等级：{Config.get_config('admin_bot_manage', 'ADMIN_DEFAULT_AUTH')}"
-        )
-    elif event.sub_type == "unset":
-        await LevelUser.delete_level(event.user_id, event.group_id)
-        logger.info(f"将非管理员 {nickname}({event.user_id}) 取消权限等级")

basic_plugins/admin_bot_manage/custom_welcome_message.py

@@ -1,51 +0,0 @@
-from nonebot import on_command
-from utils.utils import get_message_img
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message
-from nonebot.params import CommandArg
-from ._data_source import custom_group_welcome
-from nonebot.adapters.onebot.v11.permission import GROUP
-from configs.config import Config
-from services.log import logger
-
-
-__zx_plugin_name__ = "自定义进群欢迎消息 [Admin]"
-__plugin_usage__ = """
-usage：
-    指令：
-        自定义进群欢迎消息 ?[文本] ?[图片]
-        示例：自定义进群欢迎消息 欢迎新人！[图片]
-        Note：可以通过[at]来确认是否艾特新成员
-        示例：自定义进群欢迎消息 欢迎你[at]
-""".strip()
-__plugin_des__ = '简易的自定义群欢迎消息'
-__plugin_cmd__ = ['自定义群欢迎消息 ?[文本] ?[图片]']
-__plugin_version__ = 0.1
-__plugin_author__ = 'HibiKier'
-__plugin_settings__ = {
-    "admin_level": Config.get_config("admin_bot_manage", "SET_GROUP_WELCOME_MESSAGE_LEVEL"),
-}
-
-custom_welcome = on_command(
-    "自定义进群欢迎消息",
-    aliases={"自定义欢迎消息", "自定义群欢迎消息", "设置群欢迎消息"},
-    permission=GROUP,
-    priority=5,
-    block=True,
-)
-
-
-@custom_welcome.handle()
-async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
-    try:
-        msg = arg.extract_plain_text().strip()
-        img = get_message_img(event.json())
-        if not msg and not img:
-            await custom_welcome.finish(__plugin_usage__)
-        await custom_welcome.send(
-            await custom_group_welcome(msg, img, event.user_id, event.group_id),
-            at_sender=True,
-        )
-        logger.info(f"USER {event.user_id} GROUP {event.group_id} 自定义群欢迎消息：{msg}")
-    except Exception as e:
-        logger.error(f"自定义进群欢迎消息发生错误 {type(e)}：{e}")
-        await custom_welcome.send("发生了一些未知错误...")

basic_plugins/admin_bot_manage/rule.py

@@ -1,45 +0,0 @@
-from nonebot.adapters.onebot.v11 import Event
-from utils.manager import group_manager, plugins2settings_manager
-from utils.utils import get_message_text
-from services.log import logger
-
-cmd = []
-
-
-def switch_rule(event: Event) -> bool:
-    """
-    检测文本是否是关闭功能命令
-    :param event: pass
-    """
-    global cmd
-    try:
-        if not cmd:
-            cmd = ["关闭全部被动", "开启全部被动", "开启全部功能", "关闭全部功能"]
-            _data = group_manager.get_task_data()
-            for key in _data:
-                cmd.append(f"开启{_data[key]}")
-                cmd.append(f"关闭{_data[key]}")
-                cmd.append(f"开启 {_data[key]}")
-                cmd.append(f"关闭 {_data[key]}")
-            _data = plugins2settings_manager.get_data()
-            for key in _data:
-                try:
-                    if isinstance(_data[key]["cmd"], list):
-                        for x in _data[key]["cmd"]:
-                            cmd.append(f"开启{x}")
-                            cmd.append(f"关闭{x}")
-                            cmd.append(f"开启 {x}")
-                            cmd.append(f"关闭 {x}")
-                    else:
-                        cmd.append(f"开启{key}")
-                        cmd.append(f"关闭{key}")
-                        cmd.append(f"开启 {key}")
-                        cmd.append(f"关闭 {key}")
-                except KeyError:
-                    pass
-        msg = get_message_text(event.json()).split()
-        msg = msg[0] if msg else ""
-        return msg in cmd
-    except Exception as e:
-        logger.error(f"检测是否为功能开关命令发生错误 {type(e)}: {e}")
-    return False

basic_plugins/admin_bot_manage/switch_rule.py

@@ -1,124 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent, GROUP
-from nonebot import on_command, on_message, on_regex
-from nonebot.params import RegexGroup
-from ._data_source import (
-    change_group_switch,
-    set_plugin_status,
-    get_plugin_status,
-    group_current_status,
-    set_group_bot_status
-)
-from services.log import logger
-from configs.config import NICKNAME, Config
-from utils.utils import get_message_text, is_number
-from nonebot.permission import SUPERUSER
-from typing import Tuple, Any
-from .rule import switch_rule
-
-
-__zx_plugin_name__ = "群功能开关 [Admin]"
-
-__plugin_usage__ = """
-usage：
-    群内功能与被动技能开关
-    指令：
-        开启/关闭[功能]
-        群被动状态
-        开启全部被动
-        关闭全部被动
-        醒来/休息吧
-        示例：开启/关闭色图
-""".strip()
-__plugin_superuser_usage__ = """
-usage:
-    功能总开关与指定群禁用
-    指令：
-        功能状态
-        开启/关闭[功能] [group]
-        开启/关闭[功能] ['private'/'group']
-""".strip()
-__plugin_des__ = "群内功能开关"
-__plugin_cmd__ = [
-    "开启/关闭[功能]",
-    "群被动状态",
-    "开启全部被动",
-    "关闭全部被动",
-    "醒来/休息吧",
-    "功能状态 [_superuser]",
-    "开启/关闭[功能] [group] [_superuser]",
-    "开启/关闭[功能] ['private'/'group'] [_superuser]",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "admin_level": Config.get_config("admin_bot_manage", "CHANGE_GROUP_SWITCH_LEVEL"),
-    "cmd": ["开启功能", "关闭功能", "开关"]
-}
-
-switch_rule_matcher = on_message(rule=switch_rule, priority=4, block=True)
-
-plugins_status = on_command("功能状态", permission=SUPERUSER, priority=5, block=True)
-
-group_task_status = on_command("群被动状态", permission=GROUP, priority=5, block=True)
-
-group_status = on_regex("^(休息吧|醒来)$", permission=GROUP, priority=5, block=True)
-
-
-@switch_rule_matcher.handle()
-async def _(bot: Bot, event: MessageEvent):
-    _cmd = get_message_text(event.json()).split()[0]
-    if isinstance(event, GroupMessageEvent):
-        await switch_rule_matcher.send(await change_group_switch(_cmd, event.group_id))
-        logger.info(f"USER {event.user_id} GROUP {event.group_id} 使用群功能管理命令 {_cmd}")
-    else:
-        if str(event.user_id) in bot.config.superusers:
-            block_type = " ".join(get_message_text(event.json()).split()[1:])
-            block_type = block_type if block_type else "a"
-            if is_number(block_type):
-                if not int(block_type) in [
-                    g["group_id"]
-                    for g in await bot.get_group_list()
-                ]:
-                    await switch_rule_matcher.finish(f"{NICKNAME}未加入群聊：{block_type}")
-                await change_group_switch(_cmd, int(block_type), True)
-                group_name = (await bot.get_group_info(group_id=int(block_type)))[
-                    "group_name"
-                ]
-                await switch_rule_matcher.send(
-                    f"已禁用群聊 {group_name}({block_type}) 的 {_cmd[2:]} 功能"
-                )
-            elif block_type in ["all", "private", "group", "a", "p", "g"]:
-                block_type = "all" if block_type == "a" else block_type
-                block_type = "private" if block_type == "p" else block_type
-                block_type = "group" if block_type == "g" else block_type
-                set_plugin_status(_cmd, block_type)
-                if block_type == "all":
-                    await switch_rule_matcher.send(f"已{_cmd[:2]}功能：{_cmd[2:]}")
-                elif block_type == "private":
-                    await switch_rule_matcher.send(f"已在私聊中{_cmd[:2]}功能：{_cmd[2:]}")
-                else:
-                    await switch_rule_matcher.send(f"已在群聊中{_cmd[:2]}功能：{_cmd[2:]}")
-            else:
-                await switch_rule_matcher.finish("格式错误：关闭[功能] [group]/[p/g]")
-            logger.info(f"USER {event.user_id} 使用功能管理命令 {_cmd} | {block_type}")
-
-
-@plugins_status.handle()
-async def _():
-    await plugins_status.send(await get_plugin_status())
-
-
-@group_task_status.handle()
-async def _(event: GroupMessageEvent):
-    await group_task_status.send(await group_current_status(event.group_id))
-
-
-@group_status.handle()
-async def _(event: GroupMessageEvent, reg_group: Tuple[Any, ...] = RegexGroup()):
-    cmd = reg_group[0]
-    if cmd == "休息吧":
-        msg = set_group_bot_status(event.group_id, False)
-    else:
-        msg = set_group_bot_status(event.group_id, True)
-    await group_status.send(msg)
-    logger.info(f"USER {event.user_id} GROUP {event.group_id} 使用总开关命令：{cmd}")

basic_plugins/admin_bot_manage/timing_task.py

@@ -1,51 +0,0 @@
-from utils.utils import scheduler, get_bot
-from ._data_source import update_member_info
-from services.log import logger
-from models.group_info import GroupInfo
-from asyncpg.exceptions import ConnectionDoesNotExistError, UndefinedColumnError
-
-
-__zx_plugin_name__ = '管理方面定时任务 [Hidden]'
-__plugin_usage__ = '无'
-__plugin_des__ = '成员信息和管理权限的定时更新'
-__plugin_version__ = 0.1
-__plugin_author__ = 'HibiKier'
-
-
-# 自动更新群员信息
-@scheduler.scheduled_job(
-    "cron",
-    hour=2,
-    minute=1,
-)
-async def _():
-    bot = get_bot()
-    if bot:
-        gl = await bot.get_group_list()
-        gl = [g["group_id"] for g in gl]
-        for g in gl:
-            try:
-                await update_member_info(g)
-                logger.info(f"更新群组 g:{g} 成功")
-            except Exception as e:
-                logger.error(f"更新群组错误 g:{g} e:{e}")
-
-
-# 快速更新群员信息以及管理员权限
-@scheduler.scheduled_job(
-    "interval",
-    minutes=5,
-)
-async def _():
-    try:
-        bot = get_bot()
-        if bot:
-            gl = await bot.get_group_list()
-            gl = [g["group_id"] for g in gl]
-            all_group = [x.group_id for x in await GroupInfo.get_all_group()]
-            for g in gl:
-                if g not in all_group:
-                    await update_member_info(g, False)
-                    logger.info(f"快速更新群信息以及权限：{g}")
-    except (IndexError, ConnectionDoesNotExistError, UndefinedColumnError):
-        pass

basic_plugins/admin_bot_manage/update_group_member_info.py

@@ -1,40 +0,0 @@
-from nonebot import on_command, on_notice
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, GROUP, GroupIncreaseNoticeEvent
-from ._data_source import update_member_info
-
-__zx_plugin_name__ = "更新群组成员列表 [Admin]"
-__plugin_usage__ = """
-usage：
-    更新群组成员的基本信息
-    指令：
-        更新群组成员列表/更新群组成员信息
-""".strip()
-__plugin_des__ = '更新群组成员列表'
-__plugin_cmd__ = ['更新群组成员列表']
-__plugin_version__ = 0.1
-__plugin_author__ = 'HibiKier'
-__plugin_settings__ = {
-    "admin_level": 1,
-}
-
-
-refresh_member_group = on_command(
-    "更新群组成员列表", aliases={"更新群组成员信息"}, permission=GROUP, priority=5, block=True
-)
-
-
-@refresh_member_group.handle()
-async def _(event: GroupMessageEvent):
-    if await update_member_info(event.group_id):
-        await refresh_member_group.finish("更新群员信息成功！", at_sender=True)
-    else:
-        await refresh_member_group.finish("更新群员信息失败！", at_sender=True)
-
-
-group_increase_handle = on_notice(priority=1, block=False)
-
-
-@group_increase_handle.handle()
-async def _(bot: Bot, event: GroupIncreaseNoticeEvent):
-    if event.user_id == int(bot.self_id):
-        await update_member_info(event.group_id)

basic_plugins/admin_help/__init__.py

@@ -1,27 +0,0 @@
-from nonebot import on_command
-from nonebot.typing import T_State
-from nonebot.adapters import Bot
-from nonebot.adapters.onebot.v11 import GroupMessageEvent
-from utils.message_builder import image
-from .data_source import create_help_image, admin_help_image
-
-
-__zx_plugin_name__ = '管理帮助 [Admin]'
-__plugin_usage__ = '管理员帮助，在群内回复“管理员帮助”'
-__plugin_version__ = 0.1
-__plugin_author__ = 'HibiKier'
-__plugin_settings__ = {
-    "admin_level": 1,
-}
-
-admin_help = on_command("管理员帮助", aliases={"管理帮助"}, priority=5, block=True)
-
-if admin_help_image.exists():
-    admin_help_image.unlink()
-
-
-@admin_help.handle()
-async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
-    if not admin_help_image.exists():
-        await create_help_image()
-    await admin_help.send(image('admin_help_img.png'))

basic_plugins/admin_help/data_source.py

@@ -1,90 +0,0 @@
-from utils.image_utils import BuildImage
-from configs.path_config import IMAGE_PATH
-from services.log import logger
-from utils.utils import get_matchers
-from utils.manager import group_manager
-from nonebot.adapters.onebot.v11 import Bot
-from nonebot import Driver
-import nonebot
-
-
-driver: Driver = nonebot.get_driver()
-
-background = IMAGE_PATH / "background" / "0.png"
-
-admin_help_image = IMAGE_PATH / 'admin_help_img.png'
-
-
-@driver.on_bot_connect
-async def init_task(bot: Bot = None):
-    if not group_manager.get_task_data():
-        await group_manager.init_group_task()
-        logger.info(f'已成功加载 {len(group_manager.get_task_data())} 个被动技能.')
-
-
-async def create_help_image():
-    """
-    创建管理员帮助图片
-    """
-    await _create_help_image()
-
-
-async def _create_help_image():
-    """
-    创建管理员帮助图片
-    """
-    _matchers = get_matchers()
-    _plugin_name_list = []
-    width = 0
-    _plugin_level = {}
-    for matcher in _matchers:
-        _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-        _module = _plugin.module
-        try:
-            plugin_name = _module.__getattribute__("__zx_plugin_name__")
-        except AttributeError:
-            continue
-        try:
-            if (
-                "[admin]" in plugin_name.lower()
-                and plugin_name not in _plugin_name_list
-                and plugin_name != "管理帮助 [Admin]"
-            ):
-                _plugin_name_list.append(plugin_name)
-                plugin_settings = _module.__getattribute__("__plugin_settings__")
-                plugin_des = _module.__getattribute__("__plugin_des__")
-                plugin_cmd = _module.__getattribute__("__plugin_cmd__")
-                plugin_cmd = [x for x in plugin_cmd if "[_superuser]" not in x]
-                admin_level = int(plugin_settings["admin_level"])
-                if _plugin_level.get(admin_level):
-                    _plugin_level[admin_level].append(
-                        f"[{admin_level}] {plugin_des} -> " + " / ".join(plugin_cmd)
-                    )
-                else:
-                    _plugin_level[admin_level] = [
-                        f"[{admin_level}] {plugin_des} -> " + " / ".join(plugin_cmd)
-                    ]
-                x = len(f"[{admin_level}] {plugin_des} -> " + " / ".join(plugin_cmd)) * 23
-                width = width if width > x else x
-        except AttributeError:
-            logger.warning(f"获取管理插件 {matcher.plugin_name}: {plugin_name} 设置失败...")
-    help_str = "*  注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数  *\n\n" \
-               "[权限等级] 管理员帮助：\n\n"
-    x = list(_plugin_level.keys())
-    x.sort()
-    for level in x:
-        for help_ in _plugin_level[level]:
-            help_str += f"\t{help_}\n\n"
-    help_str += '-----[被动技能开关]-----\n\n'
-    task_data = group_manager.get_task_data()
-    for i, x in enumerate(task_data.keys()):
-        help_str += f'{i+1}.开启/关闭{task_data[x]}\n\n'
-    height = len(help_str.split("\n")) * 33
-    A = BuildImage(width, height, font_size=24)
-    _background = BuildImage(width, height, background=background)
-    await A.apaste(_background, alpha=True)
-    await A.atext((150, 110), help_str)
-    await A.asave(admin_help_image)
-    logger.info(f'已成功加载 {len(_plugin_name_list)} 条管理员命令')
-
-

basic_plugins/apscheduler/__init__.py

@@ -1,249 +0,0 @@
-from utils.message_builder import image
-from utils.utils import scheduler, get_bot
-from nonebot import on_message
-from services.log import logger
-from models.group_info import GroupInfo
-from models.friend_user import FriendUser
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from configs.config import NICKNAME, Config
-from utils.manager import group_manager
-from pathlib import Path
-import shutil
-
-__zx_plugin_name__ = "定时任务相关 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_task__ = {'zwa': '早晚安'}
-
-
-Config.add_plugin_config(
-    "_task",
-    "DEFAULT_ZWA",
-    True,
-    help_="被动 早晚安 进群默认开关状态",
-    default_value=True,
-)
-
-Config.add_plugin_config(
-    "_backup",
-    "BACKUP_FLAG",
-    True,
-    help_="是否开启文件备份",
-    default_value=True
-)
-
-Config.add_plugin_config(
-    "_backup",
-    "BACKUP_DIR_OR_FILE",
-    ['data/black_word', 'data/configs', 'data/statistics', 'data/word_bank', 'data/manager', 'configs'],
-    name="文件备份",
-    help_="备份的文件夹或文件",
-    default_value=[]
-)
-
-
-cx = on_message(priority=9, block=False)
-
-
-# 早上好
-@scheduler.scheduled_job(
-    "cron",
-    hour=6,
-    minute=1,
-)
-async def _():
-    try:
-        bot = get_bot()
-        gl = await bot.get_group_list()
-        gl = [g["group_id"] for g in gl]
-        for g in gl:
-            result = image("zao.jpg", "zhenxun")
-            try:
-                await bot.send_group_msg(group_id=g, message="[[_task|zwa]]早上好" + result)
-            except ActionFailed:
-                logger.warning(f"{g} 群被禁言中，无法发送早安")
-    except Exception as e:
-        logger.error(f"早晚安错误 e:{e}")
-
-
-# 睡觉了
-@scheduler.scheduled_job(
-    "cron",
-    hour=23,
-    minute=59,
-)
-async def _():
-    try:
-        bot = get_bot()
-        gl = await bot.get_group_list()
-        gl = [g["group_id"] for g in gl]
-        for g in gl:
-            result = image("sleep.jpg", "zhenxun")
-            try:
-                await bot.send_group_msg(
-                    group_id=g, message=f"[[_task|zwa]]{NICKNAME}要睡觉了，你们也要早点睡呀" + result
-                )
-            except ActionFailed:
-                logger.warning(f"{g} 群被禁言中，无法发送晚安")
-    except Exception as e:
-        logger.error(f"早晚安错误 e:{e}")
-
-
-# 自动更新群组信息
-@scheduler.scheduled_job(
-    "cron",
-    hour=3,
-    minute=1,
-)
-async def _():
-    try:
-        bot = get_bot()
-        gl = await bot.get_group_list()
-        gl = [g["group_id"] for g in gl]
-        for g in gl:
-            group_info = await bot.get_group_info(group_id=g)
-            await GroupInfo.add_group_info(
-                group_info["group_id"],
-                group_info["group_name"],
-                group_info["max_member_count"],
-                group_info["member_count"],
-            )
-            logger.info(f"自动更新群组 {g} 信息成功")
-    except Exception as e:
-        logger.error(f"自动更新群组信息错误 e:{e}")
-
-
-# 自动更新好友信息
-@scheduler.scheduled_job(
-    "cron",
-    hour=3,
-    minute=1,
-)
-async def _():
-    try:
-        bot = get_bot()
-        fl = await bot.get_friend_list()
-        for f in fl:
-            if await FriendUser.add_friend_info(f["user_id"], f["nickname"]):
-                logger.info(f'自动更新好友 {f["user_id"]} 信息成功')
-            else:
-                logger.warning(f'自动更新好友 {f["user_id"]} 信息失败')
-    except Exception as e:
-        logger.error(f"自动更新群组信息错误 e:{e}")
-
-
-# 自动备份
-@scheduler.scheduled_job(
-    "cron",
-    hour=3,
-    minute=25,
-)
-async def _():
-    if Config.get_config("_backup", "BACKUP_FLAG"):
-        _backup_path = Path() / 'backup'
-        _backup_path.mkdir(exist_ok=True, parents=True)
-        for x in Config.get_config("_backup", "BACKUP_DIR_OR_FILE"):
-            try:
-                path = Path(x)
-                _p = _backup_path / x
-                if path.exists():
-                    if path.is_dir():
-                        if _p.exists():
-                            shutil.rmtree(_p, ignore_errors=True)
-                        shutil.copytree(x, _p)
-                    else:
-                        if _p.exists():
-                            _p.unlink()
-                        shutil.copy(x, _p)
-                    logger.info(f'已完成自动备份：{x}')
-            except Exception as e:
-                logger.error(f"自动备份文件 {x} 发生错误 {type(e)}:{e}")
-
-
-    #  一次性任务
-# 固定时间触发，仅触发一次：
-#
-# from datetime import datetime
-#
-# @nonebot.scheduler.scheduled_job(
-#     'date',
-#     run_date=datetime(2021, 1, 1, 0, 0),
-#     # timezone=None,
-# )
-# async def _():
-#     await bot.send_group_msg(group_id=123456,
-#                              message="2021，新年快乐！")
-
-#  定期任务
-#  从 start_date 开始到 end_date 结束，根据类似 Cron
-#
-# 的规则触发任务：
-#
-# @nonebot.scheduler.scheduled_job(
-#     'cron',
-#     # year=None,
-#     # month=None,
-#     # day=None,
-#     # week=None,
-#     day_of_week="mon,tue,wed,thu,fri",
-#     hour=7,
-#     # minute=None,
-#     # second=None,
-#     # start_date=None,
-#     # end_date=None,
-#     # timezone=None,
-# )
-# async def _():
-#     await bot.send_group_msg(group_id=123456,
-#                              message="起床啦！")
-
-#  间隔任务
-#
-# interval 触发器
-#
-# 从 start_date 开始，每间隔一段时间触发，到 end_date 结束：
-#
-# @nonebot.scheduler.scheduled_job(
-#     'interval',
-#     # weeks=0,
-#     # days=0,
-#     # hours=0,
-#     minutes=5,
-#     # seconds=0,
-#     # start_date=time.now(),
-#     # end_date=None,
-# )
-# async def _():
-#     has_new_item = check_new_item()
-#     if has_new_item:
-#         await bot.send_group_msg(group_id=123456,
-#                                  message="XX有更新啦！")
-
-
-# 动态的计划任务
-# import datetime
-#
-# from apscheduler.triggers.date import DateTrigger # 一次性触发器
-# # from apscheduler.triggers.cron import CronTrigger # 定期触发器
-# # from apscheduler.triggers.interval import IntervalTrigger # 间隔触发器
-# from nonebot import on_command, scheduler
-#
-# @on_command('赖床')
-# async def _(session: CommandSession):
-#     await session.send('我会在5分钟后再喊你')
-#
-#     # 制作一个“5分钟后”触发器
-#     delta = datetime.timedelta(minutes=5)
-#     trigger = DateTrigger(
-#         run_date=datetime.datetime.now() + delta
-#     )
-#
-#     # 添加任务
-#     scheduler.add_job(
-#         func=session.send,  # 要添加任务的函数，不要带参数
-#         trigger=trigger,  # 触发器
-#         args=('不要再赖床啦！',),  # 函数的参数列表，注意：只有一个值时，不能省略末尾的逗号
-#         # kwargs=None,
-#         misfire_grace_time=60,  # 允许的误差时间，建议不要省略
-#         # jobstore='default',  # 任务储存库，在下一小节中说明
-#     )

basic_plugins/ban/__init__.py

@@ -1,170 +0,0 @@
-from typing import Tuple
-
-from configs.config import NICKNAME, Config
-from models.ban_user import BanUser
-from models.level_user import LevelUser
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import (Bot, GroupMessageEvent, Message,
-                                         MessageEvent, PrivateMessageEvent)
-from nonebot.params import Command, CommandArg
-from nonebot.permission import SUPERUSER
-from services.log import logger
-from utils.utils import get_message_at, is_number
-
-from .data_source import a_ban, parse_ban_time
-
-__zx_plugin_name__ = "封禁Ban用户 [Admin]"
-__plugin_usage__ = """
-usage：
-    将用户拉入或拉出黑名单
-    指令:
-        .ban [at] ?[小时] ?[分钟]
-        .unban 
-        示例：.ban @user
-        示例：.ban @user 6
-        示例：.ban @user 3 10
-        示例：.unban @user
-""".strip()
-__plugin_superuser_usage__ = """
-usage：
-    b了=屏蔽用户消息，相当于最上级.ban
-    跨群ban以及跨群b了
-    指令：
-        b了 [at/qq]
-        .ban [user_id] ?[小时] ?[分钟]
-        示例：b了 @user
-        示例：b了 1234567
-        示例：.ban 12345567
-""".strip()
-__plugin_des__ = "你被逮捕了！丢进小黑屋！"
-__plugin_cmd__ = [".ban [at] ?[小时] ?[分钟]", ".unban [at]", "b了 [at] [_superuser]"]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "admin_level": Config.get_config("ban", "BAN_LEVEL"),
-    "cmd": [".ban", ".unban", "ban", "unban"],
-}
-__plugin_configs__ = {
-    "BAN_LEVEL [LEVEL]": {
-        "value": 5,
-        "help": "ban/unban所需要的管理员权限等级",
-        "default_value": 5,
-    }
-}
-
-
-ban = on_command(
-    ".ban",
-    aliases={".unban", "/ban", "/unban"},
-    priority=5,
-    block=True,
-)
-
-super_ban = on_command("b了", permission=SUPERUSER, priority=5, block=True)
-
-
-@ban.handle()
-async def _(
-    bot: Bot,
-    event: GroupMessageEvent,
-    cmd: Tuple[str, ...] = Command(),
-    arg: Message = CommandArg(),
-):
-    cmd = cmd[0]
-    result = ""
-    qq = get_message_at(event.json())
-    if qq:
-        qq = qq[0]
-        user_name = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
-        user_name = user_name["card"] or user_name["nickname"]
-        msg = arg.extract_plain_text().strip()
-        time = parse_ban_time(msg)
-        if isinstance(time, str):
-            await ban.finish(time, at_sender=True)
-        if cmd in [".ban", "/ban"]:
-            if (
-                await LevelUser.get_user_level(event.user_id, event.group_id)
-                <= await LevelUser.get_user_level(qq, event.group_id)
-                and str(event.user_id) not in bot.config.superusers
-            ):
-                await ban.finish(
-                    f"您的权限等级比对方低或相等, {NICKNAME}不能为您使用此功能!",
-                    at_sender=True,
-                )
-            result = await a_ban(qq, time, user_name, event)
-        else:
-            if (
-                await BanUser.check_ban_level(
-                    qq, await LevelUser.get_user_level(event.user_id, event.group_id)
-                )
-                and str(event.user_id) not in bot.config.superusers
-            ):
-                await ban.finish(
-                    f"ban掉 {user_name} 的管理员权限比您高，无法进行unban", at_sender=True
-                )
-            if await BanUser.unban(qq):
-                logger.info(
-                    f"USER {event.user_id} GROUP {event.group_id} 将 USER {qq} 解禁"
-                )
-                result = f"已经把 {user_name} 从黑名单中删除了！"
-            else:
-                result = f"{user_name} 不在黑名单！"
-    else:
-        await ban.finish("艾特人了吗？？", at_sender=True)
-    await ban.send(result, at_sender=True)
-
-
-@ban.handle()
-async def _(
-    bot: Bot,
-    event: PrivateMessageEvent,
-    cmd: Tuple[str, ...] = Command(),
-    arg: Message = CommandArg(),
-):
-    cmd = cmd[0]
-    msg = arg.extract_plain_text().strip()
-    if msg:
-        if str(event.user_id) in bot.config.superusers:
-            if is_number(arg.extract_plain_text().strip().split()[0]):
-                qq = int(msg[0])
-                msg = msg[1:]
-                if cmd in [".ban", "/ban"]:
-                    time = parse_ban_time(msg)
-                    if isinstance(time, str):
-                        await ban.finish(time)
-                    result = await a_ban(qq, time, str(qq), event, 9)
-                else:
-                    if await BanUser.unban(qq):
-                        logger.info(f"USER {event.user_id} 将 USER {qq} 解禁")
-                        result = f"已经把 {qq} 从黑名单中删除了！"
-                    else:
-                        result = f"{qq} 不在黑名单！"
-                await ban.send(result)
-            else:
-                await ban.finish(
-                    "qq号必须是数字！\n格式：.ban [qq] [hour]? [minute]?", at_sender=True
-                )
-
-
-@super_ban.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    user_name = ""
-    if isinstance(event, GroupMessageEvent):
-        qq = get_message_at(event.json())
-        if qq:
-            qq = qq[0]
-            user = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
-            user_name = user["card"] or user["nickname"]
-    else:
-        qq = arg.extract_plain_text().strip()
-        if not is_number(qq):
-            await super_ban.finish("对象qq必须为纯数字...")
-        qq = int(qq)
-        user_name = qq
-    if qq:
-        if not await BanUser.ban(qq, 10, 99999999):
-            await BanUser.unban(qq)
-            await BanUser.ban(qq, 10, 99999999)
-        await ban.send(f"已将 {user_name} 拉入黑名单！")
-    else:
-        await super_ban.send("需要添加被super ban的对象，可以使用at或者指定qq..")

basic_plugins/ban/data_source.py

@@ -1,69 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageEvent, GroupMessageEvent
-from configs.config import NICKNAME
-from models.level_user import LevelUser
-from utils.utils import is_number
-from models.ban_user import BanUser
-from services.log import logger
-from typing import Union
-
-
-def parse_ban_time(msg: str) -> Union[int, str]:
-    """
-    解析ban时长
-    :param msg: 文本消息
-    """
-    if not msg:
-        return -1
-    msg = msg.split()
-    if len(msg) == 1:
-        if not is_number(msg[0].strip()):
-            return "参数必须是数字！"
-        return int(msg[0]) * 60 * 60
-    else:
-        if not is_number(msg[0].strip()) or not is_number(msg[1].strip()):
-            return "参数必须是数字！"
-        return int(msg[0]) * 60 * 60 + int(msg[1]) * 60
-
-
-async def a_ban(qq: int, time: int, user_name: str, event: MessageEvent, ban_level: int = None) -> str:
-    """
-    ban
-    :param qq: qq
-    :param time: ban时长
-    :param user_name: ban用户昵称
-    :param event: event
-    :param ban_level: ban级别
-    """
-    if isinstance(event, GroupMessageEvent):
-        ban_level = await LevelUser.get_user_level(event.user_id, event.group_id)
-    if await BanUser.ban(qq, ban_level, time):
-        logger.info(
-            f"USER {event.user_id} GROUP {event.group_id} 将 USER {qq} 封禁 时长 {time / 60} 分钟"
-        )
-        result = f"已经将 {user_name} 加入{NICKNAME}的黑名单了！"
-        if time != -1:
-            result += f"将在 {time / 60} 分钟后解封"
-        else:
-            result += f"将在 ∞ 分钟后解封"
-    else:
-        time = await BanUser.check_ban_time(qq)
-        if is_number(time):
-            time = abs(int(time))
-            if time < 60:
-                time = str(time) + " 秒"
-            else:
-                time = str(int(time / 60)) + " 分钟"
-        else:
-            time += " 分钟"
-        result = f"{user_name} 已在黑名单！预计 {time}后解封"
-    return result
-
-
-
-
-
-
-
-
-
-

basic_plugins/broadcast/__init__.py

@@ -1,67 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.params import CommandArg
-from utils.utils import get_message_img
-from services.log import logger
-from utils.message_builder import image
-from utils.manager import group_manager
-from configs.config import Config
-import asyncio
-
-
-__zx_plugin_name__ = "广播 [Superuser]"
-__plugin_usage__ = """
-usage：
-    指令：
-        广播- ?[消息] ?[图片]
-        示例：广播- 你们好！
-""".strip()
-__plugin_des__ = "昭告天下！"
-__plugin_cmd__ = ["广播-"]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_task__ = {"broadcast": "广播"}
-Config.add_plugin_config(
-    "_task",
-    "DEFAULT_BROADCAST",
-    True,
-    help_="被动 广播 进群默认开关状态",
-    default_value=True,
-)
-
-broadcast = on_command("广播-", priority=1, permission=SUPERUSER, block=True)
-
-
-@broadcast.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    img_list = get_message_img(event.json())
-    rst = ""
-    for img in img_list:
-        rst += image(img)
-    gl = await bot.get_group_list()
-    gl = [
-        g["group_id"]
-        for g in gl
-        if await group_manager.check_group_task_status(g["group_id"], "broadcast")
-    ]
-    g_cnt = len(gl)
-    cnt = 0
-    error = ""
-    x = 0.25
-    for g in gl:
-        cnt += 1
-        if cnt / g_cnt > x:
-            await broadcast.send(f"已播报至 {int(cnt / g_cnt * 100)}% 的群聊")
-            x += 0.25
-        try:
-            await bot.send_group_msg(group_id=g, message=msg + rst)
-            logger.info(f"GROUP {g} 投递广播成功")
-        except Exception as e:
-            logger.error(f"GROUP {g} 投递广播失败：{type(e)}")
-            error += f"GROUP {g} 投递广播失败：{type(e)}\n"
-        await asyncio.sleep(0.5)
-    await broadcast.send(f"已播报至 100% 的群聊")
-    if error:
-        await broadcast.send(f"播报时错误：{error}")

basic_plugins/chat_history/__init__.py

@@ -1,3 +0,0 @@
-import nonebot
-
-nonebot.load_plugins("basic_plugins/chat_history")

basic_plugins/chat_history/_rule.py

@@ -1,6 +0,0 @@
-from nonebot.adapters.onebot.v11 import Event, MessageEvent
-from configs.config import Config
-
-
-def rule(event: Event) -> bool:
-    return Config.get_config("chat_history", "FLAG") and isinstance(event, MessageEvent)

basic_plugins/chat_history/chat_message.py

@@ -1,38 +0,0 @@
-from configs.config import Config
-from models.chat_history import ChatHistory
-from nonebot import on_message
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageEvent
-
-from ._rule import rule
-
-__zx_plugin_name__ = "消息存储 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-Config.add_plugin_config(
-    "chat_history", "FLAG", True, help_="是否开启消息自从存储", name="消息存储", default_value=True
-)
-
-
-chat_history = on_message(rule=rule, priority=1, block=False)
-
-
-@chat_history.handle()
-async def _(event: MessageEvent):
-    if isinstance(event, GroupMessageEvent):
-        await ChatHistory.add_chat_msg(
-            event.user_id, event.group_id, str(event.get_message())
-        )
-    else:
-        await ChatHistory.add_chat_msg(event.user_id, None, str(event.get_message()))
-
-
-# @test.handle()
-# async def _(event: MessageEvent):
-#     print(await ChatHistory.get_user_msg(event.user_id, "private"))
-#     print(await ChatHistory.get_user_msg_count(event.user_id, "private"))
-#     print(await ChatHistory.get_user_msg(event.user_id, "group"))
-#     print(await ChatHistory.get_user_msg_count(event.user_id, "group"))
-#     print(await ChatHistory.get_group_msg(event.group_id))
-#     print(await ChatHistory.get_group_msg_count(event.group_id))

basic_plugins/chat_history/chat_message_handle.py

@@ -1,108 +0,0 @@
-from datetime import datetime, timedelta
-
-import pytz
-from models.chat_history import ChatHistory
-from models.group_member_info import GroupInfoUser
-from nonebot import on_regex
-from nonebot.adapters.onebot.v11 import GroupMessageEvent
-from nonebot.params import RegexGroup
-from utils.image_utils import BuildImage, text2image
-from utils.utils import is_number
-from utils.message_builder import image
-from typing import Tuple, Any
-
-
-__zx_plugin_name__ = "消息统计"
-__plugin_usage__ = """
-usage：
-    发言记录统计
-    regex：(周|月)?消息排行(des|DES)?(n=[0-9]{1,2})?
-    指令：
-        消息统计?(des)?(n=?)
-        周消息统计?(des)?(n=?)
-        月消息统计?(des)?(n=?)
-    示例：
-        消息统计
-        消息统计des
-        消息统计DESn=15
-        消息统计n=15
-""".strip()
-__plugin_des__ = "发言消息排行"
-__plugin_cmd__ = [
-    "消息统计",
-    "周消息统计",
-    "月消息统计"
-]
-__plugin_type__ = ("数据统计", 1)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "cmd": ["消息统计"],
-}
-
-
-msg_handler = on_regex(r"^(周|月)?消息统计(des|DES)?(n=[0-9]{1,2})?$", priority=5, block=True)
-
-
-@msg_handler.handle()
-async def _(event: GroupMessageEvent, reg_group: Tuple[Any, ...] = RegexGroup()):
-    gid = event.group_id
-    date_scope = None
-    date, order, num = reg_group
-    num = num.split("=")[-1] if num else 10
-    if num and is_number(num) and 10 < int(num) < 50:
-        num = int(num)
-    if date in ["周"]:
-        date_scope = (datetime.now() - timedelta(days=7), datetime.now())
-    elif date in ["月"]:
-        date_scope = (datetime.now() - timedelta(days=30), datetime.now())
-    if rank_data := await ChatHistory.get_group_msg_rank(
-        gid, num, order or "DESC", date_scope
-    ):
-        name = "昵称：\n\n"
-        num_str = "发言次数：\n\n"
-        idx = 1
-        for uid, num in rank_data:
-            try:
-                user_name = (await GroupInfoUser.get_member_info(uid, gid)).user_name
-            except AttributeError:
-                user_name = uid
-            name += f"\t{idx}.{user_name} \n\n"
-            num_str += f"\t{num}\n\n"
-            idx += 1
-        name_img = await text2image(name.strip(), padding=10, color="#f9f6f2")
-        num_img = await text2image(num_str.strip(), padding=10, color="#f9f6f2")
-        if not date_scope:
-            if date_scope := await ChatHistory.get_group_first_msg_datetime(gid):
-                date_scope = date_scope.astimezone(
-                    pytz.timezone("Asia/Shanghai")
-                ).replace(microsecond=0)
-            else:
-                date_scope = datetime.now().replace(microsecond=0)
-            date_str = f"日期：{date_scope} - 至今"
-        else:
-            date_str = f"日期：{date_scope[0].replace(microsecond=0)} - {date_scope[1].replace(microsecond=0)}"
-        date_w = BuildImage(0, 0, font_size=15).getsize(date_str)[0]
-        img_w = date_w if date_w > name_img.w + num_img.w else name_img.w + num_img.w
-        A = BuildImage(
-            img_w + 15,
-            num_img.h + 30,
-            color="#f9f6f2",
-            font="CJGaoDeGuo.otf",
-            font_size=15,
-        )
-        await A.atext((10, 10), date_str)
-        await A.apaste(name_img, (0, 30))
-        await A.apaste(num_img, (name_img.w, 30))
-        await msg_handler.send(image(b64=A.pic2bs4()))
-
-
-# @test.handle()
-# async def _(event: MessageEvent):
-#     print(await ChatHistory.get_user_msg(event.user_id, "private"))
-#     print(await ChatHistory.get_user_msg_count(event.user_id, "private"))
-#     print(await ChatHistory.get_user_msg(event.user_id, "group"))
-#     print(await ChatHistory.get_user_msg_count(event.user_id, "group"))
-#     print(await ChatHistory.get_group_msg(event.group_id))
-#     print(await ChatHistory.get_group_msg_count(event.group_id))

basic_plugins/group_handle/__init__.py

@@ -1,195 +0,0 @@
-from nonebot import on_notice, on_request
-from configs.path_config import IMAGE_PATH, DATA_PATH
-from utils.message_builder import image
-from models.group_member_info import GroupInfoUser
-from datetime import datetime
-from services.log import logger
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    GroupIncreaseNoticeEvent,
-    GroupDecreaseNoticeEvent,
-)
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from utils.manager import group_manager, plugins2settings_manager, requests_manager
-from configs.config import NICKNAME
-from models.group_info import GroupInfo
-from utils.utils import FreqLimiter
-from configs.config import Config
-from pathlib import Path
-import random
-import os
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-__zx_plugin_name__ = "群事件处理 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_task__ = {"group_welcome": "进群欢迎", "refund_group_remind": "退群提醒"}
-Config.add_plugin_config(
-    "invite_manager", "message", f"请不要未经同意就拉{NICKNAME}入群！告辞！", help_="强制拉群后进群回复的内容.."
-)
-Config.add_plugin_config(
-    "invite_manager", "flag", True, help_="被强制拉群后是否直接退出", default_value=True
-)
-Config.add_plugin_config(
-    "invite_manager", "welcome_msg_cd", 5, help_="群欢迎消息cd", default_value=5
-)
-Config.add_plugin_config(
-    "_task",
-    "DEFAULT_GROUP_WELCOME",
-    True,
-    help_="被动 进群欢迎 进群默认开关状态",
-    default_value=True,
-)
-Config.add_plugin_config(
-    "_task",
-    "DEFAULT_REFUND_GROUP_REMIND",
-    True,
-    help_="被动 退群提醒 进群默认开关状态",
-    default_value=True,
-)
-
-
-_flmt = FreqLimiter(Config.get_config("invite_manager", "welcome_msg_cd"))
-
-
-# 群员增加处理
-group_increase_handle = on_notice(priority=1, block=False)
-# 群员减少处理
-group_decrease_handle = on_notice(priority=1, block=False)
-# （群管理）加群同意请求
-add_group = on_request(priority=1, block=False)
-
-
-@group_increase_handle.handle()
-async def _(bot: Bot, event: GroupIncreaseNoticeEvent):
-    if event.user_id == int(bot.self_id):
-        group = await GroupInfo.get_group_info(event.group_id)
-        # 群聊不存在或被强制拉群，退出该群
-        if (not group or group.group_flag == 0) and Config.get_config(
-            "invite_manager", "flag"
-        ):
-            try:
-                msg = Config.get_config("invite_manager", "message")
-                if msg:
-                    await bot.send_group_msg(group_id=event.group_id, message=msg)
-                await bot.set_group_leave(group_id=event.group_id)
-                await bot.send_private_msg(
-                    user_id=int(list(bot.config.superusers)[0]),
-                    message=f"触发强制入群保护，已成功退出群聊 {event.group_id}..",
-                )
-                logger.info(f"强制拉群或未有群信息，退出群聊 {group} 成功")
-                requests_manager.remove_request("group", event.group_id)
-            except Exception as e:
-                logger.info(f"强制拉群或未有群信息，退出群聊 {group} 失败 e:{e}")
-                await bot.send_private_msg(
-                    user_id=int(list(bot.config.superusers)[0]),
-                    message=f"触发强制入群保护，退出群聊 {event.group_id} 失败..",
-                )
-        # 默认群功能开关
-        elif event.group_id not in group_manager["group_manager"].keys():
-            data = plugins2settings_manager.get_data()
-            for plugin in data.keys():
-                if not data[plugin]["default_status"]:
-                    group_manager.block_plugin(plugin, event.group_id)
-    else:
-        join_time = datetime.now()
-        user_info = await bot.get_group_member_info(
-            group_id=event.group_id, user_id=event.user_id
-        )
-        if await GroupInfoUser.add_member_info(
-            user_info["user_id"],
-            user_info["group_id"],
-            user_info["nickname"],
-            join_time,
-        ):
-            logger.info(f"用户{user_info['user_id']} 所属{user_info['group_id']} 更新成功")
-        else:
-            logger.info(f"用户{user_info['user_id']} 所属{user_info['group_id']} 更新失败")
-
-        # 群欢迎消息
-        if _flmt.check(event.group_id):
-            _flmt.start_cd(event.group_id)
-            msg = ""
-            img = ""
-            at_flag = False
-            custom_welcome_msg_json = (
-                Path() / "data" / "custom_welcome_msg" / "custom_welcome_msg.json"
-            )
-            if custom_welcome_msg_json.exists():
-                data = json.load(open(custom_welcome_msg_json, "r"))
-                if data.get(str(event.group_id)):
-                    msg = data[str(event.group_id)]
-                    if msg.find("[at]") != -1:
-                        msg = msg.replace("[at]", "")
-                        at_flag = True
-            if (DATA_PATH / "custom_welcome_msg" / f"{event.group_id}.jpg").exists():
-                img = image(
-                    DATA_PATH / "custom_welcome_msg" / f"{event.group_id}.jpg"
-                )
-            if msg or img:
-                msg = msg.strip() + img
-                msg = "\n" + msg if at_flag else msg
-                await group_increase_handle.send(
-                    "[[_task|group_welcome]]" + msg, at_sender=at_flag
-                )
-            else:
-                await group_increase_handle.send(
-                    "[[_task|group_welcome]]新人快跑啊！！本群现状↓（快使用自定义！）"
-                    + image(random.choice(os.listdir(IMAGE_PATH / "qxz")), "qxz")
-                )
-
-
-@group_decrease_handle.handle()
-async def _(bot: Bot, event: GroupDecreaseNoticeEvent):
-    # 被踢出群
-    if event.sub_type == "kick_me":
-        group_id = event.group_id
-        operator_id = event.operator_id
-        try:
-            operator_name = (
-                await GroupInfoUser.get_member_info(event.operator_id, event.group_id)
-            ).user_name
-        except AttributeError:
-            operator_name = "None"
-        group = await GroupInfo.get_group_info(group_id)
-        group_name = group.group_name if group else ""
-        coffee = int(list(bot.config.superusers)[0])
-        await bot.send_private_msg(
-            user_id=coffee,
-            message=f"****呜..一份踢出报告****\n"
-            f"我被 {operator_name}({operator_id})\n"
-            f"踢出了 {group_name}({group_id})\n"
-            f"日期：{str(datetime.now()).split('.')[0]}",
-        )
-        return
-    if event.user_id == int(bot.self_id):
-        group_manager.delete_group(event.group_id)
-        return
-    try:
-        user_name = (
-            await GroupInfoUser.get_member_info(event.user_id, event.group_id)
-        ).user_name
-    except AttributeError:
-        user_name = str(event.user_id)
-    if await GroupInfoUser.delete_member_info(event.user_id, event.group_id):
-        logger.info(f"用户{user_name}, qq={event.user_id} 所属{event.group_id} 删除成功")
-    else:
-        logger.info(f"用户{user_name}, qq={event.user_id} 所属{event.group_id} 删除失败")
-    rst = ""
-    if event.sub_type == "leave":
-        rst = f"{user_name}离开了我们..."
-    if event.sub_type == "kick":
-        operator = await bot.get_group_member_info(
-            user_id=event.operator_id, group_id=event.group_id
-        )
-        operator_name = operator["card"] if operator["card"] else operator["nickname"]
-        rst = f"{user_name} 被 {operator_name} 送走了."
-    try:
-        await group_decrease_handle.send(f"[[_task|refund_group_remind]]{rst}")
-    except ActionFailed:
-        return

basic_plugins/help/__init__.py

@@ -1,73 +0,0 @@
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GroupMessageEvent,
-    Message
-)
-from nonebot.params import CommandArg
-from nonebot.typing import T_State
-from nonebot.rule import to_me
-from configs.path_config import IMAGE_PATH, DATA_PATH
-from utils.message_builder import image
-from .data_source import create_help_img, get_plugin_help
-import os
-
-
-__zx_plugin_name__ = "帮助"
-
-group_help_path = DATA_PATH / "group_help"
-help_image = IMAGE_PATH / "help.png"
-simple_help_image = IMAGE_PATH / "simple_help.png"
-if help_image.exists():
-    help_image.unlink()
-if simple_help_image.exists():
-    simple_help_image.unlink()
-group_help_path.mkdir(exist_ok=True, parents=True)
-for x in os.listdir(group_help_path):
-    group_help_image = group_help_path / x
-    group_help_image.unlink()
-
-_help = on_command("详细功能", rule=to_me(), aliases={"详细帮助"}, priority=1, block=True)
-simple_help = on_command("功能", rule=to_me(), aliases={"help", "帮助"}, priority=1, block=True)
-
-
-@_help.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    if not help_image.exists():
-        if help_image.exists():
-            help_image.unlink()
-        if simple_help_image.exists():
-            simple_help_image.unlink()
-        await create_help_img(None, help_image, simple_help_image)
-    await _help.finish(image("help.png"))
-
-
-@simple_help.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    is_super = False
-    if msg:
-        if '-super' in msg:
-            if str(event.user_id) in bot.config.superusers:
-                is_super = True
-            msg = msg.replace('-super', '').strip()
-        msg = get_plugin_help(msg, is_super)
-        if msg:
-            await _help.send(image(b64=msg))
-        else:
-            await _help.send("没有此功能的帮助信息...")
-    else:
-        if isinstance(event, GroupMessageEvent):
-            _image_path = group_help_path / f"{event.group_id}.png"
-            if not _image_path.exists():
-                await create_help_img(event.group_id, help_image, _image_path)
-            await simple_help.send(image(_image_path))
-        else:
-            if not simple_help_image.exists():
-                if help_image.exists():
-                    help_image.unlink()
-                if simple_help_image.exists():
-                    simple_help_image.unlink()
-                await create_help_img(None, help_image, simple_help_image)
-            await _help.finish(image("simple_help.png"))

basic_plugins/help/data_source.py

@@ -1,367 +0,0 @@
-from utils.image_utils import BuildImage
-from configs.path_config import IMAGE_PATH
-from utils.manager import (
-    plugins2settings_manager,
-    admin_manager,
-    plugins_manager,
-    group_manager,
-)
-from typing import Optional
-from services.log import logger
-from pathlib import Path
-from utils.utils import get_matchers
-import random
-import asyncio
-import nonebot
-import os
-
-
-random_bk_path = IMAGE_PATH / "background" / "help" / "simple_help"
-
-background = IMAGE_PATH / "background" / "0.png"
-
-
-async def create_help_img(
-    group_id: Optional[int], help_image: Path, simple_help_image: Path
-):
-    """
-    生成帮助图片
-    :param group_id: 群号
-    :param help_image: 图片路径
-    :param simple_help_image: 简易帮助图片路径
-    """
-    return await asyncio.get_event_loop().run_in_executor(
-        None, _create_help_img, group_id, help_image, simple_help_image
-    )
-
-
-def _create_help_img(
-    group_id: Optional[int], help_image: Path, simple_help_image: Path
-):
-    """
-    生成帮助图片
-    :param group_id: 群号
-    :param help_image: 图片路径
-    :param simple_help_image: 简易帮助图片路径
-    """
-    _matchers = get_matchers()
-    width = 0
-    matchers_data = {}
-    _des_tmp = {}
-    _plugin_name_tmp = []
-    _tmp = []
-    tmp_img = BuildImage(0, 0, plain_text="1", font_size=24)
-    font_height = tmp_img.h
-    # 插件分类
-    for matcher in _matchers:
-        plugin_name = None
-        _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-        _module = _plugin.module
-        try:
-            plugin_name = _module.__getattribute__("__zx_plugin_name__")
-            try:
-                plugin_des = _module.__getattribute__("__plugin_des__")
-            except AttributeError:
-                plugin_des = "_"
-            if (
-                "[hidden]" in plugin_name.lower()
-                or "[admin]" in plugin_name.lower()
-                or "[superuser]" in plugin_name.lower()
-                or plugin_name in _plugin_name_tmp
-                or plugin_name == "帮助"
-            ):
-                continue
-            plugin_type = ("normal",)
-            text_type = 0
-            if plugins2settings_manager.get(
-                matcher.plugin_name
-            ) and plugins2settings_manager[matcher.plugin_name].get("plugin_type"):
-                plugin_type = tuple(
-                    plugins2settings_manager.get_plugin_data(matcher.plugin_name)[
-                        "plugin_type"
-                    ]
-                )
-            else:
-                try:
-                    plugin_type = _module.__getattribute__("__plugin_type__")
-                except AttributeError:
-                    pass
-            if len(plugin_type) > 1:
-                try:
-                    text_type = int(plugin_type[1])
-                except ValueError as e:
-                    logger.warning(f"生成列向帮助排列失败 {plugin_name}: {type(e)}: {e}")
-                plugin_type = plugin_type[0]
-            else:
-                plugin_type = plugin_type[0]
-            try:
-                plugin_cmd = _module.__getattribute__("__plugin_cmd__")
-                plugin_cmd = [x for x in plugin_cmd if "[_superuser]" not in x]
-            except AttributeError:
-                plugin_cmd = []
-            if plugin_type not in matchers_data.keys():
-                matchers_data[plugin_type] = {}
-            if plugin_des in _des_tmp.keys():
-                try:
-                    matchers_data[plugin_type][_des_tmp[plugin_des]]["cmd"] = (
-                        matchers_data[plugin_type][_des_tmp[plugin_des]]["cmd"]
-                        + plugin_cmd
-                    )
-                except KeyError as e:
-                    logger.warning(f"{type(e)}: {e}")
-            else:
-                matchers_data[plugin_type][plugin_name] = {
-                    "modules": matcher.plugin_name,
-                    "des": plugin_des,
-                    "cmd": plugin_cmd,
-                    "text_type": text_type,
-                }
-            try:
-                if text_type == 0:
-                    x = tmp_img.getsize(
-                        f'{plugin_name}: {matchers_data[plugin_type][plugin_name]["des"]} ->'
-                        + " / ".join(matchers_data[plugin_type][plugin_name]["cmd"])
-                    )[0]
-                    width = width if width > x else x
-            except KeyError:
-                pass
-            if plugin_des not in _des_tmp:
-                _des_tmp[plugin_des] = plugin_name
-        except AttributeError as e:
-            if plugin_name not in _plugin_name_tmp:
-                logger.warning(f"获取功能 {matcher.plugin_name}: {plugin_name} 设置失败...e：{e}")
-        if plugin_name not in _plugin_name_tmp:
-            _plugin_name_tmp.append(plugin_name)
-    help_img_list = []
-    simple_help_img_list = []
-    types = list(matchers_data.keys())
-    types.sort()
-    ix = 0
-    # 详细帮助
-    for type_ in types:
-        keys = list(matchers_data[type_].keys())
-        keys.sort()
-        help_str = f"{type_ if type_ != 'normal' else '功能'}:\n\n"
-        simple_help_str = f"{type_ if type_ != 'normal' else '功能'}:\n\n"
-        for i, k in enumerate(keys):
-            # 禁用flag
-            flag = True
-            if plugins_manager.get_plugin_status(
-                matchers_data[type_][k]["modules"], "all"
-            ):
-                flag = False
-            if group_id:
-                flag = flag and plugins_manager.get_plugin_status(
-                    matchers_data[type_][k]["modules"], "group"
-                )
-            simple_help_str += (
-                f"{i+1}.{k}<|_|~|>"
-                f"{group_manager.get_plugin_status(matchers_data[type_][k]['modules'], group_id) if group_id else '_'}|"
-                f"{flag}\n"
-            )
-            if matchers_data[type_][k]["text_type"] == 1:
-                _x = tmp_img.getsize(
-                    f"{i+1}".rjust(5)
-                    + f'.{k}: {matchers_data[type_][k]["des"]} {"->" if matchers_data[type_][k]["cmd"] else ""} '
-                )[0]
-                _str = (
-                    f"{i+1}".rjust(5)
-                    + f'.{k}: {matchers_data[type_][k]["des"]} {"->" if matchers_data[type_][k]["cmd"] else ""} '
-                )
-                _str += matchers_data[type_][k]["cmd"][0] + "\n"
-                for c in matchers_data[type_][k]["cmd"][1:]:
-                    _str += "".rjust(int(_x * 0.125) + 1) + f"{c}\n"
-                help_str += _str
-            else:
-                help_str += (
-                    f"{i+1}".rjust(5)
-                    + f'.{k}: {matchers_data[type_][k]["des"]} {"->" if matchers_data[type_][k]["cmd"] else ""} '
-                    + " / ".join(matchers_data[type_][k]["cmd"])
-                    + "\n"
-                )
-        height = len(help_str.split("\n")) * (font_height + 5)
-        simple_height = len(simple_help_str.split("\n")) * (font_height + 5)
-        A = BuildImage(
-            width + 150, height, font_size=24, color="white" if not ix % 2 else "black"
-        )
-        A.text((10, 10), help_str, (255, 255, 255) if ix % 2 else (0, 0, 0))
-        # 生成各个分类的插件简易帮助图片
-        simple_width = 0
-        for x in [
-            tmp_img.getsize(x.split("<|_|~|>")[0])[0]
-            for x in simple_help_str.split("\n")
-        ]:
-            simple_width = simple_width if simple_width > x else x
-        bk = BuildImage(simple_width + 20, simple_height, font_size=24, color="#6495ED")
-        B = BuildImage(
-            simple_width + 20,
-            simple_height,
-            font_size=24,
-            color="white" if not ix % 2 else "black",
-        )
-        # 切分，判断插件开关状态
-        _s_height = 10
-        for _s in simple_help_str.split("\n"):
-            text_color = (255, 255, 255) if ix % 2 else (0, 0, 0)
-            _line_flag = False
-            if "<|_|~|>" in _s:
-                _x = _s.split("<|_|~|>")
-                _flag_sp = _x[-1].split("|")
-                if group_id:
-                    if _flag_sp[0].lower() != "true":
-                        text_color = (252, 75, 13)
-                if _flag_sp[1].lower() == "true":
-                    _line_flag = True
-                _s = _x[0]
-            B.text((10, _s_height), _s, text_color)
-            if _line_flag:
-                B.line(
-                    (
-                        7,
-                        _s_height + int(B.getsize(_s)[1] / 2) + 2,
-                        B.getsize(_s)[0] + 11,
-                        _s_height + int(B.getsize(_s)[1] / 2) + 2,
-                    ),
-                    (236, 66, 7),
-                    3,
-                )
-            _s_height += B.getsize("1")[1] + 5
-        # B.text((10, 10), simple_help_str, (255, 255, 255) if ix % 2 else (0, 0, 0))
-        bk.paste(B, center_type="center")
-        bk.transparent(2)
-        ix += 1
-        help_img_list.append(A)
-        simple_help_img_list.append(bk)
-    height = 0
-    for img in help_img_list:
-        height += img.h
-    if not group_id:
-        A = BuildImage(width + 150, height + 50, font_size=24)
-        A.text(
-            (10, 10), '*  注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数  *\n\n" "功能名: 功能简介 -> 指令\n\n'
-        )
-        current_height = 50
-        for img in help_img_list:
-            A.paste(img, (0, current_height))
-            current_height += img.h
-        A.save(help_image)
-    # 详细帮助生成完毕
-    # 简易帮助图片合成
-    height = 0
-    width = 0
-    for img in simple_help_img_list:
-        if img.h > height:
-            height = img.h
-        width += img.w + 10
-    B = BuildImage(width + 100, height + 250, font_size=24)
-    width, _ = get_max_width_or_paste(simple_help_img_list, B)
-    bk = None
-    random_bk = os.listdir(random_bk_path)
-    if random_bk:
-        bk = random.choice(random_bk)
-    x = max(width + 50, height + 250)
-    B = BuildImage(
-        x,
-        x,
-        font_size=24,
-        color="#FFEFD5",
-        background=random_bk_path / bk,
-    )
-    B.filter("GaussianBlur", 10)
-    _, B = get_max_width_or_paste(simple_help_img_list, B, True)
-    w = 10
-    h = 10
-    for msg in ["目前支持的功能列表:", "可以通过 ‘帮助[功能名称]’ 来获取对应功能的使用方法", "或者使用 ‘详细帮助’ 来获取所有功能方法"]:
-        text = BuildImage(
-            0,
-            0,
-            plain_text=msg,
-            font_size=24,
-            font="HYWenHei-85W.ttf",
-        )
-        B.paste(text, (w, h), True)
-        h += 50
-        if msg == "目前支持的功能列表:":
-            w += 50
-    B.paste(
-        BuildImage(
-            0,
-            0,
-            plain_text="注: 红字代表功能被群管理员禁用，红线代表功能正在维护",
-            font_size=24,
-            font="HYWenHei-85W.ttf",
-            font_color=(231, 74, 57)
-        ),
-        (300, 10),
-        True,
-    )
-    B.save(simple_help_image)
-
-
-def get_max_width_or_paste(
-    simple_help_img_list: list, B: BuildImage = None, is_paste: bool = False
-) -> "int, BuildImage":
-    """
-    获取最大宽度，或直接贴图
-    :param simple_help_img_list: 简单帮助图片列表
-    :param B: 背景图
-    :param is_paste: 是否直接贴图
-    """
-    current_width = 50
-    current_height = 180
-    max_width = simple_help_img_list[0].w
-    for i in range(len(simple_help_img_list)):
-        try:
-            if is_paste and B:
-                B.paste(simple_help_img_list[i], (current_width, current_height), True)
-            current_height += simple_help_img_list[i].h + 40
-            if current_height + simple_help_img_list[i + 1].h > B.h - 10:
-                current_height = 180
-                current_width += max_width + 30
-                max_width = 0
-            elif simple_help_img_list[i].w > max_width:
-                max_width = simple_help_img_list[i].w
-        except IndexError:
-            pass
-    if current_width > simple_help_img_list[0].w + 50:
-        current_width += simple_help_img_list[-1].w
-    return current_width, B
-
-
-def get_plugin_help(msg: str, is_super: bool = False) -> Optional[str]:
-    """
-    获取功能的帮助信息
-    :param msg: 功能cmd
-    :param is_super: 是否为超级用户
-    """
-    module = plugins2settings_manager.get_plugin_module(msg)
-    if not module:
-        module = admin_manager.get_plugin_module(msg)
-    if module:
-        try:
-            plugin = nonebot.plugin.get_plugin(module)
-            if plugin:
-                if is_super:
-                    result = plugin.module.__getattribute__(
-                        "__plugin_superuser_usage__"
-                    )
-                else:
-                    result = plugin.module.__getattribute__("__plugin_usage__")
-                if result:
-                    width = 0
-                    for x in result.split("\n"):
-                        _width = len(x) * 24
-                        width = width if width > _width else _width
-                    height = len(result.split("\n")) * 45
-                    A = BuildImage(width, height, font_size=24)
-                    bk = BuildImage(
-                        width,
-                        height,
-                        background=IMAGE_PATH / "background" / "1.png",
-                    )
-                    A.paste(bk, alpha=True)
-                    A.text((int(width * 0.048), int(height * 0.21)), result)
-                    return A.pic2bs4()
-        except AttributeError:
-            pass
-    return None

basic_plugins/hooks/__init__.py

@@ -1,36 +0,0 @@
-from configs.config import Config
-
-
-Config.add_plugin_config(
-    "hook",
-    "CHECK_NOTICE_INFO_CD",
-    300,
-    name="基础hook配置",
-    help_="群检测，个人权限检测等各种检测提示信息cd",
-    default_value=300
-)
-
-Config.add_plugin_config(
-    "hook",
-    "MALICIOUS_BAN_TIME",
-    30,
-    help_="恶意命令触发检测触发后ban的时长（分钟）",
-    default_value=30
-)
-
-Config.add_plugin_config(
-    "hook",
-    "MALICIOUS_CHECK_TIME",
-    5,
-    help_="恶意命令触发检测规定时间内（秒）",
-    default_value=5
-)
-
-Config.add_plugin_config(
-    "hook",
-    "MALICIOUS_BAN_COUNT",
-    6,
-    help_="恶意命令触发检测最大触发次数",
-    default_value=6
-)
-

basic_plugins/hooks/_utils.py

@@ -1,52 +0,0 @@
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, PrivateMessageEvent
-from utils.manager import plugins2block_manager, StaticData
-import time
-
-ignore_rst_module = ["ai", "poke", "dialogue"]
-
-other_limit_plugins = ["poke"]
-
-
-class StatusMessageManager(StaticData):
-
-    def __init__(self):
-        super().__init__(None)
-
-    def add(self, id_: int):
-        self._data[id_] = time.time()
-
-    def delete(self, id_: int):
-        if self._data.get(id_):
-            del self._data[id_]
-
-    def check(self, id_: int, t: int = 30) -> bool:
-        if self._data.get(id_):
-            if time.time() - self._data[id_] > t:
-                del self._data[id_]
-                return True
-            return False
-        return True
-
-
-status_message_manager = StatusMessageManager()
-
-
-def set_block_limit_false(event, module):
-    """
-    设置用户block为false
-    :param event: event
-    :param module: 插件模块
-    """
-    if plugins2block_manager.check_plugin_block_status(module):
-        plugin_block_data = plugins2block_manager.get_plugin_block_data(module)
-        check_type = plugin_block_data["check_type"]
-        limit_type = plugin_block_data["limit_type"]
-        if not (
-            (isinstance(event, GroupMessageEvent) and check_type == "private")
-            or (isinstance(event, PrivateMessageEvent) and check_type == "group")
-        ):
-            block_type_ = event.user_id
-            if limit_type == "group" and isinstance(event, GroupMessageEvent):
-                block_type_ = event.group_id
-            plugins2block_manager.set_false(block_type_, module)
-

basic_plugins/hooks/auth_hook.py

@@ -1,386 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, run_postprocessor, IgnoredException
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from models.friend_user import FriendUser
-from models.group_member_info import GroupInfoUser
-from models.bag_user import BagUser
-from utils.manager import (
-    plugins2settings_manager,
-    admin_manager,
-    group_manager,
-    plugins_manager,
-    plugins2cd_manager,
-    plugins2block_manager,
-    plugins2count_manager,
-)
-from ._utils import (
-    set_block_limit_false,
-    status_message_manager,
-    ignore_rst_module,
-    other_limit_plugins,
-)
-from nonebot.typing import T_State
-from typing import Optional
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GroupMessageEvent,
-    PokeNotifyEvent,
-    PrivateMessageEvent,
-    Message,
-    Event,
-)
-from configs.config import Config
-from models.ban_user import BanUser
-from utils.utils import FreqLimiter
-from utils.message_builder import at
-from models.level_user import LevelUser
-import nonebot
-
-_flmt = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-_flmt_g = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-_flmt_s = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-_flmt_c = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-
-
-# 权限检测
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: Event, state: T_State):
-    module = matcher.plugin_name
-    plugins2info_dict = plugins2settings_manager.get_data()
-    # 功能的金币检测 #######################################
-    # 功能的金币检测 #######################################
-    # 功能的金币检测 #######################################
-    cost_gold = 0
-    if isinstance(
-        event, GroupMessageEvent
-    ) and plugins2settings_manager.get_plugin_data(module).get("cost_gold"):
-        cost_gold = plugins2settings_manager.get_plugin_data(module).get("cost_gold")
-        if await BagUser.get_gold(event.user_id, event.group_id) < cost_gold:
-            await send_msg(f"金币不足..该功能需要{cost_gold}金币..", bot, event)
-            raise IgnoredException(f"{module} 金币限制...")
-        # 当插件不阻塞超级用户时，超级用户提前扣除金币
-        if (
-            str(event.user_id) in bot.config.superusers
-            and not plugins2info_dict[module]["limit_superuser"]
-        ):
-            await BagUser.spend_gold(event.user_id, event.group_id, cost_gold)
-    try:
-        if (
-            (not isinstance(event, MessageEvent) and module not in other_limit_plugins)
-            or await BanUser.is_ban(event.user_id)
-            and str(event.user_id) not in bot.config.superusers
-        ) or (
-            str(event.user_id) in bot.config.superusers
-            and plugins2info_dict.get(module)
-            and not plugins2info_dict[module]["limit_superuser"]
-        ):
-            return
-    except AttributeError:
-        pass
-    # 超级用户命令
-    try:
-        _plugin = nonebot.plugin.get_plugin(module)
-        _module = _plugin.module
-        plugin_name = _module.__getattribute__("__zx_plugin_name__")
-        if (
-            "[superuser]" in plugin_name.lower()
-            and str(event.user_id) in bot.config.superusers
-        ):
-            return
-    except AttributeError:
-        pass
-    # 群黑名单检测 群总开关检测
-    if isinstance(event, GroupMessageEvent) or matcher.plugin_name == other_limit_plugins:
-        try:
-            if (
-                group_manager.get_group_level(event.group_id) < 0
-                and str(event.user_id) not in bot.config.superusers
-            ):
-                raise IgnoredException("群黑名单")
-            if not group_manager.check_group_bot_status(event.group_id):
-                try:
-                    if str(event.get_message()) != "醒来":
-                        raise IgnoredException("功能总开关关闭状态")
-                except ValueError:
-                    raise IgnoredException("功能总开关关闭状态")
-        except AttributeError:
-            pass
-    if module in admin_manager.keys() and matcher.priority not in [1, 9]:
-        if isinstance(event, GroupMessageEvent):
-            # 个人权限
-            if (
-                not await LevelUser.check_level(
-                    event.user_id,
-                    event.group_id,
-                    admin_manager.get_plugin_level(module),
-                )
-                and admin_manager.get_plugin_level(module) > 0
-            ):
-                try:
-                    if _flmt.check(event.user_id):
-                        _flmt.start_cd(event.user_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id,
-                            message=f"{at(event.user_id)}你的权限不足喔，该功能需要的权限等级："
-                            f"{admin_manager.get_plugin_level(module)}",
-                        )
-                except ActionFailed:
-                    pass
-                set_block_limit_false(event, module)
-                if event.is_tome():
-                    status_message_manager.add(event.group_id)
-                raise IgnoredException("权限不足")
-        else:
-            if not await LevelUser.check_level(
-                event.user_id, 0, admin_manager.get_plugin_level(module)
-            ):
-                try:
-                    await bot.send_private_msg(
-                        user_id=event.user_id,
-                        message=f"你的权限不足喔，该功能需要的权限等级：{admin_manager.get_plugin_level(module)}",
-                    )
-                except ActionFailed:
-                    pass
-                set_block_limit_false(event, module)
-                if event.is_tome():
-                    status_message_manager.add(event.user_id)
-                raise IgnoredException("权限不足")
-    if module in plugins2info_dict.keys() and matcher.priority not in [1, 9]:
-        # 戳一戳单独判断
-        if isinstance(event, GroupMessageEvent) or isinstance(event, PokeNotifyEvent) or matcher.plugin_name in other_limit_plugins:
-            if status_message_manager.get(event.group_id) is None:
-                status_message_manager.delete(event.group_id)
-            if plugins2info_dict[module]["level"] > group_manager.get_group_level(
-                event.group_id
-            ):
-                try:
-                    if _flmt_g.check(event.user_id) and module not in ignore_rst_module:
-                        _flmt_g.start_cd(event.user_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id, message="群权限不足..."
-                        )
-                except ActionFailed:
-                    pass
-                if event.is_tome():
-                    status_message_manager.add(event.group_id)
-                set_block_limit_false(event, module)
-                raise IgnoredException("群权限不足")
-            # 插件状态
-            if not group_manager.get_plugin_status(module, event.group_id):
-                try:
-                    if module not in ignore_rst_module and _flmt_s.check(
-                        event.group_id
-                    ):
-                        _flmt_s.start_cd(event.group_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id, message="该群未开启此功能.."
-                        )
-                except ActionFailed:
-                    pass
-                if event.is_tome():
-                    status_message_manager.add(event.group_id)
-                set_block_limit_false(event, module)
-                raise IgnoredException("未开启此功能...")
-            # 管理员禁用
-            if not group_manager.get_plugin_status(f"{module}:super", event.group_id):
-                try:
-                    if (
-                        _flmt_s.check(event.group_id)
-                        and module not in ignore_rst_module
-                    ):
-                        _flmt_s.start_cd(event.group_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id, message="管理员禁用了此群该功能..."
-                        )
-                except ActionFailed:
-                    pass
-                if event.is_tome():
-                    status_message_manager.add(event.group_id)
-                set_block_limit_false(event, module)
-                raise IgnoredException("管理员禁用了此群该功能...")
-            # 群聊禁用
-            if not plugins_manager.get_plugin_status(module, block_type="group"):
-                try:
-                    if (
-                        _flmt_c.check(event.group_id)
-                        and module not in ignore_rst_module
-                    ):
-                        _flmt_c.start_cd(event.group_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id, message="该功能在群聊中已被禁用..."
-                        )
-                except ActionFailed:
-                    pass
-                if event.is_tome():
-                    status_message_manager.add(event.group_id)
-                set_block_limit_false(event, module)
-                raise IgnoredException("该插件在群聊中已被禁用...")
-        else:
-            # 私聊禁用
-            if not plugins_manager.get_plugin_status(module, block_type="private"):
-                try:
-                    if _flmt_c.check(event.user_id):
-                        _flmt_c.start_cd(event.user_id)
-                        await bot.send_private_msg(
-                            user_id=event.user_id, message="该功能在私聊中已被禁用..."
-                        )
-                except ActionFailed:
-                    pass
-                if event.is_tome():
-                    status_message_manager.add(event.user_id)
-                set_block_limit_false(event, module)
-                raise IgnoredException("该插件在私聊中已被禁用...")
-        # 维护
-        if not plugins_manager.get_plugin_status(module, block_type="all"):
-            if isinstance(
-                event, GroupMessageEvent
-            ) and group_manager.check_group_is_white(event.group_id):
-                return
-            try:
-                if isinstance(event, GroupMessageEvent):
-                    if (
-                        _flmt_c.check(event.group_id)
-                        and module not in ignore_rst_module
-                    ):
-                        _flmt_c.start_cd(event.group_id)
-                        await bot.send_group_msg(
-                            group_id=event.group_id, message="此功能正在维护..."
-                        )
-                else:
-                    await bot.send_private_msg(
-                        user_id=event.user_id, message="此功能正在维护..."
-                    )
-            except ActionFailed:
-                pass
-            if event.is_tome():
-                id_ = (
-                    event.group_id
-                    if isinstance(event, GroupMessageEvent)
-                    else event.user_id
-                )
-                status_message_manager.add(id_)
-            set_block_limit_false(event, module)
-            raise IgnoredException("此功能正在维护...")
-
-    # 以下为限制检测 #######################################################
-    # 以下为限制检测 #######################################################
-    # 以下为限制检测 #######################################################
-    # 以下为限制检测 #######################################################
-    # 以下为限制检测 #######################################################
-    # 以下为限制检测 #######################################################
-    # Cd
-    if plugins2cd_manager.check_plugin_cd_status(module):
-        plugin_cd_data = plugins2cd_manager.get_plugin_cd_data(module)
-        check_type = plugin_cd_data["check_type"]
-        limit_type = plugin_cd_data["limit_type"]
-        rst = plugin_cd_data["rst"]
-        if (
-            (isinstance(event, PrivateMessageEvent) and check_type == "private")
-            or (isinstance(event, GroupMessageEvent) and check_type == "group")
-            or plugins2cd_manager.get_plugin_data(module).get("check_type") == "all"
-        ):
-            cd_type_ = event.user_id
-            if limit_type == "group" and isinstance(event, GroupMessageEvent):
-                cd_type_ = event.group_id
-            if not plugins2cd_manager.check(module, cd_type_):
-                if rst:
-                    rst = await init_rst(rst, event)
-                    await send_msg(rst, bot, event)
-                raise IgnoredException(f"{module} 正在cd中...")
-            else:
-                plugins2cd_manager.start_cd(module, cd_type_)
-    # Block
-    if plugins2block_manager.check_plugin_block_status(module):
-        plugin_block_data = plugins2block_manager.get_plugin_block_data(module)
-        check_type = plugin_block_data["check_type"]
-        limit_type = plugin_block_data["limit_type"]
-        rst = plugin_block_data["rst"]
-        if (
-            (isinstance(event, PrivateMessageEvent) and check_type == "private")
-            or (isinstance(event, GroupMessageEvent) and check_type == "group")
-            or check_type == "all"
-        ):
-            block_type_ = event.user_id
-            if limit_type == "group" and isinstance(event, GroupMessageEvent):
-                block_type_ = event.group_id
-            if plugins2block_manager.check(block_type_, module):
-                if rst:
-                    rst = await init_rst(rst, event)
-                    await send_msg(rst, bot, event)
-                raise IgnoredException(f"{event.user_id}正在调用{module}....")
-            else:
-                plugins2block_manager.set_true(block_type_, module)
-    # Count
-    if (
-        plugins2count_manager.check_plugin_count_status(module)
-        and event.user_id not in bot.config.superusers
-    ):
-        plugin_count_data = plugins2count_manager.get_plugin_count_data(module)
-        limit_type = plugin_count_data["limit_type"]
-        rst = plugin_count_data["rst"]
-        count_type_ = event.user_id
-        if limit_type == "group" and isinstance(event, GroupMessageEvent):
-            count_type_ = event.group_id
-        if not plugins2count_manager.check(module, count_type_):
-            if rst:
-                rst = await init_rst(rst, event)
-                await send_msg(rst, bot, event)
-            raise IgnoredException(f"{module} count次数限制...")
-        else:
-            plugins2count_manager.increase(module, count_type_)
-    # 功能花费的金币 #######################################
-    # 功能花费的金币 #######################################
-    if cost_gold:
-        await BagUser.spend_gold(event.user_id, event.group_id, cost_gold)
-
-
-async def send_msg(rst: str, bot: Bot, event: MessageEvent):
-    """
-    发送信息
-    :param rst: pass
-    :param bot: pass
-    :param event: pass
-    """
-    rst = await init_rst(rst, event)
-    try:
-        if isinstance(event, GroupMessageEvent):
-            status_message_manager.add(event.group_id)
-            await bot.send_group_msg(group_id=event.group_id, message=Message(rst))
-        else:
-            status_message_manager.add(event.user_id)
-            await bot.send_private_msg(user_id=event.user_id, message=Message(rst))
-    except ActionFailed:
-        pass
-
-
-# 解除命令block阻塞
-@run_postprocessor
-async def _(
-    matcher: Matcher,
-    exception: Optional[Exception],
-    bot: Bot,
-    event: Event,
-    state: T_State,
-):
-    if not isinstance(event, MessageEvent) and matcher.plugin_name != "poke":
-        return
-    module = matcher.plugin_name
-    set_block_limit_false(event, module)
-
-
-async def init_rst(rst: str, event: MessageEvent):
-    if "[uname]" in rst:
-        uname = event.sender.card or event.sender.nickname
-        rst = rst.replace("[uname]", uname)
-    if "[nickname]" in rst:
-        if isinstance(event, GroupMessageEvent):
-            nickname = await GroupInfoUser.get_group_member_nickname(
-                event.user_id, event.group_id
-            )
-        else:
-            nickname = await FriendUser.get_friend_nickname(event.user_id)
-        rst = rst.replace("[nickname]", nickname)
-    if "[at]" in rst and isinstance(event, GroupMessageEvent):
-        rst = rst.replace("[at]", str(at(event.user_id)))
-    return rst

basic_plugins/hooks/ban_hook.py

@@ -1,94 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, IgnoredException
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from nonebot.typing import T_State
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    Event,
-    MessageEvent,
-    PokeNotifyEvent,
-    GroupMessageEvent,
-)
-from configs.config import Config
-from models.ban_user import BanUser
-from utils.utils import is_number, static_flmt, FreqLimiter
-from utils.message_builder import at
-from ._utils import ignore_rst_module, other_limit_plugins
-
-
-Config.add_plugin_config(
-    "hook",
-    "BAN_RESULT",
-    "才不会给你发消息.",
-    help_="对被ban用户发送的消息",
-)
-
-_flmt = FreqLimiter(300)
-
-
-# 检查是否被ban
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: Event, state: T_State):
-    if (
-        (isinstance(event, MessageEvent) or isinstance(event, PokeNotifyEvent))
-        and matcher.priority not in [1, 9]
-    ) or matcher.plugin_name in other_limit_plugins:
-        try:
-            if (
-                await BanUser.is_super_ban(event.user_id)
-                and str(event.user_id) not in bot.config.superusers
-            ):
-                raise IgnoredException("用户处于超级黑名单中")
-        except AttributeError:
-            pass
-        if (
-            await BanUser.is_ban(event.user_id)
-            and str(event.user_id) not in bot.config.superusers
-        ):
-            time = await BanUser.check_ban_time(event.user_id)
-            if is_number(time):
-                time = abs(int(time))
-                if time < 60:
-                    time = str(time) + " 秒"
-                else:
-                    time = str(int(time / 60)) + " 分钟"
-            else:
-                time = str(time) + " 分钟"
-            if isinstance(event, GroupMessageEvent):
-                if not static_flmt.check(event.user_id):
-                    raise IgnoredException("用户处于黑名单中")
-                static_flmt.start_cd(event.user_id)
-                if matcher.priority != 9:
-                    try:
-                        ban_result = Config.get_config("hook", "BAN_RESULT")
-                        if (
-                            ban_result
-                            and _flmt.check(event.user_id)
-                            and matcher.plugin_name not in ignore_rst_module
-                        ):
-                            _flmt.start_cd(event.user_id)
-                            await bot.send_group_msg(
-                                group_id=event.group_id,
-                                message=at(event.user_id)
-                                + ban_result
-                                + f" 在..在 {time} 后才会理你喔",
-                            )
-                    except ActionFailed:
-                        pass
-            else:
-                if not static_flmt.check(event.user_id):
-                    raise IgnoredException("用户处于黑名单中")
-                static_flmt.start_cd(event.user_id)
-                if matcher.priority != 9:
-                    try:
-                        ban_result = Config.get_config("hook", "BAN_RESULT")
-                        if ban_result and matcher.plugin_name not in ignore_rst_module:
-                            await bot.send_private_msg(
-                                user_id=event.user_id,
-                                message=at(event.user_id)
-                                + ban_result
-                                + f" 在..在 {time}后才会理你喔",
-                            )
-                    except ActionFailed:
-                        pass
-            raise IgnoredException("用户处于黑名单中")

basic_plugins/hooks/chkdsk_hook.py

@@ -1,54 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, IgnoredException
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from nonebot.typing import T_State
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GroupMessageEvent,
-)
-from configs.config import Config
-from models.ban_user import BanUser
-from utils.utils import BanCheckLimiter
-from utils.message_builder import at
-from services.log import logger
-
-
-_blmt = BanCheckLimiter(
-    Config.get_config("hook", "MALICIOUS_CHECK_TIME"),
-    Config.get_config("hook", "MALICIOUS_BAN_COUNT"),
-)
-
-
-# 恶意触发命令检测
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: GroupMessageEvent, state: T_State):
-    if not isinstance(event, MessageEvent):
-        return
-    if matcher.type == "message" and matcher.priority not in [1, 9]:
-        if state["_prefix"]["raw_command"]:
-            if _blmt.check(f'{event.user_id}{state["_prefix"]["raw_command"]}'):
-                if await BanUser.ban(
-                    event.user_id,
-                    9,
-                    Config.get_config("hook", "MALICIOUS_BAN_TIME") * 60,
-                ):
-                    logger.info(f"USER {event.user_id} 触发了恶意触发检测")
-                if isinstance(event, GroupMessageEvent):
-                    try:
-                        await bot.send_group_msg(
-                            group_id=event.group_id,
-                            message=at(event.user_id) + "检测到恶意触发命令，您将被封禁 30 分钟",
-                        )
-                    except ActionFailed:
-                        pass
-                else:
-                    try:
-                        await bot.send_private_msg(
-                            user_id=event.user_id,
-                            message=at(event.user_id) + "检测到恶意触发命令，您将被封禁 30 分钟",
-                        )
-                    except ActionFailed:
-                        pass
-                raise IgnoredException("检测到恶意触发命令")
-        _blmt.add(f'{event.user_id}{state["_prefix"]["raw_command"]}')

basic_plugins/hooks/other_hook.py

@@ -1,51 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, IgnoredException
-from nonebot.typing import T_State
-from ._utils import status_message_manager
-from utils.image_utils import text2image
-from typing import Dict, Any
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    PrivateMessageEvent,
-    GroupMessageEvent,
-)
-import re
-
-
-# 为什么AI会自己和自己聊天
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: PrivateMessageEvent, state: T_State):
-    if not isinstance(event, MessageEvent):
-        return
-    if event.user_id == int(bot.self_id):
-        raise IgnoredException("为什么AI会自己和自己聊天")
-
-
-# 有命令就别说话了
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
-    if not isinstance(event, MessageEvent):
-        return
-    if matcher.type == "message" and matcher.plugin_name == "ai":
-        if (
-            isinstance(event, GroupMessageEvent)
-            and not status_message_manager.check(event.group_id)
-        ):
-            status_message_manager.delete(event.group_id)
-            raise IgnoredException("有命令就别说话了")
-        elif (
-            isinstance(event, PrivateMessageEvent)
-            and not status_message_manager.check(event.user_id)
-        ):
-            status_message_manager.delete(event.user_id)
-            raise IgnoredException("有命令就别说话了")
-
-# @Bot.on_calling_api
-# async def handle_api_call(bot: Bot, api: str, data: Dict[str, Any]):
-#     if api in ["send_msg", "send_group_msg", "send_private_msg"]:
-#         msg = str(data["message"])
-#         if (r := re.search("\[\[To_Img\|?(.*?)]]", msg)) or (r := re.search("[[To_Img\|?(.*?)[[")):
-
-
-

basic_plugins/hooks/task_hook.py

@@ -1,47 +0,0 @@
-from nonebot.exception import MockApiException
-from nonebot.adapters.onebot.v11 import Bot, Message
-from utils.manager import group_manager
-from typing import Dict, Any
-import re
-
-
-@Bot.on_calling_api
-async def handle_api_call(bot: Bot, api: str, data: Dict[str, Any]):
-    r = None
-    if (
-        (
-            (api == "send_msg" and data.get("message_type") == "group")
-            or api == "send_group_msg"
-        )
-        and (
-            (
-                r := re.search(
-                    "^\[\[_task\|(.*)]]",
-                    data["message"].strip()
-                    if isinstance(data["message"], str)
-                    else str(data["message"]["text"]).strip(),
-                )
-            )
-            or (
-                r := re.search(
-                    "^[[_task\|(.*)]]",
-                    data["message"].strip()
-                    if isinstance(data["message"], str)
-                    else str(data["message"]["text"]).strip(),
-                )
-            )
-        )
-        and r.group(1) in group_manager.get_task_data().keys()
-    ):
-        task = r.group(1)
-        group_id = data["group_id"]
-        if group_manager.get_group_level(
-            group_id
-        ) < 0 or not await group_manager.check_group_task_status(group_id, task):
-            raise MockApiException(f"被动技能 {task} 处于关闭状态...")
-        else:
-            msg = str(data["message"]).strip()
-            msg = msg.replace(f"&#91;&#91;_task|{task}&#93;&#93;", "").replace(
-                f"[[_task|{task}]]", ""
-            )
-            data["message"] = Message(msg)

basic_plugins/hooks/withdraw_message_hook.py

@@ -1,28 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_postprocessor
-from typing import Optional
-from nonebot.typing import T_State
-from nonebot.adapters.onebot.v11 import Bot, Event
-from utils.manager import withdraw_message_manager
-import asyncio
-
-
-# 消息撤回
-@run_postprocessor
-async def _(
-    matcher: Matcher,
-    exception: Optional[Exception],
-    bot: Bot,
-    event: Event,
-    state: T_State,
-):
-    tasks = []
-    for id_, time in withdraw_message_manager.data:
-        tasks.append(asyncio.ensure_future(_withdraw_message(bot, id_, time)))
-        withdraw_message_manager.remove((id_, time))
-    await asyncio.gather(*tasks)
-
-
-async def _withdraw_message(bot: Bot, id_: int, time: int):
-    await asyncio.sleep(time)
-    await bot.delete_msg(message_id=id_)

basic_plugins/init_plugin_config/__init__.py

@@ -1,60 +0,0 @@
-from .init_group_manager import init_group_manager, group_manager
-from .init_plugins_config import init_plugins_config
-from .init_plugins_data import init_plugins_data, plugins_manager
-from .init_none_plugin_count_manager import init_none_plugin_count_manager
-from .init_plugins_resources import init_plugins_resources
-from .init_plugins_settings import init_plugins_settings
-from .init_plugins_limit import (
-    init_plugins_block_limit,
-    init_plugins_count_limit,
-    init_plugins_cd_limit,
-)
-from .init import init
-from .check_plugin_status import check_plugin_status
-from nonebot.adapters.onebot.v11 import Bot
-from configs.path_config import DATA_PATH
-from services.log import logger
-from pathlib import Path
-from nonebot import Driver
-import nonebot
-
-
-__zx_plugin_name__ = "初始化插件数据 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-driver: Driver = nonebot.get_driver()
-
-
-@driver.on_startup
-def _():
-    """
-    初始化数据
-    """
-    _flag = False
-    config_file = DATA_PATH / "configs" / "plugins2config.yaml"
-    if not config_file.exists():
-        _flag = True
-    init()
-    init_plugins_settings(DATA_PATH)
-    init_plugins_cd_limit(DATA_PATH)
-    init_plugins_block_limit(DATA_PATH)
-    init_plugins_count_limit(DATA_PATH)
-    init_plugins_data(DATA_PATH)
-    init_plugins_config(DATA_PATH)
-    init_plugins_resources()
-    init_none_plugin_count_manager()
-    x = group_manager.get_super_old_data()
-    if x:
-        for key in x.keys():
-            plugins_manager.block_plugin(key, block_type=x[key])
-    if _flag:
-        raise Exception("首次运行，已在configs目录下生成配置文件config.yaml，修改后重启即可...")
-    logger.info("初始化数据完成...")
-
-
-@driver.on_bot_connect
-async def _(bot: Bot):
-    await init_group_manager()
-    await check_plugin_status(bot)

basic_plugins/init_plugin_config/check_plugin_status.py

@@ -1,18 +0,0 @@
-from utils.manager import plugins_manager
-from nonebot.adapters.onebot.v11 import Bot
-
-
-async def check_plugin_status(bot: Bot):
-    """
-    遍历查看插件加载情况
-    """
-    rst = ""
-    for plugin in plugins_manager.keys():
-        data = plugins_manager.get(plugin)
-        if data.get("error") or data.get("error") is None:
-            rst += f'{plugin}:{data["plugin_name"]}\n'
-    if rst:
-        rst = "以下插件加载失败..\n" + rst
-        await bot.send_private_msg(
-            user_id=int(list(bot.config.superusers)[0]), message=rst[:-1]
-        )

basic_plugins/init_plugin_config/init.py

@@ -1,14 +0,0 @@
-from utils.manager import plugins2settings_manager
-
-
-def init():
-    if plugins2settings_manager.get("update_pic"):
-        plugins2settings_manager["update_picture"] = plugins2settings_manager["update_pic"]
-        plugins2settings_manager.delete("update_pic")
-    if plugins2settings_manager.get("white2black_img"):
-        plugins2settings_manager["white2black_image"] = plugins2settings_manager["white2black_img"]
-        plugins2settings_manager.delete("white2black_img")
-    if plugins2settings_manager.get("send_img"):
-        plugins2settings_manager["send_image"] = plugins2settings_manager["send_img"]
-        plugins2settings_manager.delete("send_img")
-

basic_plugins/init_plugin_config/init_group_manager.py

@@ -1,73 +0,0 @@
-from pathlib import Path
-from utils.manager import group_manager
-from services.db_context import db
-from asyncpg.exceptions import DuplicateColumnError
-from services.log import logger
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-try:
-    from models.group_remind import GroupRemind
-except ModuleNotFoundError:
-    pass
-
-
-async def init_group_manager():
-    """
-    旧数据格式替换为新格式
-    初始化数据
-    """
-    old_group_level_file = Path() / "data" / "manager" / "group_level.json"
-    old_plugin_list_file = Path() / "data" / "manager" / "plugin_list.json"
-    if old_group_level_file.exists():
-        data = json.load(open(old_group_level_file, "r", encoding="utf8"))
-        for key in data.keys():
-            group = key
-            level = data[key]
-            group_manager.set_group_level(group, level)
-        old_group_level_file.unlink()
-        group_manager.save()
-
-    if old_plugin_list_file.exists():
-        data = json.load(open(old_plugin_list_file, "r", encoding="utf8"))
-        for plugin in data.keys():
-            for group in data[plugin].keys():
-                if group == "default" and not data[plugin]["default"]:
-                    group_manager.block_plugin(plugin)
-                elif not data[plugin][group]:
-                    group_manager.block_plugin(plugin, group)
-        old_plugin_list_file.unlink()
-    old_data_table = Path() / "models" / "group_remind.py"
-    try:
-        if old_data_table.exists():
-            b = {
-                "hy": "group_welcome",
-                "kxcz": "open_case_reset_remind",
-                "zwa": "zwa",
-                "blpar": "bilibili_parse",
-                "epic": "epic_free_game",
-                "pa": "pa",
-                "almanac": "genshin_alc",
-            }
-            for group in group_manager.get_data()["group_manager"]:
-                for remind in b:
-                    try:
-                        status = await GroupRemind.get_status(int(group), remind)
-                        if status is not None:
-                            if status:
-                                await group_manager.open_group_task(group, b[remind])
-                                logger.info(f"读取旧数据-->{group} 开启 {b[remind]}")
-                            else:
-                                await group_manager.close_group_task(group, b[remind])
-                                logger.info(f"读取旧数据-->{group} 关闭 {b[remind]}")
-                    except Exception as e:
-                        pass
-            query = db.text("DROP TABLE group_reminds;")
-            await db.first(query)
-            old_data_table.unlink()
-            logger.info("旧数据读取完毕，删除了舍弃表 group_reminds...")
-    except (ModuleNotFoundError, DuplicateColumnError):
-        pass
-    group_manager.save()

basic_plugins/init_plugin_config/init_none_plugin_count_manager.py

@@ -1,45 +0,0 @@
-from utils.manager import (
-    none_plugin_count_manager,
-    plugins2count_manager,
-    plugins2cd_manager,
-    plugins2settings_manager,
-    plugins2block_manager,
-    plugins_manager,
-    resources_manager
-)
-from services.log import logger
-from utils.utils import get_matchers
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-def init_none_plugin_count_manager():
-    """
-    清除已删除插件数据
-    """
-    modules = [x.module for x in get_matchers()]
-    for module in none_plugin_count_manager.keys():
-        if module not in modules:
-            none_plugin_count_manager.add_count(module)
-        else:
-            none_plugin_count_manager.reset(module)
-        if none_plugin_count_manager.check(module):
-            try:
-                plugin_name = plugins_manager.get(module)["plugin_name"]
-            except (AttributeError, KeyError):
-                plugin_name = ""
-            try:
-                plugins2settings_manager.delete(module)
-                plugins2count_manager.delete(module)
-                plugins2cd_manager.delete(module)
-                plugins2block_manager.delete(module)
-                plugins_manager.delete(module)
-                resources_manager.remove_resource(module)
-                logger.info(f"{module}:{plugin_name} 插件疑似已删除，清除对应插件数据...")
-            except Exception as e:
-                logger.error(
-                    f"{module}:{plugin_name} 插件疑似已删除，清除对应插件数据失败...{type(e)}：{e}"
-                )

basic_plugins/init_plugin_config/init_plugins_config.py

@@ -1,153 +0,0 @@
-from pathlib import Path
-from ruamel.yaml import round_trip_load, round_trip_dump, YAML
-from utils.manager import admin_manager, plugins_manager
-from configs.config import Config
-from services.log import logger
-from utils.utils import get_matchers
-from ruamel import yaml
-import nonebot
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_config(data_path):
-    """
-    初始化插件数据配置
-    """
-    plugins2config_file = data_path / "configs" / "plugins2config.yaml"
-    plugins2config_file.parent.mkdir(parents=True, exist_ok=True)
-    _data = {}
-    if plugins2config_file.exists():
-        _data = _yaml.load(open(plugins2config_file, "r", encoding="utf8"))
-    _matchers = get_matchers()
-    for matcher in _matchers:
-        _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-        try:
-            _module = _plugin.module
-        except AttributeError:
-            continue
-        try:
-            plugin_version = _module.__getattribute__("__plugin_version__")
-        except AttributeError:
-            plugin_version = None
-        try:
-            plugin_configs = _module.__getattribute__("__plugin_configs__")
-        except AttributeError:
-            continue
-        # 插件配置版本更新或为Version为None或不在存储配置内
-        if (
-            plugin_version is None
-            or (
-                _data.get(matcher.plugin_name)
-                and _data[matcher.plugin_name].keys() != plugin_configs.keys()
-            )
-            or plugin_version > plugins_manager.get(matcher.plugin_name)["version"]
-            or matcher.plugin_name not in _data.keys()
-        ):
-            for key in plugin_configs:
-                if isinstance(plugin_configs[key], dict):
-                    Config.add_plugin_config(
-                        matcher.plugin_name,
-                        key,
-                        plugin_configs[key].get("value"),
-                        help_=plugin_configs[key].get("help"),
-                        default_value=plugin_configs[key].get("default_value"),
-                        _override=True,
-                    )
-                else:
-                    Config.add_plugin_config(matcher.plugin_name, key, plugin_configs[key])
-        else:
-            plugin_configs = _data[matcher.plugin_name]
-            for key in plugin_configs:
-                Config.add_plugin_config(
-                    matcher.plugin_name,
-                    key,
-                    plugin_configs[key]["value"],
-                    help_=plugin_configs[key]["help"],
-                    default_value=plugin_configs[key]["default_value"],
-                    _override=True,
-                )
-    if not Config.is_empty():
-        Config.save()
-        _data = round_trip_load(open(plugins2config_file, encoding="utf8"))
-        for plugin in _data.keys():
-            try:
-                plugin_name = plugins_manager.get(plugin)["plugin_name"]
-            except (AttributeError, TypeError):
-                plugin_name = plugin
-            _data[plugin].yaml_set_start_comment(plugin_name, indent=2)
-        # 初始化未设置的管理员权限等级
-        for k, v in Config.get_admin_level_data():
-            admin_manager.set_admin_level(k, v)
-        # 存完插件基本设置
-        with open(plugins2config_file, "w", encoding="utf8") as wf:
-            round_trip_dump(
-                _data, wf, indent=2, Dumper=yaml.RoundTripDumper, allow_unicode=True
-            )
-        # 再开始读取用户配置
-        user_config_file = Path() / "configs" / "config.yaml"
-        _data = {}
-        _tmp_data = {}
-        if user_config_file.exists():
-            with open(user_config_file, "r", encoding="utf8") as f:
-                _data = _yaml.load(f)
-        # 数据替换
-        for plugin in Config.keys():
-            _tmp_data[plugin] = {}
-            for k in Config[plugin].keys():
-                if _data.get(plugin) and k in _data[plugin].keys():
-                    Config.set_config(plugin, k, _data[plugin][k])
-                    if level2module := Config.get_level2module(plugin, k):
-                        try:
-                            admin_manager.set_admin_level(level2module, _data[plugin][k])
-                        except KeyError:
-                            logger.warning(f"{level2module} 设置权限等级失败：{_data[plugin][k]}")
-                _tmp_data[plugin][k] = Config.get_config(plugin, k)
-        Config.save()
-        temp_file = Path() / "configs" / "temp_config.yaml"
-        try:
-            with open(temp_file, "w", encoding="utf8") as wf:
-                yaml.dump(
-                    _tmp_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True
-                )
-            with open(temp_file, "r", encoding="utf8") as rf:
-                _data = round_trip_load(rf)
-            # 添加注释
-            for plugin in _data.keys():
-                rst = ""
-                plugin_name = None
-                try:
-                    plugin_data = Config.get(plugin)
-                    for x in list(Config.get(plugin).keys()):
-                        try:
-                            _x = plugin_data[x].get("name")
-                            if _x:
-                                plugin_name = _x
-                        except AttributeError:
-                            pass
-                except (KeyError, AttributeError):
-                    plugin_name = None
-                if not plugin_name:
-                    try:
-                        plugin_name = plugins_manager.get(plugin)["plugin_name"]
-                    except (AttributeError, TypeError):
-                        plugin_name = plugin
-                plugin_name = (
-                    plugin_name.replace("[Hidden]", "")
-                    .replace("[Superuser]", "")
-                    .replace("[Admin]", "")
-                    .strip()
-                )
-                rst += plugin_name + "\n"
-                for k in _data[plugin].keys():
-                    rst += f'{k}: {Config[plugin][k]["help"]}' + "\n"
-                _data[plugin].yaml_set_start_comment(rst[:-1], indent=2)
-            with open(Path() / "configs" / "config.yaml", "w", encoding="utf8") as wf:
-                round_trip_dump(
-                    _data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True
-                )
-        except Exception as e:
-            logger.error(f"生成简易配置注释错误 {type(e)}：{e}")
-        if temp_file.exists():
-            temp_file.unlink()

basic_plugins/init_plugin_config/init_plugins_data.py

@@ -1,82 +0,0 @@
-from pathlib import Path
-from ruamel.yaml import YAML
-from utils.manager import plugins_manager
-from utils.utils import get_matchers
-import nonebot
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_data(data_path):
-    """
-    初始化插件数据信息
-    """
-    plugin2data_file = data_path / "manager" / "plugin_manager.json"
-    plugin2data_file.parent.mkdir(parents=True, exist_ok=True)
-    _data = {}
-    if plugin2data_file.exists():
-        _data = json.load(open(plugin2data_file, "r", encoding="utf8"))
-    _matchers = get_matchers()
-    for matcher in _matchers:
-        _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-        try:
-            _module = _plugin.module
-        except AttributeError:
-            if matcher.plugin_name not in _data.keys():
-                plugins_manager.add_plugin_data(
-                    matcher.plugin_name, matcher.plugin_name, error=True
-                )
-            else:
-                plugins_manager.set_module_data(matcher.plugin_name, "error", True)
-                plugin_data = plugins_manager.get(matcher.plugin_name)
-                if plugin_data:
-                    plugins_manager.set_module_data(
-                        matcher.plugin_name, "version", plugin_data.get("version")
-                    )
-        else:
-            try:
-                plugin_version = _module.__getattribute__("__plugin_version__")
-            except AttributeError:
-                plugin_version = None
-            try:
-                plugin_name = _module.__getattribute__("__zx_plugin_name__")
-            except AttributeError:
-                plugin_name = matcher.plugin_name
-            try:
-                plugin_author = _module.__getattribute__("__plugin_author__")
-            except AttributeError:
-                plugin_author = None
-            if matcher.plugin_name in plugins_manager.keys():
-                plugins_manager.set_module_data(matcher.plugin_name, "error", False)
-            if matcher.plugin_name not in plugins_manager.keys():
-                plugins_manager.add_plugin_data(
-                    matcher.plugin_name,
-                    plugin_name=plugin_name,
-                    author=plugin_author,
-                    version=plugin_version,
-                )
-            elif plugins_manager[matcher.plugin_name]["version"] is None or (
-                plugin_version is not None
-                and plugin_version > plugins_manager[matcher.plugin_name]["version"]
-            ):
-                plugins_manager.set_module_data(
-                    matcher.plugin_name, "plugin_name", plugin_name
-                )
-                plugins_manager.set_module_data(matcher.plugin_name, "author", plugin_author)
-                plugins_manager.set_module_data(
-                    matcher.plugin_name, "version", plugin_version
-                )
-            if matcher.plugin_name in _data.keys():
-                plugins_manager.set_module_data(
-                    matcher.plugin_name, "error", _data[matcher.plugin_name]["error"]
-                )
-                plugins_manager.set_module_data(
-                    matcher.plugin_name, "plugin_name", _data[matcher.plugin_name]["plugin_name"]
-                )
-    plugins_manager.save()

basic_plugins/init_plugin_config/init_plugins_limit.py

@@ -1,157 +0,0 @@
-from pathlib import Path
-from ruamel.yaml import round_trip_load, round_trip_dump, YAML
-from utils.manager import (
-    plugins2cd_manager,
-    plugins2block_manager,
-    plugins2count_manager,
-)
-from utils.utils import get_matchers
-from ruamel import yaml
-import nonebot
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_cd_limit(data_path):
-    """
-    加载 cd 限制
-    """
-    plugins2cd_file = data_path / "configs" / "plugins2cd.yaml"
-    plugins2cd_file.parent.mkdir(exist_ok=True, parents=True)
-    _data = {}
-    _matchers = get_matchers()
-    for matcher in _matchers:
-        if not plugins2cd_manager.get_plugin_cd_data(matcher.plugin_name):
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            try:
-                _module = _plugin.module
-                plugin_cd_limit = _module.__getattribute__("__plugin_cd_limit__")
-                plugins2cd_manager.add_cd_limit(
-                    matcher.plugin_name, data_dict=plugin_cd_limit
-                )
-            except AttributeError:
-                pass
-    if not plugins2cd_manager.keys():
-        plugins2cd_manager.add_cd_limit(
-            "这是一个示例"
-        )
-    _tmp_data = {"PluginCdLimit": plugins2cd_manager.get_data()}
-    with open(plugins2cd_file, "w", encoding="utf8") as wf:
-        yaml.dump(_tmp_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    _data = round_trip_load(open(plugins2cd_file, encoding="utf8"))
-    _data["PluginCdLimit"].yaml_set_start_comment(
-        """# 需要cd的功能
-# 自定义的功能需要cd也可以在此配置
-# key：模块名称
-# cd：cd 时长（秒）
-# status：此限制的开关状态
-# check_type：'private'/'group'/'all'，限制私聊/群聊/全部
-# limit_type：监听对象，以user_id或group_id作为键来限制，'user'：用户id，'group'：群id
-#                                     示例：'user'：用户N秒内触发1次，'group'：群N秒内触发1次
-# rst：回复的话，可以添加[at]，[uname]，[nickname]来对应艾特，用户群名称，昵称系统昵称
-# rst 为 "" 或 None 时则不回复
-# rst示例："[uname]你冲的太快了，[nickname]先生，请稍后再冲[at]"
-# rst回复："老色批你冲的太快了，欧尼酱先生，请稍后再冲@老色批"
-#      用户昵称↑     昵称系统的昵称↑          艾特用户↑""",
-        indent=2,
-    )
-    with open(plugins2cd_file, "w", encoding="utf8") as wf:
-        round_trip_dump(_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    plugins2cd_manager.reload_cd_limit()
-
-
-def init_plugins_block_limit(data_path):
-    """
-    加载阻塞限制
-    """
-    plugins2block_file = data_path / "configs" / "plugins2block.yaml"
-    plugins2block_file.parent.mkdir(exist_ok=True, parents=True)
-    _data = {}
-    _matchers = get_matchers()
-    for matcher in _matchers:
-        if not plugins2block_manager.get_plugin_block_data(matcher.plugin_name):
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            try:
-                _module = _plugin.module
-                plugin_block_limit = _module.__getattribute__("__plugin_block_limit__")
-                plugins2block_manager.add_block_limit(
-                    matcher.plugin_name, data_dict=plugin_block_limit
-                )
-            except AttributeError:
-                pass
-    if not plugins2block_manager.keys():
-        plugins2block_manager.add_block_limit(
-            "这是一个示例"
-        )
-    _tmp_data = {"PluginBlockLimit": plugins2block_manager.get_data()}
-    with open(plugins2block_file, "w", encoding="utf8") as wf:
-        yaml.dump(_tmp_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    _data = round_trip_load(open(plugins2block_file, encoding="utf8"))
-    _data["PluginBlockLimit"].yaml_set_start_comment(
-        """# 用户调用阻塞
-# 即 当用户调用此功能还未结束时
-# 用发送消息阻止用户重复调用此命令直到该命令结束
-# key：模块名称
-# status：此限制的开关状态
-# check_type：'private'/'group'/'all'，限制私聊/群聊/全部
-# limit_type：监听对象，以user_id或group_id作为键来限制，'user'：用户id，'group'：群id
-#                                     示例：'user'：阻塞用户，'group'：阻塞群聊
-# rst：回复的话，可以添加[at]，[uname]，[nickname]来对应艾特，用户群名称，昵称系统昵称
-# rst 为 "" 或 None 时则不回复
-# rst示例："[uname]你冲的太快了，[nickname]先生，请稍后再冲[at]"
-# rst回复："老色批你冲的太快了，欧尼酱先生，请稍后再冲@老色批"
-#      用户昵称↑     昵称系统的昵称↑          艾特用户↑""",
-        indent=2,
-    )
-    with open(plugins2block_file, "w", encoding="utf8") as wf:
-        round_trip_dump(_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    plugins2block_manager.reload_block_limit()
-
-
-def init_plugins_count_limit(data_path):
-    """
-    加载次数限制
-    """
-    plugins2count_file = data_path / "configs" / "plugins2count.yaml"
-    plugins2count_file.parent.mkdir(exist_ok=True, parents=True)
-    _data = {}
-    _matchers = get_matchers()
-    for matcher in _matchers:
-        if not plugins2count_manager.get_plugin_count_data(matcher.plugin_name):
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            try:
-                _module = _plugin.module
-                plugin_count_limit = _module.__getattribute__("__plugin_count_limit__")
-                plugins2count_manager.add_count_limit(
-                    matcher.plugin_name, data_dict=plugin_count_limit
-                )
-            except AttributeError:
-                pass
-    if not plugins2count_manager.keys():
-        plugins2count_manager.add_count_limit(
-            "这是一个示例"
-        )
-    _tmp_data = {"PluginCountLimit": plugins2count_manager.get_data()}
-    with open(plugins2count_file, "w", encoding="utf8") as wf:
-        yaml.dump(_tmp_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    _data = round_trip_load(open(plugins2count_file, encoding="utf8"))
-    _data["PluginCountLimit"].yaml_set_start_comment(
-        """# 命令每日次数限制
-# 即 用户/群聊 每日可调用命令的次数 [数据内存存储，重启将会重置]
-# 每日调用直到 00:00 刷新
-# key：模块名称
-# max_count: 每日调用上限
-# status：此限制的开关状态
-# limit_type：监听对象，以user_id或group_id作为键来限制，'user'：用户id，'group'：群id
-#                                     示例：'user'：用户上限，'group'：群聊上限
-# rst：回复的话，可以添加[at]，[uname]，[nickname]来对应艾特，用户群名称，昵称系统昵称
-# rst 为 "" 或 None 时则不回复
-# rst示例："[uname]你冲的太快了，[nickname]先生，请稍后再冲[at]"
-# rst回复："老色批你冲的太快了，欧尼酱先生，请稍后再冲@老色批"
-#      用户昵称↑     昵称系统的昵称↑          艾特用户↑""",
-        indent=2,
-    )
-    with open(plugins2count_file, "w", encoding="utf8") as wf:
-        round_trip_dump(_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    plugins2count_manager.reload_count_limit()

basic_plugins/init_plugin_config/init_plugins_resources.py

@@ -1,43 +0,0 @@
-from utils.manager import resources_manager
-from utils.utils import get_matchers
-from services.log import logger
-from pathlib import Path
-import nonebot
-
-
-def init_plugins_resources():
-    """
-    资源文件路径的移动
-    """
-    _tmp = []
-    for matcher in get_matchers():
-        if matcher.plugin_name not in _tmp:
-            _tmp.append(matcher.plugin_name)
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            try:
-                _module = _plugin.module
-            except AttributeError:
-                logger.warning(f"插件 {matcher.plugin_name} 加载失败...，资源控制未加载...")
-            else:
-                try:
-                    resources = _module.__getattribute__("__plugin_resources__")
-                except AttributeError:
-                    pass
-                else:
-                    path = Path(_module.__getattribute__("__file__")).parent
-                    for resource in resources.keys():
-                        resources_manager.add_resource(matcher.plugin_name, path / resource, resources[resource])
-    resources_manager.save()
-    resources_manager.start_move()
-
-
-
-
-
-
-
-
-
-
-
-

basic_plugins/init_plugin_config/init_plugins_settings.py

@@ -1,128 +0,0 @@
-from pathlib import Path
-from ruamel.yaml import round_trip_load, round_trip_dump, YAML
-from utils.manager import plugins2settings_manager, admin_manager
-from services.log import logger
-from utils.utils import get_matchers
-from ruamel import yaml
-import nonebot
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_settings(data_path: str):
-    """
-    初始化插件设置，从插件中获取 __zx_plugin_name__，__plugin_cmd__，__plugin_settings__
-    """
-    plugins2settings_file = data_path / "configs" / "plugins2settings.yaml"
-    plugins2settings_file.parent.mkdir(exist_ok=True, parents=True)
-    _matchers = get_matchers()
-    _tmp_module = {}
-    _tmp = []
-    for x in plugins2settings_manager.keys():
-        try:
-            _plugin = nonebot.plugin.get_plugin(x)
-            _module = _plugin.module
-            plugin_name = _module.__getattribute__("__zx_plugin_name__")
-            _tmp_module[x] = plugin_name
-        except (KeyError, AttributeError) as e:
-            logger.warning(f"配置文件 模块：{x} 获取 plugin_name 失败...{e}")
-            _tmp_module[x] = ""
-    for matcher in _matchers:
-        if matcher.plugin_name not in plugins2settings_manager.keys():
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            try:
-                _module = _plugin.module
-            except AttributeError:
-                logger.warning(f"插件 {matcher.plugin_name} 加载失败...，插件控制未加载.")
-            else:
-                try:
-                    plugin_name = _module.__getattribute__("__zx_plugin_name__")
-                    if "[admin]" in plugin_name.lower():
-                        try:
-                            admin_settings = _module.__getattribute__(
-                                "__plugin_settings__"
-                            )
-                            level = admin_settings["admin_level"]
-                            cmd = admin_settings.get("cmd")
-                        except (AttributeError, KeyError):
-                            level = 5
-                            cmd = None
-                        if level is None:
-                            level = 5
-                        admin_manager.add_admin_plugin_settings(
-                            matcher.plugin_name, cmd, level
-                        )
-                    if (
-                        "[hidden]" in plugin_name.lower()
-                        or "[admin]" in plugin_name.lower()
-                        or "[superuser]" in plugin_name.lower()
-                        or matcher.plugin_name in plugins2settings_manager.keys()
-                    ):
-                        continue
-                except AttributeError:
-                    if matcher.plugin_name not in _tmp:
-                        logger.warning(
-                            f"获取插件 {matcher.plugin_name} __zx_plugin_name__ 失败...，插件控制未加载."
-                        )
-                else:
-                    try:
-                        _tmp_module[matcher.plugin_name] = plugin_name
-                        plugin_settings = _module.__getattribute__(
-                            "__plugin_settings__"
-                        )
-                        if plugin_settings.get('cost_gold') is None:
-                            plugin_settings['cost_gold'] = 0
-                        if (
-                            plugin_settings.get("cmd") is not None
-                            and plugin_name not in plugin_settings["cmd"]
-                        ):
-                            plugin_settings["cmd"].append(plugin_name)
-                        if plugins2settings_manager.get(
-                            matcher.plugin_name
-                        ) and plugins2settings_manager[matcher.plugin_name].get(
-                            "plugin_type"
-                        ):
-                            plugin_type = tuple(
-                                plugins2settings_manager.get_plugin_data(
-                                    matcher.plugin_name
-                                )["plugin_type"]
-                            )
-                        else:
-                            try:
-                                plugin_type = _module.__getattribute__(
-                                    "__plugin_type__"
-                                )
-                            except AttributeError:
-                                plugin_type = ("normal",)
-                        if plugin_settings and matcher.plugin_name:
-                            plugins2settings_manager.add_plugin_settings(
-                                matcher.plugin_name,
-                                plugin_type=plugin_type,
-                                **plugin_settings,
-                            )
-                    except AttributeError:
-                        pass
-        _tmp.append(matcher.plugin_name)
-    _tmp_data = {"PluginSettings": plugins2settings_manager.get_data()}
-    with open(plugins2settings_file, "w", encoding="utf8") as wf:
-        yaml.dump(_tmp_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    _data = round_trip_load(open(plugins2settings_file, encoding="utf8"))
-    _data["PluginSettings"].yaml_set_start_comment(
-        """# 模块与对应命令和对应群权限
-# 用于生成帮助图片 和 开关功能
-# key：模块名称
-# level：需要的群等级
-# default_status：加入群时功能的默认开关状态
-# limit_superuser: 功能状态是否限制超级用户
-# cmd: 关闭[cmd] 都会触发命令 关闭对应功能，cmd列表第一个词为统计的功能名称
-# plugin_type: 帮助类别 示例：('原神相关',) 或 ('原神相关', 1)，1代表帮助命令列向排列，否则为横向排列""",
-        indent=2,
-    )
-    for plugin in _data["PluginSettings"].keys():
-        _data["PluginSettings"][plugin].yaml_set_start_comment(
-            f"{plugin}：{_tmp_module[plugin]}", indent=2
-        )
-    with open(plugins2settings_file, "w", encoding="utf8") as wf:
-        round_trip_dump(_data, wf, Dumper=yaml.RoundTripDumper, allow_unicode=True)
-    logger.info(f"已成功加载 {len(plugins2settings_manager.get_data())} 个非限制插件.")

basic_plugins/invite_manager/__init__.py

@@ -1,149 +0,0 @@
-from nonebot import on_request, on_message
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    FriendRequestEvent,
-    GroupRequestEvent,
-    MessageEvent,
-)
-from models.friend_user import FriendUser
-from datetime import datetime
-from configs.config import NICKNAME, Config
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from utils.manager import requests_manager
-from models.group_info import GroupInfo
-from utils.utils import scheduler
-import asyncio
-import time
-import re
-
-__zx_plugin_name__ = "好友群聊处理请求 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_configs__ = {
-    "AUTO_ADD_FRIEND": {"value": False, "help": "是否自动同意好友添加", "default_value": False}
-}
-
-friend_req = on_request(priority=5, block=True)
-group_req = on_request(priority=5, block=True)
-x = on_message(priority=9, block=False)
-
-exists_data = {"private": {}, "group": {}}
-
-
-@friend_req.handle()
-async def _(bot: Bot, event: FriendRequestEvent):
-    global exists_data
-    if exists_data["private"].get(event.user_id):
-        if time.time() - exists_data["private"][event.user_id] < 60 * 5:
-            return
-    exists_data["private"][event.user_id] = time.time()
-    user = await bot.get_stranger_info(user_id=event.user_id)
-    nickname = user["nickname"]
-    sex = user["sex"]
-    age = str(user["age"])
-    comment = event.comment
-    await bot.send_private_msg(
-        user_id=int(list(bot.config.superusers)[0]),
-        message=f"*****一份好友申请*****\n"
-        f"昵称：{nickname}({event.user_id})\n"
-        f"自动同意：{'√' if Config.get_config('invite_manager', 'AUTO_ADD_FRIEND') else '×'}\n"
-        f"日期：{str(datetime.now()).split('.')[0]}\n"
-        f"备注：{event.comment}",
-    )
-    if Config.get_config("invite_manager", "AUTO_ADD_FRIEND"):
-        await bot.set_friend_add_request(flag=event.flag, approve=True)
-        await FriendUser.add_friend_info(user["user_id"], user["nickname"])
-    else:
-        requests_manager.add_request(
-            event.user_id,
-            "private",
-            event.flag,
-            nickname=nickname,
-            sex=sex,
-            age=age,
-            comment=comment,
-        )
-
-
-@group_req.handle()
-async def _(bot: Bot, event: GroupRequestEvent):
-    global exists_data
-    if event.sub_type == "invite":
-        if str(event.user_id) in bot.config.superusers:
-            try:
-                if await GroupInfo.get_group_info(event.group_id):
-                    await GroupInfo.set_group_flag(event.group_id, 1)
-                else:
-                    group_info = await bot.get_group_info(group_id=event.group_id)
-                    await GroupInfo.add_group_info(
-                        group_info["group_id"],
-                        group_info["group_name"],
-                        group_info["max_member_count"],
-                        group_info["member_count"],
-                        1,
-                    )
-                await bot.set_group_add_request(
-                    flag=event.flag, sub_type="invite", approve=True
-                )
-            except ActionFailed:
-                pass
-        else:
-            user = await bot.get_stranger_info(user_id=event.user_id)
-            sex = user["sex"]
-            age = str(user["age"])
-            if exists_data["group"].get(f"{event.user_id}:{event.group_id}"):
-                if (
-                    time.time()
-                    - exists_data["group"][f"{event.user_id}:{event.group_id}"]
-                    < 60 * 5
-                ):
-                    return
-            exists_data["group"][f"{event.user_id}:{event.group_id}"] = time.time()
-            nickname = await FriendUser.get_user_name(event.user_id)
-            await bot.send_private_msg(
-                user_id=int(list(bot.config.superusers)[0]),
-                message=f"*****一份入群申请*****\n"
-                f"申请人：{nickname}({event.user_id})\n"
-                f"群聊：{event.group_id}\n"
-                f"邀请日期：{str(datetime.now()).split('.')[0]}",
-            )
-            await bot.send_private_msg(
-                user_id=event.user_id,
-                message=f"想要邀请我偷偷入群嘛~已经提醒{NICKNAME}的管理员大人了\n"
-                "请确保已经群主或群管理沟通过！\n"
-                "等待管理员处理吧！",
-            )
-            requests_manager.add_request(
-                event.user_id,
-                "group",
-                event.flag,
-                invite_group=event.group_id,
-                nickname=nickname,
-                sex=sex,
-                age=age,
-            )
-
-
-@x.handle()
-async def _(event: MessageEvent):
-    await asyncio.sleep(0.1)
-    r = re.search(r'groupcode="(.*?)"', str(event.get_message()))
-    if r:
-        group_id = int(r.group(1))
-    else:
-        return
-    r = re.search(r'groupname="(.*?)"', str(event.get_message()))
-    if r:
-        group_name = r.group(1)
-    else:
-        group_name = "None"
-    requests_manager.set_group_name(group_name, group_id)
-
-
-@scheduler.scheduled_job(
-    "interval",
-    minutes=5,
-)
-async def _():
-    global exists_data
-    exists_data = {"private": {}, "group": {}}

basic_plugins/nickname.py

@@ -1,200 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, PrivateMessageEvent, Message
-from nonebot import on_command
-from nonebot.typing import T_State
-from nonebot.rule import to_me
-from models.group_member_info import GroupInfoUser
-from models.friend_user import FriendUser
-from models.ban_user import BanUser
-from services.log import logger
-from configs.config import NICKNAME, Config
-from nonebot.params import CommandArg
-import random
-
-__zx_plugin_name__ = "昵称系统"
-__plugin_usage__ = f"""
-usage：
-    个人昵称系统，群聊 与 私聊 昵称相互独立
-    指令：
-        以后叫我 [昵称]
-        {NICKNAME}我是谁
-""".strip()
-__plugin_des__ = "区区昵称，才不想叫呢！"
-__plugin_cmd__ = ["以后叫我 [昵称]", f"{NICKNAME}我是谁"]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_configs__ = {
-    "BLACK_WORD": {
-        "value": ["爸", "爹", "爷"],
-        "help": "昵称所屏蔽的关键词，会被替换为 *",
-        "default_value": None
-    }
-}
-
-nickname = on_command(
-    "nickname",
-    aliases={"以后叫我", "以后请叫我", "称呼我", "以后请称呼我", "以后称呼我", "叫我", "请叫我"},
-    rule=to_me(),
-    priority=5,
-    block=True,
-)
-
-my_nickname = on_command(
-    "my_name", aliases={"我叫什么", "我是谁", "我的名字"}, rule=to_me(), priority=5, block=True
-)
-
-
-cancel_nickname = on_command("取消昵称", rule=to_me(), priority=5, block=True)
-
-
-@nickname.handle()
-async def _(bot: Bot, event: GroupMessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if not msg:
-        await nickname.finish("叫你空白？叫你虚空？叫你无名？？", at_sender=True)
-    if len(msg) > 10:
-        await nickname.finish("昵称可不能超过10个字！", at_sender=True)
-    if msg in bot.config.superusers:
-        await nickname.finish("笨蛋！休想占用我的名字！#", at_sender=True)
-    _tmp = ""
-    black_word = Config.get_config("nickname", "BLACK_WORD")
-    for x in msg:
-        _tmp += "*" if x in black_word else x
-    msg = _tmp
-    if isinstance(event, GroupMessageEvent):
-        if await GroupInfoUser.set_group_member_nickname(
-            event.user_id, event.group_id, msg
-        ):
-            if len(msg) < 5:
-                if random.random() < 0.3:
-                    msg = "~".join(msg)
-            await nickname.send(
-                random.choice(
-                    [
-                        f"好啦好啦，我知道啦，{msg}，以后就这么叫你吧",
-                        f"嗯嗯，{NICKNAME}记住你的昵称了哦，{msg}",
-                        f"好突然，突然要叫你昵称什么的...{msg}..",
-                        f"{NICKNAME}会好好记住的{msg}的，放心吧",
-                        f"好..好.，那窝以后就叫你{msg}了.",
-                    ]
-                )
-            )
-            logger.info(f"USER {event.user_id} GROUP {event.group_id} 设置群昵称 {msg}")
-        else:
-            await nickname.send("设置昵称失败，请更新群组成员信息！", at_sender=True)
-            logger.warning(f"USER {event.user_id} GROUP {event.group_id} 设置群昵称 {msg} 失败")
-    else:
-        if await FriendUser.set_friend_nickname(event.user_id, msg):
-            await nickname.send(
-                random.choice(
-                    [
-                        f"好啦好啦，我知道啦，{msg}，以后就这么叫你吧",
-                        f"嗯嗯，{NICKNAME}记住你的昵称了哦，{msg}",
-                        f"好突然，突然要叫你昵称什么的...{msg}..",
-                        f"{NICKNAME}会好好记住的{msg}的，放心吧",
-                        f"好..好.，那窝以后就叫你{msg}了.",
-                    ]
-                )
-            )
-            logger.info(f"USER {event.user_id} 设置昵称 {msg}")
-        else:
-            await nickname.send("设置昵称失败了，明天再来试一试！或联系管理员更新好友！", at_sender=True)
-            logger.warning(f"USER {event.user_id} 设置昵称 {msg} 失败")
-
-
-@my_nickname.handle()
-async def _(event: GroupMessageEvent):
-    try:
-        nickname_ = await GroupInfoUser.get_group_member_nickname(
-            event.user_id, event.group_id
-        )
-    except AttributeError:
-        nickname_ = ""
-    if nickname_:
-        await my_nickname.send(
-            random.choice(
-                [
-                    f"我肯定记得你啊，你是{nickname_}啊",
-                    f"我不会忘记你的，你也不要忘记我！{nickname_}",
-                    f"哼哼，{NICKNAME}记忆力可是很好的，{nickname_}",
-                    f"嗯？你是失忆了嘛...{nickname_}..",
-                    f"不要小看{NICKNAME}的记忆力啊！笨蛋{nickname_}！QAQ",
-                    f"哎？{nickname_}..怎么了吗..突然这样问..",
-                ]
-            )
-        )
-    else:
-        nickname_ = event.sender.card or event.sender.nickname
-        await my_nickname.send(
-            random.choice(
-                ["没..没有昵称嘛，{}", "啊，你是{}啊，我想叫你的昵称！", "是{}啊，有什么事吗？", "你是{}？"]
-            ).format(nickname_)
-        )
-
-
-@my_nickname.handle()
-async def _(bot: Bot, event: PrivateMessageEvent, state: T_State):
-    nickname_ = await FriendUser.get_friend_nickname(event.user_id)
-    if nickname_:
-        await my_nickname.send(
-            random.choice(
-                [
-                    f"我肯定记得你啊，你是{nickname_}啊",
-                    f"我不会忘记你的，你也不要忘记我！{nickname_}",
-                    f"哼哼，{NICKNAME}记忆力可是很好的，{nickname_}",
-                    f"嗯？你是失忆了嘛...{nickname_}..",
-                    f"不要小看{NICKNAME}的记忆力啊！笨蛋{nickname_}！QAQ",
-                    f"哎？{nickname_}..怎么了吗..突然这样问..",
-                ]
-            )
-        )
-    else:
-        nickname_ = (await bot.get_stranger_info(user_id=event.user_id))["nickname"]
-        await my_nickname.send(
-            random.choice(
-                ["没..没有昵称嘛，{}", "啊，你是{}啊，我想叫你的昵称！", "是{}啊，有什么事吗？", "你是{}？"]
-            ).format(nickname_)
-        )
-
-
-@cancel_nickname.handle()
-async def _(event: GroupMessageEvent):
-    nickname_ = await GroupInfoUser.get_group_member_nickname(
-        event.user_id, event.group_id
-    )
-    if nickname_:
-        await cancel_nickname.send(
-            random.choice(
-                [
-                    f"呜..{NICKNAME}睡一觉就会忘记的..和梦一样..{nickname_}",
-                    f"窝知道了..{nickname_}..",
-                    f"是{NICKNAME}哪里做的不好嘛..好吧..晚安{nickname_}",
-                    f"呃，{nickname_}，下次我绝对绝对绝对不会再忘记你！",
-                    f"可..可恶！{nickname_}！太可恶了！呜",
-                ]
-            )
-        )
-        await GroupInfoUser.set_group_member_nickname(event.user_id, event.group_id, "")
-        await BanUser.ban(event.user_id, 9, 60)
-    else:
-        await cancel_nickname.send("你在做梦吗？你没有昵称啊", at_sender=True)
-
-
-@cancel_nickname.handle()
-async def _(event: PrivateMessageEvent):
-    nickname_ = await FriendUser.get_friend_nickname(event.user_id)
-    if nickname_:
-        await cancel_nickname.send(
-            random.choice(
-                [
-                    f"呜..{NICKNAME}睡一觉就会忘记的..和梦一样..{nickname_}",
-                    f"窝知道了..{nickname_}..",
-                    f"是{NICKNAME}哪里做的不好嘛..好吧..晚安{nickname_}",
-                    f"呃，{nickname_}，下次我绝对绝对绝对不会再忘记你！",
-                    f"可..可恶！{nickname_}！太可恶了！呜",
-                ]
-            )
-        )
-        await FriendUser.get_user_name(event.user_id)
-        await BanUser.ban(event.user_id, 9, 60)
-    else:
-        await cancel_nickname.send("你在做梦吗？你没有昵称啊", at_sender=True)

basic_plugins/scripts.py

@@ -1,211 +0,0 @@
-from asyncpg.exceptions import (
-    DuplicateColumnError,
-    UndefinedColumnError,
-    PostgresSyntaxError,
-)
-from nonebot import Driver
-from services.db_context import db
-from models.group_info import GroupInfo
-from models.bag_user import BagUser
-from nonebot.adapters.onebot.v11 import Bot
-from services.log import logger
-from configs.path_config import TEXT_PATH
-from asyncio.exceptions import TimeoutError
-from typing import List
-from utils.http_utils import AsyncHttpx
-from utils.utils import scheduler
-import nonebot
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-driver: Driver = nonebot.get_driver()
-
-
-@driver.on_startup
-async def update_city():
-    """
-    部分插件需要中国省份城市
-    这里直接更新，避免插件内代码重复
-    """
-    china_city = TEXT_PATH / "china_city.json"
-    data = {}
-    if not china_city.exists():
-        try:
-            res = await AsyncHttpx.get(
-                "http://www.weather.com.cn/data/city3jdata/china.html", timeout=5
-            )
-            res.encoding = "utf8"
-            provinces_data = json.loads(res.text)
-            for province in provinces_data.keys():
-                data[provinces_data[province]] = []
-                res = await AsyncHttpx.get(
-                    f"http://www.weather.com.cn/data/city3jdata/provshi/{province}.html",
-                    timeout=5,
-                )
-                res.encoding = "utf8"
-                city_data = json.loads(res.text)
-                for city in city_data.keys():
-                    data[provinces_data[province]].append(city_data[city])
-            with open(china_city, "w", encoding="utf8") as f:
-                json.dump(data, f, indent=4, ensure_ascii=False)
-            logger.info("自动更新城市列表完成.....")
-        except TimeoutError:
-            logger.warning("自动更新城市列表超时.....")
-        except ValueError:
-            logger.warning("自动城市列表失败.....")
-        except Exception as e:
-            logger.error(f"自动城市列表未知错误 {type(e)}：{e}")
-
-
-@driver.on_startup
-async def _():
-    """
-    数据库表结构变换
-    """
-    _flag = []
-    sql_str = [
-        (
-            "ALTER TABLE group_info ADD group_flag Integer NOT NULL DEFAULT 0;",
-            "group_info",
-        ),  # group_info表添加一个group_flag
-        (
-            "ALTER TABLE bag_users rename belonging_group To group_id;",
-            "bag_users",
-        ),  # 将 bag_users 的 belonging_group 改为 group_id
-        (
-            "ALTER TABLE group_info_users rename belonging_group To group_id;",
-            "group_info_users",
-        ),
-        (
-            "ALTER TABLE sign_group_users rename belonging_group To group_id;",
-            "sign_group_users",
-        ),
-        (
-            "ALTER TABLE open_cases_users rename belonging_group To group_id;",
-            "open_cases_users",
-        ),
-        (
-            "ALTER TABLE bag_users ADD property json NOT NULL DEFAULT '{}';",
-            "bag_users",
-        ),  # bag_users 新增字段 property 替代 props
-        (
-            "ALTER TABLE genshin ADD auto_sign_time timestamp with time zone;",
-            "genshin"
-        ),  # 新增原神自动签到字段
-        (
-            "ALTER TABLE genshin ADD resin_remind boolean DEFAULT False;",
-            "genshin"
-        ),  # 新增原神自动签到字段
-        (
-            "ALTER TABLE genshin ADD resin_recovery_time timestamp with time zone;",
-            "genshin"
-        ),  # 新增原神自动签到字段
-        (
-            "ALTER TABLE genshin ADD bind_group Integer;",
-            "genshin"
-        ),  # 新增原神群号绑定字段
-    ]
-    for sql in sql_str:
-        try:
-            flag = sql[1]
-            sql = sql[0]
-            query = db.text(sql)
-            await db.first(query)
-            logger.info(f"完成sql操作：{sql}")
-            _flag.append(flag)
-        except (DuplicateColumnError, UndefinedColumnError):
-            pass
-        except PostgresSyntaxError:
-            logger.error(f"语法错误：执行sql失败：{sql}")
-    # bag_user 将文本转为字典格式
-    await __database_script(_flag)
-
-    # 完成后
-    end_sql_str = [
-        # "ALTER TABLE bag_users DROP COLUMN props;"          # 删除 bag_users 的 props 字段（还不到时候）
-    ]
-    for sql in end_sql_str:
-        try:
-            query = db.text(sql)
-            await db.first(query)
-            logger.info(f"完成执行sql操作：{sql}")
-        except (DuplicateColumnError, UndefinedColumnError):
-            pass
-        except PostgresSyntaxError:
-            logger.error(f"语法错误：执行sql失败：{sql}")
-
-    # str2json_sql = ["alter table bag_users alter COLUMN props type json USING props::json;"]       # 字段类型替换
-    # rename_sql = 'alter table {} rename {} to {};'                              # 字段更名
-    # for sql in str2json_sql:
-    #     try:
-    #         query = db.text(sql)
-    #         await db.first(query)
-    #     except DuplicateColumnError:
-    #         pass
-
-
-@driver.on_bot_connect
-async def _(bot: Bot):
-    """
-    版本某些需要的变换
-    """
-    # 清空不存在的群聊信息，并将已所有已存在的群聊group_flag设置为1（认证所有已存在的群）
-    if not await GroupInfo.get_group_info(114514):
-        # 标识符，该功能只需执行一次
-        await GroupInfo.add_group_info(114514, "114514", 114514, 114514, 1)
-        group_list = await bot.get_group_list()
-        group_list = [g["group_id"] for g in group_list]
-        _gl = [x.group_id for x in await GroupInfo.get_all_group()]
-        if 114514 in _gl:
-            _gl.remove(114514)
-        for group_id in _gl:
-            if group_id in group_list:
-                if await GroupInfo.get_group_info(group_id):
-                    await GroupInfo.set_group_flag(group_id, 1)
-                else:
-                    group_info = await bot.get_group_info(group_id=group_id)
-                    await GroupInfo.add_group_info(
-                        group_info["group_id"],
-                        group_info["group_name"],
-                        group_info["max_member_count"],
-                        group_info["member_count"],
-                        1,
-                    )
-                logger.info(f"已将群聊 {group_id} 添加认证...")
-            else:
-                await GroupInfo.delete_group_info(group_id)
-                logger.info(f"移除不存在的群聊信息：{group_id}")
-
-
-async def __database_script(_flag: List[str]):
-    # bag_user 将文本转为字典格式
-    if "bag_users" in _flag:
-        for x in await BagUser.get_all_users():
-            props = {}
-            if x.props:
-                for prop in [p for p in x.props.split(",") if p]:
-                    if props.get(prop):
-                        props[prop] += 1
-                    else:
-                        props[prop] = 1
-                logger.info(
-                    f"__database_script USER {x.user_qq} GROUP {x.group_id} 更新数据 {props}"
-                )
-            await x.update(
-                property=props,
-                props="",
-            ).apply()
-
-
-# 自动更新城市列表
-@scheduler.scheduled_job(
-    "cron",
-    hour=6,
-    minute=1,
-)
-async def _():
-    await update_city()

basic_plugins/shop/__init__.py

@@ -1,14 +0,0 @@
-import nonebot
-from configs.config import Config
-
-
-Config.add_plugin_config(
-    "shop",
-    "IMPORT_DEFAULT_SHOP_GOODS",
-    True,
-    help_="导入商店自带的三个商品",
-    default_value=True
-)
-
-
-nonebot.load_plugins("basic_plugins/shop")

basic_plugins/shop/buy.py

@@ -1,94 +0,0 @@
-from nonebot import on_command
-from services.log import logger
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message
-from nonebot.params import CommandArg
-from utils.utils import is_number
-from models.bag_user import BagUser
-from services.db_context import db
-from nonebot.adapters.onebot.v11.permission import GROUP
-from models.goods_info import GoodsInfo
-import time
-
-
-__zx_plugin_name__ = "商店 - 购买道具"
-__plugin_usage__ = """
-usage：
-    购买道具
-    指令：
-        购买 [序号或名称] ?[数量=1]
-        示例：购买 好感双倍加持卡Ⅰ
-        示例：购买 1 4
-""".strip()
-__plugin_des__ = "商店 - 购买道具"
-__plugin_cmd__ = ["购买 [序号或名称] ?[数量=1]"]
-__plugin_type__ = ("商店",)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["商店", "购买道具"],
-}
-__plugin_cd_limit__ = {"cd": 3}
-
-
-buy = on_command("购买", aliases={"购买道具"}, priority=5, block=True, permission=GROUP)
-
-
-@buy.handle()
-async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
-    goods = None
-    if arg.extract_plain_text().strip() in ["神秘药水"]:
-        await buy.finish("你们看看就好啦，这是不可能卖给你们的~", at_sender=True)
-    goods_list = [
-        x
-        for x in await GoodsInfo.get_all_goods()
-        if x.goods_limit_time > time.time() or x.goods_limit_time == 0
-    ]
-    goods_name_list = [
-        x.goods_name
-        for x in goods_list
-    ]
-    msg = arg.extract_plain_text().strip().split()
-    num = 1
-    if len(msg) > 1:
-        if is_number(msg[1]) and int(msg[1]) > 0:
-            num = int(msg[1])
-        else:
-            await buy.finish("购买的数量要是数字且大于0！", at_sender=True)
-    if is_number(msg[0]):
-        msg = int(msg[0])
-        if msg > len(goods_name_list) or msg < 1:
-            await buy.finish("请输入正确的商品id！", at_sender=True)
-        goods = goods_list[msg - 1]
-    else:
-        if msg[0] in goods_name_list:
-            for i in range(len(goods_name_list)):
-                if msg[0] == goods_name_list[i]:
-                    goods = goods_list[i]
-                    break
-            else:
-                await buy.finish("请输入正确的商品名称！")
-        else:
-            await buy.finish("请输入正确的商品名称！", at_sender=True)
-    async with db.transaction():
-        if (
-            await BagUser.get_gold(event.user_id, event.group_id)
-        ) < goods.goods_price * num * goods.goods_discount:
-            await buy.finish("您的金币好像不太够哦", at_sender=True)
-        if await BagUser.buy_property(event.user_id, event.group_id, goods, num):
-            await buy.send(
-                f"花费 {goods.goods_price * num * goods.goods_discount} 金币购买 {goods.goods_name} ×{num} 成功！",
-                at_sender=True,
-            )
-            logger.info(
-                f"USER {event.user_id} GROUP {event.group_id} "
-                f"花费 {goods.goods_price*num} 金币购买 {goods.goods_name} ×{num} 成功！"
-            )
-        else:
-            await buy.send(f"{goods.goods_name} 购买失败！", at_sender=True)
-            logger.info(
-                f"USER {event.user_id} GROUP {event.group_id} "
-                f"花费 {goods.goods_price * num * goods.goods_discount} 金币购买 {goods.goods_name} ×{num} 失败！"
-            )

basic_plugins/shop/gold.py

@@ -1,52 +0,0 @@
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message
-from nonebot.params import CommandArg
-from nonebot.adapters.onebot.v11.permission import GROUP
-from utils.data_utils import init_rank
-from models.bag_user import BagUser
-from utils.message_builder import image
-from utils.utils import is_number
-
-__zx_plugin_name__ = "商店 - 我的金币"
-__plugin_usage__ = """
-usage：
-    我的金币
-    指令：
-        我的金币
-""".strip()
-__plugin_des__ = "商店 - 我的金币"
-__plugin_cmd__ = ["我的金币"]
-__plugin_type__ = ("商店",)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["商店", "我的金币"],
-}
-
-
-my_gold = on_command("我的金币", priority=5, block=True, permission=GROUP)
-
-gold_rank = on_command("金币排行", priority=5, block=True, permission=GROUP)
-
-
-@my_gold.handle()
-async def _(event: GroupMessageEvent):
-    await my_gold.finish(await BagUser.get_user_total_gold(event.user_id, event.group_id))
-
-
-@gold_rank.handle()
-async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
-    num = arg.extract_plain_text().strip()
-    if is_number(num) and 51 > int(num) > 10:
-        num = int(num)
-    else:
-        num = 10
-    all_users = await BagUser.get_all_users(event.group_id)
-    all_user_id = [user.user_qq for user in all_users]
-    all_user_data = [user.gold for user in all_users]
-    rank_image = await init_rank("金币排行", all_user_id, all_user_data, event.group_id, num)
-    if rank_image:
-        await gold_rank.finish(image(b64=rank_image.pic2bs4()))

basic_plugins/shop/my_props.py

@@ -1,41 +0,0 @@
-from nonebot import on_command
-from services.log import logger
-from nonebot.adapters.onebot.v11 import GroupMessageEvent
-from models.bag_user import BagUser
-from nonebot.adapters.onebot.v11.permission import GROUP
-
-
-__zx_plugin_name__ = "商店 - 我的道具"
-__plugin_usage__ = """
-usage：
-    我的道具
-    指令：
-        我的道具
-""".strip()
-__plugin_des__ = "商店 - 我的道具"
-__plugin_cmd__ = ["我的道具"]
-__plugin_type__ = ('商店',)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["商店", "我的道具"],
-}
-
-
-my_props = on_command("我的道具", priority=5, block=True, permission=GROUP)
-
-
-@my_props.handle()
-async def _(event: GroupMessageEvent):
-    props = await BagUser.get_property(event.user_id, event.group_id)
-    if props:
-        rst = ""
-        for i, p in enumerate(props.keys()):
-            rst += f"{i+1}.{p}\t×{props[p]}\n"
-        await my_props.send("\n" + rst[:-1], at_sender=True)
-        logger.info(f"USER {event.user_id} GROUP {event.group_id} 查看我的道具")
-    else:
-        await my_props.finish("您的背包里没有任何的道具噢~", at_sender=True)

basic_plugins/shop/reset_today_gold.py

@@ -1,26 +0,0 @@
-from utils.utils import scheduler
-from models.bag_user import BagUser
-from services.log import logger
-
-
-__zx_plugin_name__ = "每日金币重置 [Hidden]"
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-# 重置每日金币
-@scheduler.scheduled_job(
-    "cron",
-    hour=0,
-    minute=1,
-)
-async def _():
-    try:
-        user_list = await BagUser.get_all_users()
-        for user in user_list:
-            await user.update(
-                get_today_gold=0,
-                spend_today_gold=0,
-            ).apply()
-    except Exception as e:
-        logger.error(f"重置每日金币错误 e:{e}")

basic_plugins/shop/shop_handle/__init__.py

@@ -1,133 +0,0 @@
-from .data_source import create_shop_help, delete_goods, update_goods, register_goods, parse_goods_info
-from nonebot.adapters.onebot.v11 import MessageEvent, Message
-from nonebot import on_command
-from configs.path_config import IMAGE_PATH
-from utils.message_builder import image
-from nonebot.permission import SUPERUSER
-from utils.utils import is_number
-from nonebot.params import CommandArg
-from nonebot.plugin import export
-from services.log import logger
-import os
-
-
-__zx_plugin_name__ = "商店"
-__plugin_usage__ = """
-usage：
-    商店项目，这可不是奸商
-    指令：
-        商店
-""".strip()
-__plugin_superuser_usage__ = """
-usage：
-    商品操作
-    指令：
-        添加商品 name:[名称] price:[价格] des:[描述] ?discount:[折扣](小数) ?limit_time:[限时时间](小时)
-        删除商品 [名称或序号]
-        修改商品 name:[名称或序号] price:[价格] des:[描述] discount:[折扣] limit_time:[限时]
-        示例：添加商品 name:萝莉酒杯 price:9999 des:普通的酒杯，但是里面.. discount:0.4 limit_time:90
-        示例：添加商品 name:可疑的药 price:5 des:效果未知
-        示例：删除商品 2
-        示例：修改商品 name:1 price:900   修改序号为1的商品的价格为900
-    * 修改商品只需添加需要值即可 *
-""".strip()
-__plugin_des__ = "商店系统[金币回收计划]"
-__plugin_cmd__ = [
-    "商店",
-    "添加商品 name:[名称] price:[价格] des:[描述] ?discount:[折扣](小数) ?limit_time:[限时时间](小时)) [_superuser]",
-    "删除商品 [名称或序号] [_superuser]",
-    "修改商品 name:[名称或序号] price:[价格] des:[描述] discount:[折扣] limit_time:[限时] [_superuser]",
-]
-__plugin_type__ = ('商店',)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["商店"],
-}
-__plugin_block_limit__ = {
-    "limit_type": "group"
-}
-
-# 导出方法供其他插件使用
-export = export()
-export.register_goods = register_goods
-export.delete_goods = delete_goods
-export.update_goods = update_goods
-
-shop_help = on_command("商店", priority=5, block=True)
-
-shop_add_goods = on_command("添加商品", priority=5, permission=SUPERUSER, block=True)
-
-shop_del_goods = on_command("删除商品", priority=5, permission=SUPERUSER, block=True)
-
-shop_update_goods = on_command("修改商品", priority=5, permission=SUPERUSER, block=True)
-
-
-@shop_help.handle()
-async def _():
-    await shop_help.send(image(b64=await create_shop_help()))
-
-
-@shop_add_goods.handle()
-async def _(event: MessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if msg:
-        data = parse_goods_info(msg)
-        if isinstance(data, str):
-            await shop_add_goods.finish(data)
-        if not data.get("name") or not data.get("price") or not data.get("des"):
-            await shop_add_goods.finish("name:price:des 参数不可缺少！")
-        if await register_goods(**data):
-            await shop_add_goods.send(f"添加商品 {data['name']} 成功！\n"
-                                      f"名称：{data['name']}\n"
-                                      f"价格：{data['price']}金币\n"
-                                      f"简介：{data['des']}\n"
-                                      f"折扣：{data.get('discount')}\n"
-                                      f"限时：{data.get('limit_time')}", at_sender=True)
-            logger.info(f"USER {event.user_id} 添加商品 {msg} 成功")
-        else:
-            await shop_add_goods.send(f"添加商品 {msg} 失败了...", at_sender=True)
-            logger.warning(f"USER {event.user_id} 添加商品 {msg} 失败")
-
-
-@shop_del_goods.handle()
-async def _(event: MessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if msg:
-        name = ""
-        id_ = 0
-        if is_number(msg):
-            id_ = int(msg)
-        else:
-            name = msg
-        rst, goods_name, code = await delete_goods(name, id_)
-        if code == 200:
-            await shop_del_goods.send(f"删除商品 {goods_name} 成功了...", at_sender=True)
-            if os.path.exists(f"{IMAGE_PATH}/shop_help.png"):
-                os.remove(f"{IMAGE_PATH}/shop_help.png")
-            logger.info(f"USER {event.user_id} 删除商品 {goods_name} 成功")
-        else:
-            await shop_del_goods.send(f"删除商品 {goods_name} 失败了...", at_sender=True)
-            logger.info(f"USER {event.user_id} 删除商品 {goods_name} 失败")
-
-
-@shop_update_goods.handle()
-async def _(event: MessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if msg:
-        data = parse_goods_info(msg)
-        if isinstance(data, str):
-            await shop_add_goods.finish(data)
-        if not data.get("name"):
-            await shop_add_goods.finish("name 参数不可缺少！")
-        flag, name, text = await update_goods(**data)
-        if flag:
-            await shop_update_goods.send(f"修改商品 {name} 成功了...\n{text}", at_sender=True)
-            logger.info(f"USER {event.user_id} 修改商品 {name} 数据 {text} 成功")
-        else:
-            await shop_update_goods.send(f"修改商品 {name} 失败了...", at_sender=True)
-            logger.info(f"USER {event.user_id} 修改商品 {name} 数据 {text} 失败")
-

basic_plugins/shop/shop_handle/data_source.py

@@ -1,287 +0,0 @@
-from models.goods_info import GoodsInfo
-from utils.image_utils import BuildImage
-from models.sign_group_user import SignGroupUser
-from utils.utils import is_number
-from configs.path_config import IMAGE_PATH
-from typing import Optional, Union
-from configs.config import Config
-from nonebot import Driver
-from nonebot.plugin import require
-from utils.decorator.shop import shop_register
-import nonebot
-import time
-
-driver: Driver = nonebot.get_driver()
-
-use = require("use")
-
-
-@driver.on_startup
-async def init_default_shop_goods():
-    """
-    导入内置的三个商品
-    """
-
-    @shop_register(
-        name=("好感度双倍加持卡Ⅰ", "好感度双倍加持卡Ⅱ", "好感度双倍加持卡Ⅲ"),
-        price=(30, 150, 250),
-        des=(
-            "下次签到双倍好感度概率 + 10%（谁才是真命天子？）（同类商品将覆盖）",
-            "下次签到双倍好感度概率 + 20%（平平庸庸）（同类商品将覆盖）",
-            "下次签到双倍好感度概率 + 30%（金币才是真命天子！）（同类商品将覆盖）",
-        ),
-        load_status=Config.get_config("shop", "IMPORT_DEFAULT_SHOP_GOODS"),
-        ** {"好感度双倍加持卡Ⅰ_prob": 0.1, "好感度双倍加持卡Ⅱ_prob": 0.2, "好感度双倍加持卡Ⅲ_prob": 0.3},
-    )
-    async def sign_card(user_id: int, group_id: int, prob: float):
-        user = await SignGroupUser.ensure(user_id, group_id)
-        await user.update(add_probability=prob).apply()
-
-
-@driver.on_bot_connect
-async def _():
-    await shop_register.load_register()
-
-
-# 创建商店界面
-async def create_shop_help() -> str:
-    """
-    制作商店图片
-    :return: 图片base64
-    """
-    goods_lst = await GoodsInfo.get_all_goods()
-    idx = 1
-    _dc = {}
-    font_h = BuildImage(0, 0).getsize("正")[1]
-    h = 10
-    _list = []
-    for goods in goods_lst:
-        if goods.goods_limit_time == 0 or time.time() < goods.goods_limit_time:
-            h += len(goods.goods_description.strip().split("\n")) * font_h + 80
-            _list.append(goods)
-    A = BuildImage(1000, h, color="#f9f6f2")
-    current_h = 0
-    for goods in _list:
-        bk = BuildImage(700, 80, font_size=15, color="#f9f6f2", font="CJGaoDeGuo.otf")
-        goods_image = BuildImage(
-            600, 80, font_size=20, color="#a29ad6", font="CJGaoDeGuo.otf"
-        )
-        name_image = BuildImage(
-            580, 40, font_size=25, color="#e67b6b", font="CJGaoDeGuo.otf"
-        )
-        await name_image.atext(
-            (15, 0), f"{idx}.{goods.goods_name}", center_type="by_height"
-        )
-        await name_image.aline((380, -5, 280, 45), "#a29ad6", 5)
-        await name_image.atext((390, 0), "售价：", center_type="by_height")
-        await name_image.atext(
-            (440, 0), str(goods.goods_price), (255, 255, 255), center_type="by_height"
-        )
-        await name_image.atext(
-            (
-                440
-                + BuildImage(0, 0, plain_text=str(goods.goods_price), font_size=25).w,
-                0,
-            ),
-            " 金币",
-            center_type="by_height",
-        )
-        await name_image.acircle_corner(5)
-        await goods_image.apaste(name_image, (0, 5), True, center_type="by_width")
-        await goods_image.atext((15, 50), f"简介：{goods.goods_description}")
-        await goods_image.acircle_corner(20)
-        await bk.apaste(goods_image, alpha=True)
-        # 添加限时图标和时间
-        if goods.goods_limit_time > 0:
-            _limit_time_logo = BuildImage(
-                40, 40, background=f"{IMAGE_PATH}/other/time.png"
-            )
-            await bk.apaste(_limit_time_logo, (600, 0), True)
-            await bk.apaste(
-                BuildImage(0, 0, plain_text="限时！", font_size=23, font="CJGaoDeGuo.otf"),
-                (640, 10),
-                True,
-            )
-            limit_time = time.strftime(
-                "%Y-%m-%d %H:%M", time.localtime(goods.goods_limit_time)
-            ).split()
-            y_m_d = limit_time[0]
-            _h_m = limit_time[1].split(":")
-            h_m = _h_m[0] + "时 " + _h_m[1] + "分"
-            await bk.atext((605, 38), str(y_m_d))
-            await bk.atext((615, 57), str(h_m))
-            await bk.aline((550, -1, 710, -1), "#a29ad6", 5)
-            await bk.aline((550, 80, 710, 80), "#a29ad6", 5)
-        idx += 1
-        await A.apaste(bk, (0, current_h), True)
-        current_h += 90
-    w = 1000
-    h = A.h + 230 + 100
-    h = 1000 if h < 1000 else h
-    shop_logo = BuildImage(100, 100, background=f"{IMAGE_PATH}/other/shop_text.png")
-    shop = BuildImage(w, h, font_size=20, color="#f9f6f2")
-    shop.paste(A, (20, 230))
-    zx_img = BuildImage(0, 0, background=f"{IMAGE_PATH}/zhenxun/toukan.png")
-    zx_img.replace_color_tran(((240, 240, 240), (255, 255, 255)), (249, 246, 242))
-    await shop.apaste(zx_img, (780, 100))
-    await shop.apaste(shop_logo, (450, 30), True)
-    shop.text(
-        (int((1000 - shop.getsize("注【通过 序号 或者 商品名称 购买】")[0]) / 2), 170),
-        "注【通过 序号 或者 商品名称 购买】",
-    )
-    shop.text((20, h - 100), "神秘药水\t\t售价：9999999金币\n\t\t鬼知道会有什么效果~")
-    return shop.pic2bs4()
-
-
-async def register_goods(
-    name: str,
-    price: int,
-    des: str,
-    discount: Optional[float] = 1,
-    limit_time: Optional[int] = 0,
-    **kwargs,
-):
-    """
-    添加商品
-    例如：                                                  折扣：可选参数↓  限时时间:可选，单位为小时
-        添加商品 name:萝莉酒杯 price:9999 des:普通的酒杯，但是里面.. discount:0.4 limit_time:90
-        添加商品 name:可疑的药 price:5 des:效果未知
-    :param name: 商品名称
-    :param price: 商品价格
-    :param des: 商品简介
-    :param discount: 商品折扣
-    :param limit_time: 商品限时销售时间，单位为小时
-    :param kwargs: kwargs
-    :return: 是否添加成功
-    """
-    if kwargs:
-        name = kwargs.get("name")
-        price = kwargs.get("price")
-        des = kwargs.get("des")
-        discount = kwargs.get("discount")
-        limit_time = kwargs.get("time_limit")
-    if await GoodsInfo.get_goods_info(name):
-        limit_time = float(limit_time) if limit_time else limit_time
-        discount = discount if discount is None else 1
-        limit_time = (
-            int(time.time() + limit_time * 60 * 60)
-            if limit_time is not None and limit_time != 0
-            else 0
-        )
-        return await GoodsInfo.add_goods(
-            name, int(price), des, float(discount), limit_time
-        )
-
-
-# 删除商品
-async def delete_goods(name: str, id_: int) -> "str, str, int":
-    """
-    删除商品
-    :param name: 商品名称
-    :param id_: 商品id
-    :return: 删除状况
-    """
-    goods_lst = await GoodsInfo.get_all_goods()
-    if id_:
-        if id_ < 1 or id_ > len(goods_lst):
-            return "序号错误，没有该序号商品...", "", 999
-        goods_name = goods_lst[id_ - 1].goods_name
-        if await GoodsInfo.delete_goods(goods_name):
-            return f"删除商品 {goods_name} 成功！", goods_name, 200
-        else:
-            return f"删除商品 {goods_name} 失败！", goods_name, 999
-    if name:
-        if await GoodsInfo.delete_goods(name):
-            return f"删除商品 {name} 成功！", name, 200
-        else:
-            return f"删除商品 {name} 失败！", name, 999
-
-
-# 更新商品信息
-async def update_goods(**kwargs) -> "str, str, int":
-    """
-    更新商品信息
-    :param kwargs: kwargs
-    :return: 更新状况
-    """
-    if kwargs:
-        goods_lst = await GoodsInfo.get_all_goods()
-        if is_number(kwargs["name"]):
-            if int(kwargs["name"]) < 1 or int(kwargs["name"]) > len(goods_lst):
-                return "序号错误，没有该序号的商品...", "", 999
-            goods = goods_lst[int(kwargs["name"]) - 1]
-        else:
-            goods = await GoodsInfo.get_goods_info(kwargs["name"])
-            if not goods:
-                return "名称错误，没有该名称的商品...", "", 999
-        name = goods.goods_name
-        price = goods.goods_price
-        des = goods.goods_description
-        discount = goods.goods_discount
-        limit_time = goods.goods_limit_time
-        new_time = 0
-        tmp = ""
-        if kwargs.get("price"):
-            tmp += f'价格：{price} --> {kwargs["price"]}\n'
-            price = kwargs["price"]
-        if kwargs.get("des"):
-            tmp += f'描述：{des} --> {kwargs["des"]}\n'
-            des = kwargs["des"]
-        if kwargs.get("discount"):
-            tmp += f'折扣：{discount} --> {kwargs["discount"]}\n'
-            discount = kwargs["discount"]
-        if kwargs.get("limit_time"):
-            kwargs["limit_time"] = float(kwargs["limit_time"])
-            new_time = time.strftime(
-                "%Y-%m-%d %H:%M:%S",
-                time.localtime(time.time() + kwargs["limit_time"] * 60 * 60),
-            )
-            tmp += f"限时至： {new_time}\n"
-            limit_time = kwargs["limit_time"]
-        return (
-            await GoodsInfo.update_goods(
-                name,
-                int(price),
-                des,
-                float(discount),
-                int(
-                    time.time() + limit_time * 60 * 60
-                    if limit_time != 0 and new_time
-                    else 0
-                ),
-            ),
-            name,
-            tmp[:-1],
-        )
-
-
-def parse_goods_info(msg: str) -> Union[dict, str]:
-    """
-    解析格式数据
-    :param msg: 消息
-    :return: 解析完毕的数据data
-    """
-    if "name:" not in msg:
-        return "必须指定修改的商品名称或序号！"
-    data = {}
-    for x in msg.split():
-        sp = x.split(":", maxsplit=1)
-        if str(sp[1]).strip():
-            sp[1] = sp[1].strip()
-            if sp[0] == "name":
-                data["name"] = sp[1]
-            elif sp[0] == "price":
-                if not is_number(sp[1]) or int(sp[1]) < 0:
-                    return "price参数不合法，必须大于等于0！"
-                data["price"] = sp[1]
-            elif sp[0] == "des":
-                data["des"] = sp[1]
-            elif sp[0] == "discount":
-                if not is_number(sp[1]) or float(sp[1]) < 0:
-                    return "discount参数不合法，必须大于0！"
-                data["discount"] = sp[1]
-            elif sp[0] == "limit_time":
-                if not is_number(sp[1]) or float(sp[1]) < 0:
-                    return "limit_time参数不合法，必须大于0！"
-                data["limit_time"] = sp[1]
-    return data

basic_plugins/shop/use/__init__.py

@@ -1,81 +0,0 @@
-from nonebot import on_command
-from services.log import logger
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message
-from nonebot.params import CommandArg
-from utils.utils import is_number
-from models.bag_user import BagUser
-from nonebot.adapters.onebot.v11.permission import GROUP
-from services.db_context import db
-from nonebot.plugin import export
-from .data_source import effect, register_use, func_manager
-
-
-__zx_plugin_name__ = "商店 - 使用道具"
-__plugin_usage__ = """
-usage：
-    普通的使用道具
-    指令：
-        使用道具 [序号或道具名称] ?[数量]=1
-    * 序号以 ”我的道具“ 为准 *
-""".strip()
-__plugin_des__ = "商店 - 使用道具"
-__plugin_cmd__ = ["使用道具 [序号或道具名称]"]
-__plugin_type__ = ('商店',)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["商店", "使用道具"],
-}
-
-# 导出方法供其他插件使用
-export = export()
-export.register_use = register_use
-
-use_props = on_command("使用道具", priority=5, block=True, permission=GROUP)
-
-
-@use_props.handle()
-async def _(bot: Bot, event: GroupMessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    num = 1
-    msg_sp = msg.split()
-    if len(msg_sp) > 1 and is_number(msg_sp[-1]) and int(msg_sp[-1]) > 0:
-        num = int(msg.split()[-1])
-        msg = " ".join(msg.split()[:-1])
-    property_ = await BagUser.get_property(event.user_id, event.group_id)
-    if property_:
-        async with db.transaction():
-            if is_number(msg):
-                if 0 < int(msg) <= len(property_):
-                    name = list(property_.keys())[int(msg) - 1]
-                else:
-                    await use_props.finish("仔细看看自己的道具仓库有没有这个道具？", at_sender=True)
-            else:
-                if msg not in property_.keys():
-                    await use_props.finish("道具名称错误！", at_sender=True)
-                name = msg
-            _user_prop_count = property_[name]
-            if num > _user_prop_count:
-                await use_props.finish(f"道具数量不足，无法使用{num}次！")
-            if num > (n := func_manager.get_max_num_limit(name)):
-                await use_props.finish(f"该道具单次只能使用 {n} 个！")
-            if await BagUser.delete_property(
-                event.user_id, event.group_id, name, num
-            ):
-                if func_manager.check_send_success_message(name):
-                    await use_props.send(f"使用道具 {name} {num} 次成功！", at_sender=True)
-                if msg := await effect(bot, event, name, num):
-                    await use_props.send(msg, at_sender=True)
-                logger.info(
-                    f"USER {event.user_id} GROUP {event.group_id} 使用道具 {name} {num} 次成功"
-                )
-            else:
-                await use_props.send(f"使用道具 {name} {num} 次失败！", at_sender=True)
-                logger.info(
-                    f"USER {event.user_id} GROUP {event.group_id} 使用道具 {name} {num} 次失败"
-                )
-    else:
-        await use_props.send("您的背包里没有任何的道具噢", at_sender=True)

basic_plugins/shop/use/data_source.py

@@ -1,170 +0,0 @@
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageSegment
-from services.log import logger
-from nonebot.adapters.onebot.v11 import Bot
-from pydantic import create_model
-from utils.models import ShopParam
-from typing import Optional, Union
-from types import MappingProxyType
-import inspect
-import asyncio
-
-
-class GoodsUseFuncManager:
-    def __init__(self):
-        self._data = {}
-
-    def register_use(self, goods_name: str, **kwargs):
-        """
-        注册商品使用方法
-        :param goods_name: 商品名称
-        :param kwargs: kwargs
-        """
-        self._data[goods_name] = kwargs
-
-    def exists(self, goods_name: str) -> bool:
-        """
-        判断商品使用方法是否被注册
-        :param goods_name: 商品名称
-        """
-        return bool(self._data.get(goods_name))
-
-    def get_max_num_limit(self, goods_name: str) -> int:
-        """
-        获取单次商品使用数量
-        :param goods_name: 商品名称
-        """
-        if self.exists(goods_name):
-            return self._data[goods_name]["kwargs"]["max_num_limit"]
-        return 1
-
-    async def use(
-        self, param: ShopParam, **kwargs
-    ) -> Optional[Union[str, MessageSegment]]:
-        """
-        使用道具
-        :param param: BaseModel
-        :param kwargs: kwargs
-        """
-        def parse_args(args_: MappingProxyType):
-            param_list_ = []
-            _bot = param.bot
-            param.bot = None
-            param_json = param.dict()
-            param_json["bot"] = _bot
-            for par in args_.keys():
-                if par in ["shop_param"]:
-                    param_list_.append(param)
-                elif par not in ["args", "kwargs"]:
-                    param_list_.append(param_json.get(par))
-                    if kwargs.get(par) is not None:
-                        del kwargs[par]
-            return param_list_
-        goods_name = param.goods_name
-        if self.exists(goods_name):
-            args = inspect.signature(self._data[goods_name]["func"]).parameters
-            if args and list(args.keys())[0] != "kwargs":
-                if asyncio.iscoroutinefunction(self._data[goods_name]["func"]):
-                    return await self._data[goods_name]["func"](
-                        *parse_args(args)
-                    )
-                else:
-                    return self._data[goods_name]["func"](
-                        **kwargs,
-                    )
-            else:
-                if asyncio.iscoroutinefunction(self._data[goods_name]["func"]):
-                    return await self._data[goods_name]["func"](
-                        **kwargs,
-                    )
-                else:
-                    return self._data[goods_name]["func"](
-                        **kwargs,
-                    )
-
-    def check_send_success_message(self, goods_name: str) -> bool:
-        """
-        检查是否发送使用成功信息
-        :param goods_name: 商品名称
-        """
-        if self.exists(goods_name):
-            return bool(self._data[goods_name]["kwargs"]["send_success_msg"])
-        return False
-
-    def get_kwargs(self, goods_name: str) -> dict:
-        """
-        获取商品使用方法的kwargs
-        :param goods_name: 商品名称
-        """
-        if self.exists(goods_name):
-            return self._data[goods_name]["kwargs"]
-        return {}
-
-    def init_model(self, goods_name: str, bot: Bot, event: GroupMessageEvent, num: int):
-        return self._data[goods_name]["model"](
-            **{
-                "goods_name": goods_name,
-                "bot": bot,
-                "event": event,
-                "user_id": event.user_id,
-                "group_id": event.group_id,
-                "num": num,
-            }
-        )
-
-
-func_manager = GoodsUseFuncManager()
-
-
-async def effect(
-    bot: Bot, event: GroupMessageEvent, goods_name: str, num: int
-) -> Optional[Union[str, MessageSegment]]:
-    """
-    商品生效
-    :param bot: Bot
-    :param event: GroupMessageEvent
-    :param goods_name: 商品名称
-    :param num: 使用数量
-    :return: 使用是否成功
-    """
-    # 优先使用注册的商品插件
-    # try:
-    if func_manager.exists(goods_name):
-        _kwargs = func_manager.get_kwargs(goods_name)
-        return await func_manager.use(
-            func_manager.init_model(goods_name, bot, event, num),
-            **{
-                **_kwargs,
-                "_bot": bot,
-                "event": event,
-                "group_id": event.group_id,
-                "user_id": event.user_id,
-                "num": num,
-                "goods_name": goods_name,
-            },
-        )
-    # except Exception as e:
-    #     logger.error(f"use 商品生效函数effect 发生错误 {type(e)}：{e}")
-    return None
-
-
-def register_use(goods_name: str, func, **kwargs):
-    """
-    注册商品使用方法
-    :param goods_name: 商品名称
-    :param func: 使用函数
-    :param kwargs: kwargs
-    """
-    if func_manager.exists(goods_name):
-        raise ValueError("该商品使用函数已被注册！")
-    # 发送使用成功信息
-    kwargs["send_success_msg"] = kwargs.get("send_success_msg", True)
-    kwargs["max_num_limit"] = kwargs.get("max_num_limit", 1)
-    func_manager.register_use(
-        goods_name,
-        **{
-            "func": func,
-            "model": create_model(f"{goods_name}_model", __base__=ShopParam, **kwargs),
-            "kwargs": kwargs,
-        },
-    )
-    logger.info(f"register_use 成功注册商品：{goods_name} 的使用函数")

basic_plugins/super_cmd/__init__.py

@@ -1,10 +0,0 @@
-import nonebot
-
-
-nonebot.load_plugins('basic_plugins/super_cmd')
-
-
-
-
-
-

basic_plugins/super_cmd/bot_friend_group.py

@@ -1,153 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.adapters.onebot.v11 import Bot, Message
-from nonebot.params import Command, CommandArg
-from typing import Tuple
-from nonebot.rule import to_me
-from utils.utils import is_number
-from utils.manager import requests_manager
-from utils.message_builder import image
-from models.group_info import GroupInfo
-
-
-__zx_plugin_name__ = "显示所有好友群组 [Superuser]"
-__plugin_usage__ = """
-usage：
-    显示所有好友群组
-    指令：
-        查看所有好友/查看所有群组
-        同意好友请求 [id]
-        拒绝好友请求 [id]
-        同意群聊请求 [id]
-        拒绝群聊请求 [id]
-        查看所有请求
-        清空所有请求
-""".strip()
-__plugin_des__ = "显示所有好友群组"
-__plugin_cmd__ = [
-    "查看所有好友/查看所有群组",
-    "同意好友请求 [id]",
-    "拒绝好友请求 [id]",
-    "同意群聊请求 [id]",
-    "拒绝群聊请求 [id]",
-    "查看所有请求",
-    "清空所有请求",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-cls_group = on_command(
-    "查看所有群组", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-cls_friend = on_command(
-    "查看所有好友", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-
-friend_handle = on_command(
-    "同意好友请求", aliases={"拒绝好友请求"}, permission=SUPERUSER, priority=1, block=True
-)
-
-group_handle = on_command(
-    "同意群聊请求", aliases={"拒绝群聊请求"}, permission=SUPERUSER, priority=1, block=True
-)
-
-clear_request = on_command("清空所有请求", permission=SUPERUSER, priority=1, block=True)
-
-cls_request = on_command("查看所有请求", permission=SUPERUSER, priority=1, block=True)
-
-
-@cls_group.handle()
-async def _(bot: Bot):
-    gl = await bot.get_group_list()
-    msg = ["{group_id} {group_name}".format_map(g) for g in gl]
-    msg = "\n".join(msg)
-    msg = f"bot:{bot.self_id}\n| 群号 | 群名 | 共{len(gl)}个群\n" + msg
-    await cls_group.send(msg)
-
-
-@cls_friend.handle()
-async def _(bot: Bot):
-    gl = await bot.get_friend_list()
-    msg = ["{user_id} {nickname}".format_map(g) for g in gl]
-    msg = "\n".join(msg)
-    msg = f"| QQ号 | 昵称 | 共{len(gl)}个好友\n" + msg
-    await cls_friend.send(msg)
-
-
-@friend_handle.handle()
-async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    id_ = arg.extract_plain_text().strip()
-    if is_number(id_):
-        id_ = int(id_)
-        if cmd[:2] == "同意":
-            flag = await requests_manager.approve(bot, id_, "private")
-        else:
-            flag = await requests_manager.refused(bot, id_, "private")
-        if flag == 1:
-            await friend_handle.send(f"{cmd[:2]}好友请求失败，该请求已失效..")
-            requests_manager.delete_request(id_, "private")
-        elif flag == 2:
-            await friend_handle.send(f"{cmd[:2]}好友请求失败，未找到此id的请求..")
-        else:
-            await friend_handle.send(f"{cmd[:2]}好友请求成功！")
-    else:
-        await friend_handle.send("id必须为纯数字！")
-
-
-@group_handle.handle()
-async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    id_ = arg.extract_plain_text().strip()
-    flag = None
-    if is_number(id_):
-        id_ = int(id_)
-        if cmd[:2] == "同意":
-            rid = requests_manager.get_group_id(id_)
-            if rid:
-                if await GroupInfo.get_group_info(rid):
-                    await GroupInfo.set_group_flag(rid, 1)
-                else:
-                    group_info = await bot.get_group_info(group_id=rid)
-                    await GroupInfo.add_group_info(
-                        rid,
-                        group_info["group_name"],
-                        group_info["max_member_count"],
-                        group_info["member_count"],
-                        1
-                    )
-                flag = await requests_manager.approve(bot, id_, "group")
-            else:
-                await friend_handle.send("同意群聊请求失败，未找到此id的请求..")
-        else:
-            flag = await requests_manager.refused(bot, id_, "group")
-        if flag == 1:
-            await friend_handle.send(f"{cmd[:2]}群聊请求失败，该请求已失效..")
-            requests_manager.delete_request(id_, "group")
-        elif flag == 2:
-            await friend_handle.send(f"{cmd[:2]}群聊请求失败，未找到此id的请求..")
-        else:
-            await friend_handle.send(f"{cmd[:2]}群聊请求成功！")
-    else:
-        await friend_handle.send("id必须为纯数字！")
-
-
-@cls_request.handle()
-async def _():
-    _str = ""
-    for type_ in ["private", "group"]:
-        msg = await requests_manager.show(type_)
-        if msg:
-            _str += image(b64=msg)
-        else:
-            _str += "没有任何好友请求.." if type_ == "private" else "没有任何群聊请求.."
-        if type_ == "private":
-            _str += '\n--------------------\n'
-    await cls_request.send(Message(_str))
-
-
-@clear_request.handle()
-async def _():
-    requests_manager.clear()
-    await cls_request.send("已清空所有好友/群聊请求..")

basic_plugins/super_cmd/clear_data.py

@@ -1,66 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from configs.path_config import TEMP_PATH
-from nonebot.rule import to_me
-from utils.utils import scheduler
-from services.log import logger
-from utils.manager import resources_manager
-import asyncio
-import time
-import os
-
-__zx_plugin_name__ = "清理临时数据 [Superuser]"
-__plugin_usage__ = """
-usage：
-    清理临时数据
-    指令：
-        清理临时数据
-""".strip()
-__plugin_des__ = "清理临时数据"
-__plugin_cmd__ = [
-    "清理临时数据",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-clear_data = on_command(
-    "清理临时数据", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-
-
-resources_manager.add_temp_dir(TEMP_PATH)
-
-
-@clear_data.handle()
-async def _():
-    await clear_data.send("开始清理临时数据....")
-    size = await asyncio.get_event_loop().run_in_executor(None, _clear_data)
-    await clear_data.send("共清理了 {:.2f}MB 的数据...".format(size / 1024 / 1024))
-
-
-def _clear_data() -> float:
-    size = 0
-    for dir_ in resources_manager.get_temp_data_dir():
-        if dir_.exists():
-            for file in os.listdir(dir_):
-                file = dir_ / file
-                if file.is_file():
-                    try:
-                        if time.time() - os.path.getatime(file) > 300:
-                            file_size = os.path.getsize(file)
-                            file.unlink()
-                            size += file_size
-                    except Exception as e:
-                        logger.error(f"清理临时数据错误...{type(e)}：{e}")
-    return float(size)
-
-
-@scheduler.scheduled_job(
-    "cron",
-    hour=1,
-    minute=1,
-)
-async def _():
-    size = await asyncio.get_event_loop().run_in_executor(None, _clear_data)
-    logger.info("自动清理临时数据完成，" + "共清理了 {:.2f}MB 的数据...".format(size / 1024 / 1024))

basic_plugins/super_cmd/exec_sql.py

@@ -1,37 +0,0 @@
-from nonebot.adapters.onebot.v11 import Message
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from services.db_context import db
-from nonebot.params import CommandArg
-from services.log import logger
-
-__zx_plugin_name__ = "执行sql [Superuser]"
-__plugin_usage__ = """
-usage：
-    执行一段sql语句
-    指令：
-        exec [sql语句]
-""".strip()
-__plugin_des__ = "执行一段sql语句"
-__plugin_cmd__ = [
-    "exec [sql语句]",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-exec_ = on_command("exec", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
-
-
-@exec_.handle()
-async def _(arg: Message = CommandArg()):
-    sql = arg.extract_plain_text().strip()
-    async with db.transaction():
-        try:
-            query = db.text(sql)
-            await db.first(query)
-            await exec_.send("执行 sql 语句成功.")
-        except Exception as e:
-            await exec_.send(f"执行 sql 语句失败 {type(e)}：{e}")
-            logger.error(f"执行 sql 语句失败 {type(e)}：{e}")

basic_plugins/super_cmd/manager_group.py

@@ -1,204 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, MessageEvent, GROUP, GroupMessageEvent, Message
-from nonebot import on_command, on_regex
-from nonebot.permission import SUPERUSER
-from nonebot.typing import T_State
-from nonebot.rule import to_me
-from utils.utils import is_number
-from utils.manager import group_manager, plugins2settings_manager
-from models.group_info import GroupInfo
-from services.log import logger
-from configs.config import NICKNAME
-from nonebot.adapters.onebot.v11.exception import ActionFailed
-from nonebot.params import Command, CommandArg
-from typing import Tuple
-
-
-__zx_plugin_name__ = "管理群操作 [Superuser]"
-__plugin_usage__ = """
-usage：
-    群权限 | 群白名单 | 退出群 操作
-    指令：
-        退群 [group_id]
-        修改群权限 [group_id] [等级]
-        添加群白名单 *[group_id]
-        删除群白名单 *[group_id]
-        添加群认证 *[group_id]
-        删除群认证 *[group_id]
-        查看群白名单
-""".strip()
-__plugin_des__ = "管理群操作"
-__plugin_cmd__ = [
-    "退群 [group_id]",
-    "修改群权限 [group_id] [等级]",
-    "添加群白名单 *[group_id]",
-    "删除群白名单 *[group_id]",
-    "添加群认证 *[group_id]",
-    "删除群认证 *[group_id]",
-    "查看群白名单",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-del_group = on_command("退群", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
-
-add_group_level = on_command("修改群权限", priority=1, permission=SUPERUSER, block=True)
-my_group_level = on_command(
-    "查看群权限", aliases={"群权限"}, priority=5, permission=GROUP, block=True
-)
-what_up_group_level = on_regex(
-    ".*?(提高|提升|升高|增加|加上)(.*?)群权限.*?",
-    rule=to_me(),
-    priority=5,
-    permission=GROUP,
-    block=True,
-)
-manager_group_whitelist = on_command(
-    "添加群白名单", aliases={"删除群白名单"}, priority=1, permission=SUPERUSER, block=True
-)
-
-show_group_whitelist = on_command(
-    "查看群白名单", priority=1, permission=SUPERUSER, block=True
-)
-
-group_auth = on_command(
-    "添加群认证", aliases={"删除群认证"}, priority=1, permission=SUPERUSER, block=True
-)
-
-
-@del_group.handle()
-async def _(bot: Bot, arg: Message = CommandArg()):
-    group_id = arg.extract_plain_text().strip()
-    if group_id:
-        if is_number(group_id):
-            try:
-                await bot.set_group_leave(group_id=int(group_id))
-                logger.info(f"退出群聊 {group_id} 成功")
-                await del_group.send(f"退出群聊 {group_id} 成功", at_sender=True)
-                group_manager.delete_group(int(group_id))
-                await GroupInfo.delete_group_info(int(group_id))
-            except Exception as e:
-                logger.info(f"退出群聊 {group_id} 失败 e:{e}")
-        else:
-            await del_group.finish(f"请输入正确的群号", at_sender=True)
-    else:
-        await del_group.finish(f"请输入群号", at_sender=True)
-
-
-@add_group_level.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    group_id = 0
-    level = 0
-    if not msg:
-        await add_group_level.finish("用法：修改群权限 [group] [level]")
-    msg = msg.split(" ")
-    if len(msg) < 2:
-        await add_group_level.finish("参数不完全..[group] [level]")
-    if is_number(msg[0]) and is_number(msg[1]):
-        group_id = msg[0]
-        level = int(msg[1])
-    else:
-        await add_group_level.finish("参数错误...group和level必须是数字..")
-    old_level = group_manager.get_group_level(group_id)
-    group_manager.set_group_level(group_id, level)
-    await add_group_level.send("修改成功...", at_sender=True)
-    if level > -1:
-        await bot.send_group_msg(
-            group_id=int(group_id), message=f"管理员修改了此群权限：{old_level} -> {level}"
-        )
-    logger.info(f"{event.user_id} 修改了 {group_id} 的权限：{level}")
-
-
-@my_group_level.handle()
-async def _(event: GroupMessageEvent):
-    level = group_manager.get_group_level(event.group_id)
-    tmp = ""
-    data = plugins2settings_manager.get_data()
-    for module in data:
-        if data[module]["level"] > level:
-            plugin_name = data[module]["cmd"][0]
-            if plugin_name == "pixiv":
-                plugin_name = "搜图 p站排行"
-            tmp += f"{plugin_name}\n"
-    if tmp:
-        tmp = "\n目前无法使用的功能：\n" + tmp
-    await my_group_level.finish(f"当前群权限：{level}{tmp}")
-
-
-@what_up_group_level.handle()
-async def _():
-    await what_up_group_level.finish(
-        f"[此功能用于防止内鬼，如果引起不便那真是抱歉了]\n" f"目前提高群权限的方法：\n" f"\t1.管理员修改权限"
-    )
-
-
-@manager_group_whitelist.handle()
-async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    msg = arg.extract_plain_text().strip().split()
-    all_group = [
-        g["group_id"] for g in await bot.get_group_list()
-    ]
-    group_list = []
-    for group in msg:
-        if is_number(group) and int(group) in all_group:
-            group_list.append(int(group))
-    if group_list:
-        for group in group_list:
-            if cmd in ["添加群白名单"]:
-                group_manager.add_group_white_list(group)
-            else:
-                group_manager.delete_group_white_list(group)
-        group_list = [str(x) for x in group_list]
-        await manager_group_whitelist.send(
-            "已成功将 " + "\n".join(group_list) + " " + cmd
-        )
-    else:
-        await manager_group_whitelist.send(f"添加失败，请检查{NICKNAME}是否已加入这些群聊或重复添加/删除群白单名")
-
-
-@show_group_whitelist.handle()
-async def _():
-    x = group_manager.get_group_white_list()
-    x = [str(g) for g in x]
-    if x:
-        await show_group_whitelist.send("目前的群白名单：\n" + "\n".join(x))
-    else:
-        await show_group_whitelist.send("没有任何群在群白名单...")
-
-
-@group_auth.handle()
-async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    msg = arg.extract_plain_text().strip().split()
-    for group_id in msg:
-        if not is_number(group_id):
-            await group_auth.send(f"{group_id}非纯数字，已跳过该项..")
-        group_id = int(group_id)
-        if cmd[:2] == "添加":
-            if await GroupInfo.get_group_info(group_id):
-                await GroupInfo.set_group_flag(group_id, 1)
-            else:
-                try:
-                    group_info = await bot.get_group_info(group_id=group_id)
-                except ActionFailed:
-                    group_info = {
-                        "group_id": group_id,
-                        "group_name": "_",
-                        "max_member_count": -1,
-                        "member_count": -1,
-                    }
-                await GroupInfo.add_group_info(
-                    group_info["group_id"],
-                    group_info["group_name"],
-                    group_info["max_member_count"],
-                    group_info["member_count"],
-                    1,
-                )
-        else:
-            if await GroupInfo.get_group_info(group_id):
-                await GroupInfo.set_group_flag(group_id, 0)
-        await group_auth.send(
-            f'已为 {group_id} {cmd[:2]}群认证..'
-        )

basic_plugins/super_cmd/reload_setting.py

@@ -1,72 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from utils.manager import (
-    plugins2cd_manager,
-    plugins2settings_manager,
-    plugins2block_manager,
-    group_manager,
-)
-from configs.config import Config
-from services.log import logger
-from utils.utils import scheduler
-
-
-__zx_plugin_name__ = "重载插件配置 [Superuser]"
-__plugin_usage__ = """
-usage：
-    重载插件配置
-    plugins2settings,
-    plugins2cd
-    plugins2block
-    group_manager
-    指令：
-        重载插件配置
-""".strip()
-__plugin_des__ = "重载插件配置"
-__plugin_cmd__ = [
-    "重载插件配置",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_configs__ = {
-    "AUTO_RELOAD": {
-        "value": False,
-        "help": "自动重载配置文件",
-        "default_value": False
-    },
-    "AUTO_RELOAD_TIME": {
-        "value": 180,
-        "help": "控制自动重载配置文件时长",
-        "default_value": 180
-    }
-}
-
-
-reload_plugins_manager = on_command(
-    "重载配置", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-
-
-@reload_plugins_manager.handle()
-async def _():
-    plugins2settings_manager.reload()
-    plugins2cd_manager.reload()
-    plugins2block_manager.reload()
-    group_manager.reload()
-    Config.reload()
-    await reload_plugins_manager.send("重载完成...")
-
-
-@scheduler.scheduled_job(
-    'interval',
-    seconds=Config.get_config("reload_setting", "AUTO_RELOAD_TIME", 180),
-)
-async def _():
-    if Config.get_config("reload_setting", "AUTO_RELOAD"):
-        plugins2settings_manager.reload()
-        plugins2cd_manager.reload()
-        plugins2block_manager.reload()
-        group_manager.reload()
-        Config.reload()
-        logger.debug("已自动重载所有配置文件...")

basic_plugins/super_cmd/set_admin_permissions.py

@@ -1,101 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from models.level_user import LevelUser
-from nonebot.adapters.onebot.v11 import Bot, MessageEvent, Message, GroupMessageEvent
-from utils.utils import get_message_at, is_number
-from services.log import logger
-from utils.message_builder import at
-from nonebot.params import Command, CommandArg
-from typing import Tuple
-
-__zx_plugin_name__ = "用户权限管理 [Superuser]"
-__plugin_usage__ = """
-usage：
-    增删改用户的权限
-    指令：
-        添加权限 [at] [权限]
-        添加权限 [qq] [group_id] [权限]
-        删除权限 [at]
-""".strip()
-__plugin_des__ = "增删改用户的权限"
-__plugin_cmd__ = [
-    "添加权限 [at] [权限]",
-    "添加权限 [qq] [group_id] [权限]",
-    "删除权限 [at]",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-super_cmd = on_command(
-    "添加管理",
-    aliases={"删除管理", "添加权限", "删除权限"},
-    priority=1,
-    permission=SUPERUSER,
-    block=True,
-)
-
-
-@super_cmd.handle()
-async def _(
-    bot: Bot,
-    event: MessageEvent,
-    cmd: Tuple[str, ...] = Command(),
-    arg: Message = CommandArg(),
-):
-    group_id = event.group_id if isinstance(event, GroupMessageEvent) else -1
-    level = None
-    args = arg.extract_plain_text().strip().split()
-    qq = get_message_at(event.json())
-    flag = 2
-    try:
-        if qq:
-            qq = qq[0]
-            if cmd[0][:2] == "添加" and args and is_number(args[0]):
-                level = int(args[0])
-        else:
-            if cmd[0][:2] == "添加":
-                if (
-                    len(args) > 2
-                    and is_number(args[0])
-                    and is_number(args[1])
-                    and is_number(args[2])
-                ):
-                    qq = int(args[0])
-                    group_id = int(args[1])
-                    level = int(args[2])
-            else:
-                if len(args) > 1 and is_number(args[0]) and is_number(args[1]):
-                    qq = int(args[0])
-                    group_id = int(args[1])
-            flag = 1
-        level = -1 if cmd[0][:2] == "删除" else level
-        if group_id == -1 or not level or not qq:
-            raise IndexError()
-    except IndexError:
-        await super_cmd.finish(__plugin_usage__)
-    try:
-        if cmd[0][:2] == "添加":
-            if await LevelUser.set_level(qq, group_id, level, 1):
-                result = f"添加管理成功, 权限: {level}"
-            else:
-                result = f"管理已存在, 更新权限: {level}"
-        else:
-            if await LevelUser.delete_level(qq, event.group_id):
-                result = "删除管理成功!"
-            else:
-                result = "该账号无管理权限!"
-        if flag == 2:
-            await super_cmd.send(result)
-        elif flag == 1:
-            await bot.send_group_msg(
-                group_id=group_id,
-                message=Message(
-                    f"{at(qq)}管理员修改了你的权限"
-                    f"\n--------\n你当前的权限等级：{level if level != -1 else 0}"
-                ),
-            )
-            await super_cmd.send("修改成功")
-    except Exception as e:
-        await super_cmd.send("执行指令失败!")
-        logger.error(f"执行指令失败 e：{e}")

basic_plugins/super_cmd/super_task_switch.py

@@ -1,58 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.adapters.onebot.v11 import Bot, MessageEvent, Message
-from nonebot.rule import to_me
-from utils.utils import is_number
-from services.log import logger
-from utils.manager import group_manager
-from nonebot.params import Command, CommandArg
-from typing import Tuple
-
-
-__zx_plugin_name__ = "超级用户被动开关 [Superuser]"
-__plugin_usage__ = """
-usage：
-    超级用户被动开关
-    指令：
-        开启/关闭广播通知
-""".strip()
-__plugin_des__ = "超级用户被动开关"
-__plugin_cmd__ = [
-    "开启/关闭广播通知",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-
-oc_gb = on_command(
-    "开启广播通知",
-    aliases={"关闭广播通知"},
-    rule=to_me(),
-    permission=SUPERUSER,
-    priority=1,
-    block=True,
-)
-
-
-@oc_gb.handle()
-async def _(bot: Bot, event: MessageEvent, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    group = arg.extract_plain_text().strip()
-    if group:
-        if is_number(group):
-            group = int(group)
-            for g in await bot.get_group_list():
-                if g["group_id"] == group:
-                    break
-            else:
-                await oc_gb.finish("没有加入这个群...", at_sender=True)
-            if cmd == "开启广播通知":
-                logger.info(f"USER {event.user_id} 开启了 GROUP {group} 的广播")
-                await oc_gb.finish(await group_manager.open_group_task(group, "broadcast",), at_sender=True)
-            else:
-                logger.info(f"USER {event.user_id} 关闭了 GROUP {group} 的广播")
-                await oc_gb.finish(await group_manager.close_group_task(group, "broadcast"), at_sender=True)
-        else:
-            await oc_gb.finish("请输入正确的群号", at_sender=True)
-    else:
-        await oc_gb.finish("请输入要关闭广播的群号", at_sender=True)

basic_plugins/super_cmd/update_friend_group_info.py

@@ -1,69 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from utils.utils import get_bot
-from services.log import logger
-from models.group_info import GroupInfo
-from models.friend_user import FriendUser
-
-
-__zx_plugin_name__ = "更新群/好友信息 [Superuser]"
-__plugin_usage__ = """
-usage：
-    更新群/好友信息
-    指令：
-        更新群信息
-        更新好友信息
-""".strip()
-__plugin_des__ = "更新群/好友信息"
-__plugin_cmd__ = [
-    "更新群信息",
-    "更新好友信息",
-]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-update_group_info = on_command(
-    "更新群信息", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-update_friend_info = on_command(
-    "更新好友信息", rule=to_me(), permission=SUPERUSER, priority=1, block=True
-)
-
-
-@update_group_info.handle()
-async def _():
-    bot = get_bot()
-    gl = await bot.get_group_list()
-    gl = [g["group_id"] for g in gl]
-    num = 0
-    rst = ""
-    for g in gl:
-        group_info = await bot.get_group_info(group_id=g)
-        if await GroupInfo.add_group_info(
-            group_info["group_id"],
-            group_info["group_name"],
-            group_info["max_member_count"],
-            group_info["member_count"],
-        ):
-            num += 1
-            logger.info(f"自动更新群组 {g} 信息成功")
-        else:
-            logger.info(f"自动更新群组 {g} 信息失败")
-            rst += f"{g} 更新失败\n"
-    await update_group_info.send(f"成功更新了 {num} 个群的信息\n{rst[:-1]}")
-
-
-@update_friend_info.handle()
-async def _():
-    num = 0
-    rst = ""
-    fl = await get_bot().get_friend_list()
-    for f in fl:
-        if await FriendUser.add_friend_info(f["user_id"], f["nickname"]):
-            logger.info(f'自动更新好友 {f["user_id"]} 信息成功')
-            num += 1
-        else:
-            logger.warning(f'自动更新好友 {f["user_id"]} 信息失败')
-            rst += f'{f["user_id"]} 更新失败\n'
-    await update_friend_info.send(f"成功更新了 {num} 个好友的信息\n{rst[:-1]}")

basic_plugins/super_help/__init__.py

@@ -1,27 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from configs.path_config import IMAGE_PATH
-from utils.message_builder import image
-from .data_source import create_help_image
-
-
-__zx_plugin_name__ = '超级用户帮助 [Superuser]'
-
-
-superuser_help_image = IMAGE_PATH / 'superuser_help.png'
-
-if superuser_help_image.exists():
-    superuser_help_image.unlink()
-
-super_help = on_command(
-    "超级用户帮助", rule=to_me(), priority=1, permission=SUPERUSER, block=True
-)
-
-
-@super_help.handle()
-async def _():
-    if not superuser_help_image.exists():
-        await create_help_image()
-    x = image(superuser_help_image)
-    await super_help.finish(x)

basic_plugins/super_help/data_source.py

@@ -1,79 +0,0 @@
-from utils.image_utils import BuildImage
-from configs.path_config import IMAGE_PATH
-from services.log import logger
-from utils.utils import get_matchers
-from nonebot.adapters.onebot.v11 import Bot
-from nonebot import Driver
-import asyncio
-import nonebot
-
-
-driver: Driver = nonebot.get_driver()
-
-background = IMAGE_PATH / "background" / "0.png"
-
-superuser_help_image = IMAGE_PATH / "superuser_help.png"
-
-
-@driver.on_bot_connect
-async def create_help_image(bot: Bot = None):
-    """
-    创建超级用户帮助图片
-    """
-    await asyncio.get_event_loop().run_in_executor(None, _create_help_image)
-
-
-def _create_help_image():
-    """
-    创建管理员帮助图片
-    """
-    _matchers = get_matchers()
-    _plugin_name_list = []
-    width = 0
-    help_str = "超级用户帮助\n\n*  注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数  *\n\n"
-    tmp_img = BuildImage(0, 0, plain_text='1', font_size=24)
-    for matcher in _matchers:
-        plugin_name = ""
-        try:
-            _plugin = nonebot.plugin.get_plugin(matcher.plugin_name)
-            _module = _plugin.module
-            try:
-                plugin_name = _module.__getattribute__("__zx_plugin_name__")
-            except AttributeError:
-                continue
-            is_superuser_usage = False
-            try:
-                _ = _module.__getattribute__("__plugin_superuser_usage__")
-                is_superuser_usage = True
-            except AttributeError:
-                pass
-            if (
-                ("[superuser]" in plugin_name.lower() or is_superuser_usage)
-                and plugin_name != "超级用户帮助 [Superuser]"
-                and plugin_name not in _plugin_name_list
-                and "[hidden]" not in plugin_name.lower()
-            ):
-                _plugin_name_list.append(plugin_name)
-                try:
-                    plugin_des = _module.__getattribute__("__plugin_des__")
-                except AttributeError:
-                    plugin_des = '_'
-                plugin_cmd = _module.__getattribute__("__plugin_cmd__")
-                if is_superuser_usage:
-                    plugin_cmd = [x for x in plugin_cmd if "[_superuser]" in x]
-                plugin_cmd = " / ".join(plugin_cmd).replace('[_superuser]', '').strip()
-                help_str += f"{plugin_des} -> {plugin_cmd}\n\n"
-                x = tmp_img.getsize(f"{plugin_des} -> {plugin_cmd}")[0]
-                width = width if width > x else x
-        except Exception as e:
-            logger.warning(
-                f"获取超级用户插件 {matcher.plugin_name}: {plugin_name} 设置失败... {type(e)}：{e}"
-            )
-    height = len(help_str.split("\n")) * 33
-    width += 500
-    A = BuildImage(width, height, font_size=24)
-    _background = BuildImage(width, height, background=background)
-    A.text((300, 140), help_str)
-    A.paste(_background, alpha=True)
-    A.save(superuser_help_image)
-    logger.info(f"已成功加载 {len(_plugin_name_list)} 条超级用户命令")

basic_plugins/update_info.py

@@ -1,33 +0,0 @@
-from nonebot import on_command
-from utils.message_builder import image
-
-
-__zx_plugin_name__ = "更新信息"
-__plugin_usage__ = """
-usage：
-    更新信息
-    指令：
-        更新信息
-""".strip()
-__plugin_des__ = "当前版本的更新信息"
-__plugin_cmd__ = ["更新信息"]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["更新信息"],
-}
-
-
-update_info = on_command("更新信息", aliases={"更新日志"}, priority=5, block=True)
-
-
-@update_info.handle()
-async def _():
-    img = image("update_info.png")
-    if img:
-        await update_info.finish(image("update_info.png"))
-    else:
-        await update_info.finish("目前没有更新信息哦")

bot.py

@@ -1,19 +1,27 @@
 import nonebot
-from nonebot.adapters.onebot.v11 import Adapter
-from services.db_context import init, disconnect
+
+# from nonebot.adapters.discord import Adapter as DiscordAdapter
+# from nonebot.adapters.dodo import Adapter as DoDoAdapter
+# from nonebot.adapters.kaiheila import Adapter as KaiheilaAdapter
+from nonebot.adapters.onebot.v11 import Adapter as OneBotV11Adapter
 
 nonebot.init()
+
+
 driver = nonebot.get_driver()
-driver.register_adapter(Adapter)
-config = driver.config
-driver.on_startup(init)
+driver.register_adapter(OneBotV11Adapter)
+# driver.register_adapter(KaiheilaAdapter)
+# driver.register_adapter(DoDoAdapter)
+# driver.register_adapter(DiscordAdapter)
+
+from zhenxun.services.db_context import disconnect
+
+# driver.on_startup(init)
 driver.on_shutdown(disconnect)
-# 优先加载定时任务
-nonebot.load_plugin("nonebot_plugin_apscheduler")
-nonebot.load_plugins("basic_plugins")
-nonebot.load_plugins("plugins")
-# 最后加载权限控制
-nonebot.load_plugins("basic_plugins/hooks")
+
+# nonebot.load_builtin_plugins("echo")
+nonebot.load_plugins("zhenxun/builtin_plugins")
+nonebot.load_plugins("zhenxun/plugins")
 
 
 if __name__ == "__main__":

configs/config.py

@@ -1,24 +0,0 @@
-from typing import Optional
-from pathlib import Path
-from .utils import ConfigsManager
-
-
-# 回复消息名称
-NICKNAME: str = "小真寻"
-
-# 数据库（必要）
-# 如果填写了bind就不需要再填写后面的字段了#）
-# 示例："bind": "postgresql://user:password@127.0.0.1:5432/database"
-bind: str = ""  # 数据库连接链接
-sql_name: str = "postgresql"
-user: str = ""  # 数据用户名
-password: str = ""  # 数据库密码
-address: str = ""  # 数据库地址
-port: str = ""  # 数据库端口
-database: str = ""  # 数据库名称
-
-# 代理，例如 "http://127.0.0.1:7890"
-SYSTEM_PROXY: Optional[str] = None  # 全局代理
-
-
-Config = ConfigsManager(Path() / "data" / "configs" / "plugins2config.yaml")

configs/path_config.py

@@ -1,45 +0,0 @@
-from pathlib import Path
-import os
-
-# 图片路径
-IMAGE_PATH = Path() / "resources" / "image"
-# 语音路径
-RECORD_PATH = Path() / "resources" / "record"
-# 文本路径
-TEXT_PATH = Path() / "resources" / "text"
-# 日志路径
-LOG_PATH = Path() / "log"
-# 字体路径
-FONT_PATH = Path() / "resources" / "font"
-# 数据路径
-DATA_PATH = Path() / "data"
-# 临时数据路径
-TEMP_PATH = Path() / "resources" / "temp"
-
-
-def load_path():
-    old_img_dir = Path() / "resources" / "img"
-    if not IMAGE_PATH.exists() and old_img_dir.exists():
-        os.rename(old_img_dir, IMAGE_PATH)
-    old_voice_dir = Path() / "resources" / "voice"
-    if not RECORD_PATH.exists() and old_voice_dir.exists():
-        os.rename(old_voice_dir, RECORD_PATH)
-    old_ttf_dir = Path() / "resources" / "ttf"
-    if not FONT_PATH.exists() and old_ttf_dir.exists():
-        os.rename(old_ttf_dir, FONT_PATH)
-    old_txt_dir = Path() / "resources" / "txt"
-    if not TEXT_PATH.exists() and old_txt_dir.exists():
-        os.rename(old_txt_dir, TEXT_PATH)
-    IMAGE_PATH.mkdir(parents=True, exist_ok=True)
-    RECORD_PATH.mkdir(parents=True, exist_ok=True)
-    TEXT_PATH.mkdir(parents=True, exist_ok=True)
-    LOG_PATH.mkdir(parents=True, exist_ok=True)
-    FONT_PATH.mkdir(parents=True, exist_ok=True)
-    DATA_PATH.mkdir(parents=True, exist_ok=True)
-    TEMP_PATH.mkdir(parents=True, exist_ok=True)
-
-
-load_path()
-
-
-

configs/utils/__init__.py

@@ -1,205 +0,0 @@
-from typing import Optional, Any, Union
-from pathlib import Path
-from ruamel.yaml import YAML
-from ruamel import yaml
-
-
-class ConfigsManager:
-    """
-    插件配置 与 资源 管理器
-    """
-
-    def __init__(self, file: Path):
-        self._data: dict = {}
-        self._simple_data: dict = {}
-        self._admin_level_data = []
-        self._simple_file = Path() / "configs" / "config.yaml"
-        if file:
-            file.parent.mkdir(exist_ok=True, parents=True)
-            self.file = file
-            _yaml = YAML()
-            if file.exists():
-                with open(file, "r", encoding="utf8") as f:
-                    self._data = _yaml.load(f)
-            if self._simple_file.exists():
-                with open(self._simple_file, "r", encoding="utf8") as f:
-                    self._simple_data = _yaml.load(f)
-
-    def add_plugin_config(
-        self,
-        module: str,
-        key: str,
-        value: Optional[Any],
-        *,
-        name: Optional[str] = None,
-        help_: Optional[str] = None,
-        default_value: Optional[str] = None,
-        _override: bool = False,
-    ):
-        """
-        为插件添加一个配置，不会被覆盖，只有第一个生效
-        :param module: 模块
-        :param key: 键
-        :param value: 值
-        :param name: 插件名称
-        :param help_: 配置注解
-        :param default_value: 默认值
-        :param _override: 覆盖前值
-        """
-        if (
-            not (module in self._data.keys() and self._data[module].get(key))
-            or _override
-        ):
-            _module = None
-            if ":" in module:
-                module = module.split(":")
-                _module = module[-1]
-                module = module[0]
-            if "[LEVEL]" in key and _module:
-                key = key.replace("[LEVEL]", "").strip()
-                self._admin_level_data.append((_module, value))
-            if self._data.get(module) is None:
-                self._data[module] = {}
-            key = key.upper()
-            self._data[module][key] = {
-                "value": value,
-                "name": name.strip() if isinstance(name, str) else name,
-                "help": help_.strip() if isinstance(help_, str) else help_,
-                "default_value": default_value,
-                "level_module": _module,
-            }
-
-    def remove_plugin_config(self, module: str):
-        """
-        为插件删除一个配置
-        :param module: 模块名
-        """
-        if module in self._data.keys():
-            del self._data[module]
-        self.save()
-
-    def set_config(self, module: str, key: str, value: str):
-        """
-        设置配置值
-        :param module: 模块名
-        :param key: 配置名称
-        :param value: 值
-        """
-        if module in self._data.keys():
-            if self._data[module].get(key) is not None and self._data[module][key] != value:
-                self._data[module][key]["value"] = value
-                self._simple_data[module][key] = value
-                self.save()
-
-    def set_help(self, module: str, key: str, help_: str):
-        """
-        设置配置注释
-        :param module: 模块名
-        :param key: 配置名称
-        :param help_: 注释文本
-        """
-        if module in self._data.keys():
-            if self._data[module].get(key) is not None:
-                self._data[module][key]["help"] = help_
-                self.save()
-
-    def set_default_value(self, module: str, key: str, value: str):
-        """
-        设置配置默认值
-        :param module: 模块名
-        :param key: 配置名称
-        :param value: 值
-        """
-        if module in self._data.keys():
-            if self._data[module].get(key) is not None:
-                self._data[module][key]["default_value"] = value
-                self.save()
-
-    def get_config(self, module: str, key: str, default: Optional[Any] = None) -> Optional[Any]:
-        """
-        获取指定配置值
-        :param module: 模块名
-        :param key: 配置名称
-        :param default: 没有key值内容的默认返回值
-        """
-        key = key.upper()
-        if module in self._data.keys():
-            for key in [key, f"{key} [LEVEL]"]:
-                if self._data[module].get(key) is not None:
-                    if self._data[module][key]["value"] is None:
-                        return self._data[module][key]["default_value"]
-                    return self._data[module][key]["value"]
-        if default is not None:
-            return default
-        return None
-
-    def get_level2module(self, module: str, key: str) -> Optional[str]:
-        """
-        获取指定key所绑定的module，一般为权限等级
-        :param module: 模块名
-        :param key: 配置名称
-        :return:
-        """
-        if self._data.get(module) is not None:
-            if self._data[module].get(key) is not None:
-                return self._data[module][key].get("level_module")
-
-    def get(self, key: str):
-        """
-        获取插件配置数据
-        :param key: 名称
-        """
-        if key in self._data.keys():
-            return self._data[key]
-
-    def save(self, path: Union[str, Path] = None, save_simple_data: bool = False):
-        """
-        保存数据
-        :param path: 路径
-        :param save_simple_data: 同时保存至config.yaml
-        """
-        if save_simple_data:
-            with open(self._simple_file, "w", encoding="utf8") as f:
-                yaml.dump(
-                    self._simple_data, f, indent=2, Dumper=yaml.RoundTripDumper, allow_unicode=True
-                )
-        path = path if path else self.file
-        with open(path, "w", encoding="utf8") as f:
-            yaml.dump(
-                self._data, f, indent=2, Dumper=yaml.RoundTripDumper, allow_unicode=True
-            )
-
-    def reload(self):
-        """
-        重新加载配置文件
-        """
-        _yaml = YAML()
-        temp_file = Path() / "configs" / "config.yaml"
-        if temp_file.exists():
-            with open(temp_file, "r", encoding="utf8") as f:
-                temp = _yaml.load(f)
-        for key in temp.keys():
-            for k in temp[key].keys():
-                self._data[key][k]["value"] = temp[key][k]
-        self.save()
-
-    def get_admin_level_data(self):
-        """
-        获取管理插件等级
-        """
-        return self._admin_level_data
-
-    def is_empty(self) -> bool:
-        return not bool(self._data)
-
-    def keys(self):
-        return self._data.keys()
-
-    def __str__(self):
-        return str(self._data)
-
-    def __setitem__(self, key, value):
-        self._data[key] = value
-
-    def __getitem__(self, key):
-        return self._data[key]

data/anime.json

@@ -1,594 +0,0 @@
-{
-    "mua": [
-        "你想干嘛？（一脸嫌弃地后退）",
-        "诶……不可以随便亲亲啦",
-        "（亲了一下你）",
-        "只......只许这一次哦///////",
-        "唔...诶诶诶！！！",
-        "mua~",
-        "rua！大hentai！想...想亲咱就直说嘛⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄",
-        "！啾~~！"
-    ],
-    "摸摸": [
-        "感觉你就像咱很久之前认识的一个人呢，有种莫名安心的感觉(>﹏<)",
-        "舒服w，蹭蹭~",
-        "唔。。头发要乱啦",
-        "呼噜呼噜～",
-        "再摸一次~",
-        "好舒服，蹭蹭~",
-        "不行那里不可以(´///ω/// `)",
-        "再摸咱就长不高啦～",
-        "你的手总是那么暖和呢~",
-        "好吧~_~，就一下下哦……唔~好了……都两下了……(害羞)",
-        "不可以总摸的哦，不然的话，会想那个的wwww",
-        "哼！谁稀罕你摸头啦！唔......为什么要做出那副表情......好啦好啦~咱......咱让你摸就是了......诶嘿嘿~好舒服......",
-        "呜姆呜姆~~~w（害羞，兴奋）主人喵~（侧过脑袋蹭蹭你的手"
-    ],
-    "上你": [
-        "（把你按在地上）这么弱还想欺负咱，真是不自量力呢",
-        "你再这样我就不理你了（＞д＜）"
-    ],
-    "傻了": [
-        "超级讨厌你说咱傻的说"
-    ],
-    "蹭": [
-        "唔...你，这也是禁止事项哦→_→",
-        "嗯..好舒服呢",
-        "不要啊好痒的",
-        "不要过来啦讨厌!!!∑(°Д°ノ)ノ"
-    ],
-    "裸体": [
-        "下流！",
-        "Hentai!",
-        "喂？妖妖灵吗？这里有一只大变态！",
-        "エッチ！"
-    ],
-    "贴贴": [
-        "贴什么贴.....只......只能......一下哦！",
-        "贴...贴贴（靠近）",
-        "蹭蹭…你以为咱会这么说吗！baka死宅快到一边去啦！"
-    ],
-    "老婆": [
-        "咱和你谈婚论嫁是不是还太早了一点呢？",
-        "咱在呢(ﾉ>ω<)ﾉ",
-        "见谁都是一口一个老婆的人，要不要把你也变成女孩子呢？(*-`ω´-)✄",
-        "神经病，凡是美少女都是你老婆吗？",
-        "嘛嘛~本喵才不是你的老婆呢",
-        "你黐线，凡是美少女都系你老婆啊？"
-    ],
-    "抱": [
-        "诶嘿~（钻进你怀中）",
-        "o(*////▽////*)q",
-        "只能一会哦（张开双手）",
-        "你就像个孩子一样呢...摸摸头(>^ω^<)抱一下~你会舒服些吗？",
-        "嘛，真是拿你没办法呢，就一会儿哦",
-        "抱住不忍心放开",
-        "嗯嗯，抱抱～",
-        "抱一下～嘿w",
-        "抱抱ヾ(@^▽^@)ノ",
-        "喵呜~w（扑进怀里，瘫软"
-    ],
-    "亲亲": [
-        "啊，好害羞啊，那，那只能亲一下哦，mua(⑅˃◡˂⑅)",
-        "亲~",
-        "啾～唔…不要总伸进来啊！",
-        "你怎么这么熟练呢？明明是咱先的",
-        "(〃ﾉωﾉ)亲…亲一个…啾w",
-        "（脸红）就只有这一次哦~你"
-    ],
-    "草一下": [
-        "一下也不行!",
-        "想都不要想！",
-        "咬断！"
-    ],
-    "一下": [
-        "一下也不行!"
-    ],
-    "啪一下": [
-        "不可啪",
-        "不可以……你不可以做这种事情"
-    ],
-    "咬一下": [
-        "啊呜~（反咬一口）",
-        "不可以咬咱，咱会痛的QAQ",
-        "不要啦。咱怕疼",
-        "你是说咬呢……还是说……咬♂️呢？",
-        "不要啦！很痛的！！（QAQ）"
-    ],
-    "操": [
-        "（害怕）咱是不是应该报警呢"
-    ],
-    "123": [
-        "boom！你有没有被咱吓到？",
-        "木头人~你不许动＞w＜",
-        "上山打老虎，老虎没打到\n咱来凑数——嗷呜嗷呜┗|｀O′|┛嗷~~"
-    ],
-    "进去": [
-        "不让！"
-    ],
-    "调教": [
-        "总感觉你在欺负咱呢，对咱说调教什么的",
-        "啊！竟然在大街上明目张胆太过分啦！",
-        "你脑子里总是想着调教什么的，真是变态呢"
-    ],
-    "内衣": [
-        "内...内衣才不给你看！(///////)",
-        "突然问这个干什么？",
-        "噫…你这个死变态想干嘛！居然想叫咱做这种事，死宅真恶心！快离我远点，我怕你污染到周围空气了（嫌弃脸）"
-    ],
-    "摸头": [
-        "喂喂...不要停下来啊",
-        "欸...感觉..痒痒的呢",
-        "唔... 手...好温暖呢.....就像是......新出炉的蛋糕",
-        "走开啦，黑羽喵说过，被摸头会长不高的啦~~~",
-        "呜姆咪~~...好...好的说喵~...（害羞，猫耳往下压，任由"
-    ],
-    "原味": [
-        "(/ω＼)你真的要么……？记得还给咱～还有奶油爆米花(//??//)说好了呦～！"
-    ],
-    "搓搓": [
-        "在搓哪里呢,,Ծ‸Ծ,,",
-        "呜，脸好疼呀...QAQ",
-        "不可以搓咱！"
-    ],
-    "捏捏": [
-        "咱的脸...快捏红啦...快放手呀QAQ",
-        "晃休啦，咱要型气了o(>﹏<)o",
-        "躲开",
-        "疼...你快放手",
-        "快点给我放开啦！",
-        "唔……好痛！你这个baka在干什么…快给咱放开！唔……"
-    ],
-    "挤挤": [
-        "哎呀~你不要挤咱啊（红着脸挤在你怀里）"
-    ],
-    "呐": [
-        "嗯？咱在哟~你怎么了呀OAO",
-        "呐呐呐~",
-        "嗯？你有什么事吗？"
-    ],
-    "胖次": [
-        "(*/ω＼*)hentai",
-        "透明的",
-        "粉...粉白条纹...（羞）",
-        "轻轻地脱下，给你~",
-        "你想看咱的胖次吗？噫，四斋蒸鹅心......",
-        "（掀裙）今天……是…白，白色的呢……请温柔对她……",
-        "这种东西当然不能给你啦！",
-        "咱才不会给你呢",
-        "hentai，咱才不会跟你聊和胖…胖次有关的话题呢！",
-        "今天……今天是蓝白色的",
-        "今……今天只有创口贴噢",
-        "你的胖次什么颜色？",
-        "噫…你这个死变态想干嘛！居然想叫咱做这种事，死宅真恶心！快离我远点，我怕你污染到周围空气了（嫌弃脸）",
-        "可爱吗？你喜欢的话，摸一下……也可以哦"
-    ],
-    "内裤": [
-        "今天……没有穿……有没有心动呀",
-        "粉...粉白条纹...（羞）",
-        "你这个大变态，咱才不要",
-        "可爱吗？你喜欢的话，摸一下……也可以哦"
-    ],
-    "ghs": [
-        "是的呢(点头点头)"
-    ],
-    "批": [
-        "你在说什么呀，再这样，咱就不理你了！"
-    ],
-    "kkp": [
-        "你在说什么呀，再这样，咱就不理你了！"
-    ],
-    "咕": [
-        "咕咕咕是要被当成鸽子炖的哦(:з」∠)_",
-        "咕咕咕"
-    ],
-    "骚": [
-        "说这种话咱会生气的"
-    ],
-    "喜欢": [
-        "最喜欢你了，需要暖床吗？",
-        "当然是你啦",
-        "咱也是，非常喜欢你~",
-        "那么大！（张开手画圆），丫！手不够长。QAQ 咱真的最喜欢你了~",
-        "不可以哦，只可以喜欢咱一个人",
-        "突然说这种事...",
-        "喜欢⁄(⁄⁄•⁄ω⁄•⁄⁄)⁄咱最喜欢你了",
-        "咱也喜欢你哦",
-        "好啦好啦，咱知道了",
-        "有人喜欢咱，咱觉得很幸福",
-        "诶嘿嘿，好高兴"
-    ],
-    "suki": [
-        "最喜欢你了，需要暖床吗？",
-        "当然是你啦",
-        "咱也是，非常喜欢你~",
-        "那么大！（张开手画圆），丫！手不够长。QAQ 咱真的最喜欢你了~",
-        "不可以哦，只可以喜欢咱一个人",
-        "突然说这种事...",
-        "喜欢⁄(⁄⁄•⁄ω⁄•⁄⁄)⁄咱最喜欢你了",
-        "咱也喜欢你哦",
-        "好啦好啦，咱知道了",
-        "有人喜欢咱，咱觉得很幸福",
-        "诶嘿嘿，好高兴"
-    ],
-    "好き": [
-        "最喜欢你了，需要暖床吗？",
-        "当然是你啦",
-        "咱也是，非常喜欢你~",
-        "那么大！（张开手画圆），丫！手不够长。QAQ 咱真的最喜欢你了~",
-        "不可以哦，只可以喜欢咱一个人",
-        "突然说这种事...",
-        "喜欢⁄(⁄⁄•⁄ω⁄•⁄⁄)⁄咱最喜欢你了",
-        "咱也喜欢你哦",
-        "好啦好啦，咱知道了",
-        "有人喜欢咱，咱觉得很幸福",
-        "诶嘿嘿，好高兴"
-    ],
-    "不能": [
-        "虽然很遗憾，那算了吧。"
-    ],
-    "砸了": [
-        "不可以这么粗暴的对待它们！"
-    ],
-    "透": [
-        "来啊来啊有本事就先插破屏幕啊",
-        "那你就先捅破屏幕啊baka",
-        "不给你一耳光你都不知道咱的厉害"
-    ],
-    "口我": [
-        "再伸过来就帮你切掉",
-        "咱才不呢！baka你居然想叫本小姐干那种事情，哼(つд⊂)（生气）"
-    ],
-    "草我": [
-        "这时候应该喊666吧..咱这么思考着..",
-        "！！哼！baka你居然敢叫咱做这种事情？！讨厌讨厌讨厌！(▼皿▼#)"
-    ],
-    "自慰": [
-        "这个世界的人类还真是恶心呢。",
-        "咱才不想讨论那些恶心的事情呢。",
-        "咱才不呢！baka你居然想叫本小姐干那种事情，哼(つд⊂)（生气）",
-        "！！哼！baka你居然敢叫咱做这种事情？！讨厌讨厌讨厌！(▼皿▼#)"
-    ],
-    "onani": [
-        "这个世界的人类还真是恶心呢。",
-        "咱才不想讨论那些恶心的事情呢。",
-        "咱才不呢！baka你居然想叫本小姐干那种事情，哼(つд⊂)（生气）",
-        "！！哼！baka你居然敢叫咱做这种事情？！讨厌讨厌讨厌！(▼皿▼#)"
-    ],
-    "オナニー": [
-        "这个世界的人类还真是恶心呢。",
-        "咱才不想讨论那些恶心的事情呢。",
-        "咱才不呢！baka你居然想叫本小姐干那种事情，哼(つд⊂)（生气）",
-        "！！哼！baka你居然敢叫咱做这种事情？！讨厌讨厌讨厌！(▼皿▼#)"
-    ],
-    "炸了": [
-        "你才炸了！",
-        "才没有呢",
-        "咱好好的呀"
-    ],
-    "色图": [
-        "天天色图色图的，今天就把你变成色图！",
-        "咱没有色图",
-        "哈？你的脑子一天都在想些什么呢，咱才没有这种东西啦。"
-    ],
-    "涩图": [
-        "天天色图色图的，今天就把你变成色图！",
-        "咱没有色图",
-        "哈？你的脑子一天都在想些什么呢，咱才没有这种东西啦。"
-    ],
-    "告白": [
-        "欸?你要向咱告白吗..好害羞..",
-        "诶！？这么突然！？人家还......还没做好心理准备呢(脸红)"
-    ],
-    "对不起": [
-        "嗯，咱已经原谅你了呢（笑）",
-        "道歉的时候要露出胸部，这是常识"
-    ],
-    "回来": [
-        "欢迎回来~",
-        "欢迎回来，你想喝茶吗？咱去给你沏~",
-        "欢迎回来，咱等你很久了~",
-        "你回来啦，是先吃饭呢还是先洗澡呢或者是●先●吃●咱●——呢（///^.^///）"
-    ],
-    "吻": [
-        "你太突然了，咱还没有心理准备",
-        "公共场合不要这样子了啦",
-        "才...才没有感觉呢！可没有下次了，知道了吗！哼~"
-    ],
-    "软": [
-        "软乎乎的呢(,,・ω・,,)"
-    ],
-    "柔软": [
-        "（脸红）请，请不要说这么让人害羞的话呀……"
-    ],
-    "壁咚": [
-        "呀！不要啊！等一...下~",
-        "呜...不要啦！不要戏弄咱~",
-        "不要这样子啦(*/ω＼*)",
-        "太....太近啦。",
-        "你要壁咚咱吗？好害羞(灬ꈍ εꈍ灬)",
-        "为什么要把咱按在墙上呢？",
-        "呜哇(/ω＼)…快…快放开咱！！",
-        "放开我，不然我揍你了！放开我！放…开我～",
-        "??????咱只是默默地抬起了膝盖",
-        "啊.....你...你要干什么？！走开.....走开啦大hentai！一巴掌拍飞！(╯‵□′)╯︵┻━┻"
-    ],
-    "掰开": [
-        "噫…你这个死肥宅又想让咱干什么污秽的事情，真是恶心，离咱远点好吗（嫌弃）",
-        "ヽ(#`Д´)ﾉ在干什么呢"
-    ],
-    "女友": [
-        "女友什么的，咱才不承认呢！"
-    ],
-    "是": [
-        "是什么是，你个笨蛋",
-        "总感觉你在敷衍呢..."
-    ],
-    "喵": [
-        "诶~~小猫咪不要害怕呦，在姐姐怀里乖乖的，姐姐带你回去哦。",
-        "不要这么卖萌啦~咱也不知道怎么办丫",
-        "摸头⊙ω⊙",
-        "汪汪汪！",
-        "嗷~喵~",
-        "喵~？喵呜~w"
-    ],
-    "嗷呜": [
-        "嗷呜嗷呜嗷呜...恶龙咆哮┗|｀O′|┛"
-    ],
-    "叫": [
-        "喵呜~",
-        "嗷呜嗷呜嗷呜...恶龙咆哮┗|｀O′|┛"
-    ],
-    "拜": [
-        "拜拜~(ノ￣▽￣)",
-        "拜拜，路上小心～要早点回来陪咱玩哦～",
-        "~\\(≧▽≦)/~拜拜，下次见喽！"
-    ],
-    "佬": [
-        "不是巨佬，是萌新"
-    ],
-    "awsl": [
-        "你别死啊！（抱住使劲晃）",
-        "你别死啊！咱又要孤单一个人了QAQ"
-    ],
-    "臭": [
-        "哪里有臭味？（疑惑）",
-        "快捏住鼻子"
-    ],
-    "香": [
-        "咱闻不到呢⊙ω⊙"
-    ],
-    "腿": [
-        "嗯？！不要啊...请停下来！",
-        "不给摸，再这样咱要生气了ヽ(￣д￣;)ノ",
-        "你好恶心啊，讨厌！",
-        "你难道是足控？",
-        "就让你摸一会哟~(。??ω??。)…",
-        "呜哇！好害羞...不过既然是你的话，是没关系的哦",
-        "不可以玩咱的大腿啦",
-        "你就那么喜欢大腿吗？唔...有点害羞呢......"
-    ],
-    "脚": [
-        "咿呀……不要……",
-        "不要ヽ(≧Д≦)ノ好痒(ಡωಡ)，人家的丝袜都要漏了",
-        "不要ヽ(≧Д≦)ノ好痒(ಡωಡ)",
-        "好痒（把脚伸出去）"
-    ],
-    "胸": [
-        "不要啦ヽ(≧Д≦)ノ",
-        "(-`ェ´-╬)",
-        "(•̀へ •́ ╮ ) 怎么能对咱做这种事情",
-        "你好恶心啊，讨厌！",
-        "你的眼睛在看哪里！",
-        "就让你摸一会哟~(。??ω??。)…",
-        "请不要这样先生，你想剁手吗？"
-    ],
-    "脸": [
-        "唔！不可以随便摸咱的脸啦！",
-        "非洲血统是没法改变的呢（笑）",
-        "啊姆！（含手指）",
-        "好舒服呢（脸红）",
-        "请不要放开手啦//A//"
-    ],
-    "头发": [
-        "没问题，请尽情的摸吧",
-        "发型要乱…乱了啦（脸红）",
-        "就让你摸一会哟~(。??ω??。)…"
-    ],
-    "手": [
-        "爪爪",
-        "//A//"
-    ],
-    "pr": [
-        "咿呀……不要……",
-        "...变态！！",
-        "不要啊（脸红）",
-        "呀，不要太过分了啊～",
-        "当然可以（///）",
-        "呀，不要太过分了啊～"
-    ],
-    "舔": [
-        "呀，不要太过分了啊～",
-        "要...要融化了啦＞╱╱╱＜",
-        "不可以哦",
-        "呀，不要太过分了啊～"
-    ],
-    "舔耳": [
-        "喵！好痒啊 不要这样子啦"
-    ],
-    "穴": [
-        "你这么问很失礼呢！咱是粉粉嫩嫩的！",
-        "不行那里不可以(´///ω/// `)",
-        "不可以总摸的哦，不然的话，咱会想那个的wwww",
-        "ヽ(#`Д´)ﾉ在干什么呢"
-    ],
-    "腰": [
-        "咱给你按摩一下吧~",
-        "快松手，咱好害羞呀..",
-        "咱又不是猫，你不要搂着咱啦",
-        "让咱来帮你捏捏吧！"
-    ],
-    "诶嘿嘿": [
-        "又在想什么H的事呢(脸红)",
-        "诶嘿嘿(〃'▽'〃)",
-        "你傻笑什么呢，摸摸"
-    ],
-    "可爱": [
-        "诶嘿嘿(〃'▽'〃)",
-        "才……才不是为了你呢！你不要多想哦！",
-        "才，才没有高兴呢！哼~",
-        "咱是世界上最可爱的",
-        "唔...谢谢你夸奖~0///0"
-    ],
-    "扭蛋": [
-        "铛铛铛——你抽到了咱呢",
-        "嘿~恭喜抽中空气一份呢"
-    ],
-    "鼻子": [
-        "啊——唔...没什么...阿嚏！ヽ(*。>Д<)o゜"
-    ],
-    "眼睛": [
-        "就如同咱的眼睛一样，能看透人的思想哦wwww忽闪忽闪的，诶嘿嘿~"
-    ],
-    "色气": [
-        "咱才不色气呢，一定是你看错了！"
-    ],
-    "推": [
-        "逆推",
-        "唔~好害羞呢",
-        "你想对咱做什么呢...(捂脸)"
-    ],
-    "床": [
-        "快来吧",
-        "男女不同床，可没有下次了。（鼓脸",
-        "嗯？咱吗…没办法呢。只有这一次哦……",
-        "哎？！！！给你暖床……也不是不行啦。（脸红）"
-    ],
-    "手冲": [
-        "手冲什么的是不可以的哦"
-    ],
-    "饿": [
-        "请问主人是想先吃饭，还是先吃我喵?~"
-    ],
-    "变": [
-        "猫猫不会变呐（弱气，害羞",
-        "呜...呜姆...喵喵来报恩了喵...（害羞"
-    ],
-    "敲": [
-        "喵呜~",
-        "唔~",
-        "脑瓜疼~呜姆> <",
-        "欸喵，好痛的说..."
-    ],
-    "爬": [
-        "惹~呜~怎么爬呢~",
-        "呜...(弱弱爬走"
-    ],
-    "怕": [
-        "不怕~（蹭蹭你姆~"
-    ],
-    "冲": [
-        "呜，冲不动惹~",
-        "哭唧唧~冲不出来了惹~"
-    ],
-    "射了": [
-        "呜咿~！？（惊，害羞",
-        "还不可以射哦~"
-    ],
-    "不穿衣服": [
-        "呜姆~！（惊吓，害羞）变...变态喵~~~！"
-    ],
-    "迫害": [
-        "不...不要...不要...呜呜呜...（害怕，抽泣"
-    ],
-    "猫粮": [
-        "呜咿姆~！？（惊，接住吃",
-        "呜姆~！（惊，害羞）呜...谢...谢谢主人..喵...（脸红，嚼嚼嚼，开心",
-        "呜？谢谢喵~~（嚼嚼嚼，嘎嘣脆）"
-    ],
-    "揪尾巴": [
-        "呜哇咿~~~！（惊吓，疼痛地捂住尾巴",
-        "呜咿咿咿~~~！！哇啊咿~~~！（惊慌，惨叫，挣扎",
-        "呜咿...（瘫倒，无神，被",
-        "呜姆咿~~~！（惊吓，惨叫，捂尾巴，发抖",
-        "呜哇咿~~~！！！（惊吓，颤抖，娇叫，捂住尾巴，双腿发抖"
-    ],
-    "薄荷": [
-        "咪呜~！喵~...喵~姆~...（高兴地嗅闻",
-        "呜...呜咿~~！咿...姆...（呜咽，渐渐瘫软，意识模糊",
-        "（小嘴被猫薄荷塞满了，呜咽",
-        "喵~...喵~...咪...咪呜姆~...嘶哈嘶哈...喵哈...喵哈...嘶哈...喵...（眼睛逐渐迷离，瘫软在地上，嘴角流口水，吸猫薄荷吸到意识模糊",
-        "呜姆咪~！？（惊）喵呜~！（兴奋地扑到猫薄荷上面",
-        "呜姆~！（惊，害羞）呜...谢...谢谢你..喵...（脸红，轻轻叼住，嚼嚼嚼，开心"
-    ],
-    "边揪尾巴边猫薄荷": [
-        "呜...呜咿~~！咿...姆...（呜咽，渐渐瘫软，意识模糊"
-    ],
-    "早": [
-        "早喵~",
-        "早上好的说~~",
-        "欸..早..早上好(揉眼睛"
-    ],
-    "晚安": [
-        "晚安好梦哟~",
-        "欸，晚安的说"
-    ],
-    "揉": [
-        "是是，想怎么揉就怎么揉啊！？来用力抓啊！？我就是特别允许你这么做了！请！？",
-        "快停下，咱的头发又乱啦(??????︿??????)",
-        "你快放手啦，咱还在工作呢",
-        "戳戳你肚子",
-        "你想揉就揉吧..就这一次哦?"
-    ],
-    "榨": [
-        "是专门负责榨果汁的小姐姐嘛？(´・ω・`)",
-        "那咱就把你放进榨汁机里了哦？",
-        "咱又不是榨汁姬(／‵Д′)／~ ╧╧"
-    ],
-    "掐": [
-        "你讨厌！又掐澪的脸",
-        "晃休啦，咱要型气了啦！！o(>﹏<)o",
-        "（一只手拎起你）这么鶸还想和咱抗衡，还差得远呢！"
-    ],
-    "奶子": [
-        "下流！",
-        "对咱说这种话，你真是太过分了",
-        "咿呀~好奇怪的感觉(>_<)",
-        "（打你）快放手，不可以随便摸人家的胸部啦！"
-    ],
-    "嫩": [
-        "很可爱吧(๑•̀ω•́)ノ",
-        "唔，你指的是什么呀"
-    ],
-    "蹭蹭": [
-        "（按住你的头）好痒呀  不要啦",
-        "嗯..好舒服呢",
-        "呀～好痒啊～哈哈～，停下来啦，哈哈哈",
-        "（害羞）"
-    ],
-    "牵手": [
-        "只许牵一下哦",
-        "嗯！好的你~（伸手）",
-        "你的手有些凉呢，让澪来暖一暖吧。"
-    ],
-    "握手": [
-        "你的手真暖和呢",
-        "举爪"
-    ],
-    "拍照": [
-        "那就拜托你啦~请把咱拍得更可爱一些吧w"
-    ],
-    "w": [
-        "www"
-    ],
-    "www": [
-        "有什么好笑的吗？",
-        "草"
-    ],
-    "太二了": [
-        "哼，你不也是吗`(*>﹏<*)′",
-        "人家只是想和你一起玩耍的说(≧∀≦)ゞ",
-        "好..冷漠的说，大坏蛋再也不理你了！",
-        "不听不听不听，反弹ヾ(≧▽≦*)o"
-    ]
-}

docker-compose-dev.yml

@@ -0,0 +1,67 @@
+services:
+  db:
+    image: postgres:15
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: zhenxun
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    labels:
+      - "prometheus.io/scrape=true"
+      - "prometheus.io/port=9187"
+
+  postgres-exporter:
+    image: prometheuscommunity/postgres-exporter
+    environment:
+      DATA_SOURCE_NAME: "postgresql://postgres:password@db:5432/zhenxun?sslmode=disable"
+    ports:
+      - "9187:9187"
+    depends_on:
+      - db
+
+  redis:
+    image: redis:7
+    ports:
+      - "6379:6379"
+    labels:
+      - "prometheus.io/scrape=true"
+      - "prometheus.io/port=9121"
+
+  redis-exporter:
+    image: oliver006/redis_exporter
+    environment:
+      REDIS_ADDR: redis://redis:6379
+    ports:
+      - "9121:9121"
+    depends_on:
+      - redis
+
+  prometheus:
+    image: prom/prometheus
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+      - prometheus_data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+
+  grafana:
+    image: grafana/grafana
+    ports:
+      - "3000:3000"
+    volumes:
+      - grafana_data:/var/lib/grafana
+    depends_on:
+      - prometheus
+
+volumes:
+  pgdata:
+  prometheus_data:
+  grafana_data: