🩹 修正踢出bot时参数

* 🐛 修复获取群组时会修改群组插件关闭状态

* ✨ 支持https图片地址转换

* ✨ 支持https图片地址转换

* 🎨 移除多余导入

* 🎨  优化GroupConsole设置插件默认状态代码结构

* 🎨 优化群组表代码结构

* ⚡ 移除build_message的https默认转图片

.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,5 +1,3 @@
-
-
 SUPERUSERS=[""]
 
 COMMAND_START=[""]
@@ -8,9 +6,72 @@ SESSION_RUNNING_EXPRESSION="别急呀,小真寻要宕机了!QAQ"
 
 NICKNAME=["真寻", "小真寻", "绪山真寻", "小寻子"]
 
-SESSION_EXPIRE_TIMEOUT=30
+SESSION_EXPIRE_TIMEOUT=00:00:30
 
-DEBUG=False
+ALCONNA_USE_COMMAND_START=True
+
+# 全局图片统一使用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 = ""
+
+# 系统代理
+# 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/ISSUE_TEMPLATE/issue-template.md

@@ -1,23 +0,0 @@
----
-name: Issue template
-about: " issue template's purpose here."
-title: ''
-labels: ''
-assignees: ''
-
----
-
-### 系统版本：Ubuntu 20.04
-### 真寻版本：0.1.5.3
-
-### 错误截图
-
-[img]
-
-### 日志截图
-
-[img]
-
-### 错误说明
-
-发生了xx错误...

.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/ISSUE_TEMPLATE.md

@@ -1,9 +0,0 @@
-### 系统版本：Ubuntu 20.04
-### 真寻版本：0.1.5.3
-
-### 错误截图
-
-[img]
-
-### 错误说明
-发生了xx错误...

.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,94 @@
+# 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
+          - language: javascript-typescript
+            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
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript 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/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/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

@@ -113,6 +113,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+.env.dev
 
 # Spyder project settings
 .spyderproject
@@ -151,15 +152,9 @@ backup/
 extensive_plugin/
 test/
 bot.py
-data/
-.env
-.env.dev
-/resources/text/
-/resources/image/
-!/resources/template/
-configs/config.py
+.idea/
+resources/
+/configs/config.py
 configs/config.yaml
-./.env
-./.env.dev
-plugins/csgo_server/
-plugins/activity/
+.vscode/launch.json
+plugins_/

.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,62 @@
+{
+  "C_Cpp.errorSquiggles": "enabled",
+  "terminal.integrated.env.linux": {
+    "PYTHONPATH": "${workspaceFolder}${pathSeparator}${env:PYTHONPATH}"
+  },
+  "cSpell.words": [
+    "aiofiles",
+    "Alconna",
+    "arclet",
+    "Arparma",
+    "displayname",
+    "flmt",
+    "getbbox",
+    "hibiapi",
+    "httpx",
+    "jsdelivr",
+    "kaiheila",
+    "lolicon",
+    "Mahiro",
+    "nonebot",
+    "onebot",
+    "pixiv",
+    "qbot",
+    "Setu",
+    "tobytes",
+    "ujson",
+    "unban",
+    "Uninfo",
+    "userinfo",
+    "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,210 +1,134 @@
-<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>
 
-[//]: # (是老手！讨论插件开发，nonebot2开发，可以加入[ <strong>[真寻酱的技术群]&#40;https://jq.qq.com/?_wv=1027&k=u8PgBkMZ&#41; </strong>])
+[![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)
 
-## 声明
-此项目仅用于学习交流，请勿用于非法用途
+</div>
 
-# Nonebot2
-<img style="height: 200px;width: 200px;" src="https://camo.githubusercontent.com/0ef71e86056da694c540790aa4a4e314396884d6c4fdb95362a7538b27a1b034/68747470733a2f2f76322e6e6f6e65626f742e6465762f6c6f676f2e706e67">
+<div align=center>
 
-非常 [ **[NICE](https://github.com/nonebot/nonebot2)** ] 的OneBot框架
+[文档](https://hibikier.github.io/zhenxun_bot/)
 
-## 未完成的文档
+</div>
 
-# [传送门](https://hibikier.github.io/zhenxun_bot/)
+<div align=center>
 
-## 真寻的帮助
-请对真寻说: '真寻帮助' or '管理员帮助' or '超级用户帮助' or '真寻帮助 指令'
+## 绪山真寻 Bot
 
-## 普通帮助图片
-![x](https://raw.githubusercontent.com/HibiKier/zhenxun_bot/main/docs_image/help.png)
+</div>
 
-## HTML版帮助图片
-![x](https://raw.githubusercontent.com/HibiKier/zhenxun_bot/main/docs_image/html_help.png)
+<div align=center>
 
-## Web UI
-[zhenxun_bot_webui](https://github.com/HibiKier/zhenxun_bot_webui)
+“真寻是<strong>[椛椛](https://github.com/FloatTech/ZeroBot-Plugin)</strong>的好朋友！”
 
-## 一键安装脚本
-[zhenxun_bot-deploy](https://github.com/AkashiCoin/zhenxun_bot-deploy)
+🎉 喜欢真寻，于是真寻就来了！🎉
 
-## 提供符合真寻标准的插件仓库
+本项目符合 [OneBot](https://github.com/howmanybots/onebot) 标准，可基于以下项目与机器人框架/平台进行交互
 
-[AkashiCoin/nonebot_plugins_zhenxun_bot](https://github.com/AkashiCoin/nonebot_plugins_zhenxun_bot)
+|                           项目地址                            | 平台 |         核心作者         | 备注 |
+| :-----------------------------------------------------------: | :--: | :----------------------: | :--: |
+|       [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>
 
-  * 实现了许多功能，且提供了大量功能管理命令
-  * 通过Config配置项将所有插件配置统计保存至config.yaml，利于统一用户修改
-  * 方便增删插件，原生nonebot2 matcher，不需要额外修改，仅仅通过简单的配置属性就可以生成`帮助图片`和`帮助信息`
-  * 提供了cd，阻塞，每日次数等限制，仅仅通过简单的属性就可以生成一个限制，例如：`__plugin_cd_limit__`
-  * __..... 更多详细请通过`传送门`查看文档！__
+<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] 更新群组成员信息
-- [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/HibiKier/zhenxun_bot_webui)         |   管理   |       [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://hibikier.github.io/zhenxun_bot/) 查看文档！**
+
+## 🛠️ 简单部署
+
+```bash
 # 获取代码
 git clone https://github.com/HibiKier/zhenxun_bot.git
 
@@ -215,356 +139,221 @@ cd zhenxun_bot
 pip install poetry      # 安装 poetry
 poetry install          # 安装依赖
 
-# 进行基础配置
-####请查看 配置 部分####
-
 # 开始运行
-poetry shell            # 进入虚拟环境
-python bot.py
+poetry run python bot.py
 ```
 
-## 简单配置
+## 📝 简单配置
 
-```
-1.在.env.dev文件中
+> [!TIP]
+> config.yaml 需要启动一次 Bot 后生成
 
-  SUPERUSERS = [""]   # 填写你的QQ
+1.在 .env.dev 文件中填写你的机器人配置项
 
-2.在configs/config.py文件中
-  * 数据库配置
+2.在 configs/config.yaml 文件中修改你需要修改的插件配置项
 
-3.在configs/config.yaml文件中 # 该文件需要启动一次后生成
-  * 修改插件配置项
-
-```
-
-
-## 使用Docker
-__Docker 单机版（仅真寻Bot）__  
-**点击下方的 GitHub 徽标查看教程**  
-[![Github](https://shields.io/badge/GITHUB-Sakuracio-4476AF?logo=github&style=for-the-badge)](https://github.com/Sakuracio/zhenxun_bot_docker)  
-[![DOCKER](https://shields.io/badge/docker-hibikier/zhenxun_bot-4476AF?logo=docker&style=for-the-badge)](https://hub.docker.com/r/hibikier/zhenxun_bot)  
-__Docker 全量版（包含 真寻Bot PostgreSQL数据库 go-cqhttp webui等）__  
-[![Github](https://shields.io/badge/GITHUB-SinKy--Yan-4476AF?logo=github&style=for-the-badge)](https://github.com/SinKy-Yan/zhenxunbot-docker)  
-[![DOCKER](https://shields.io/badge/docker-jyishit/zhenxun_bot-4476AF?logo=docker&style=for-the-badge)](https://hub.docker.com/r/jyishit/zhenxun_bot)  
-**点击上方的 GitHub 徽标查看教程**  
-PS: **ARM平台** 请使用全量版 同时 **如果你的机器 RAM < 1G 可能无法正常启动全量版容器**
-
-## [爱发电](https://afdian.net/@HibiKier)
 <details>
-<summary>爱发电 以及 感谢投喂 </summary>
-<img width="365px" height="450px" src="https://user-images.githubusercontent.com/45528451/175059389-cfeb8174-fa07-4939-80ab-a039087a50f6.png">
+<summary>数据库地址（DB_URL）配置说明</summary>
 
-### 感谢名单
-(可以告诉我你的 __github__ 地址，我偷偷换掉0v|)  
+DB_URL 是基于 Tortoise ORM 的数据库连接字符串，用于指定项目所使用的数据库。以下是 DB_URL 的组成部分以及示例：
 
-[阿奎](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)  
+格式为： `<数据库类型>://<用户名>:<密码>@<主机>:<端口>/<数据库名>?<参数>`
 
+- 数据库类型：表示数据库类型，例如 postgres、mysql、sqlite 等。
+- 用户名：数据库的用户名，例如 root。
+- 密码：数据库的密码，例如 123456。
+- 主机：数据库的主机地址，例如 127.0.0.1（本地）或远程服务器 IP。
+- 端口：数据库的端口号，例如：PostgreSQL：5432, MySQL：3306
+- 数据库名：指定要使用的数据库名称，例如 zhenxun。
+- 参数（可选）：用于传递额外的配置，例如字符集设置。
 
 </details>
 
+## 📋 功能列表
 
-## 更新
+> [!NOTE]
+> 真寻原 `plugins` 插件文件夹已迁移至 [插件仓库](https://github.com/zhenxun-org/zhenxun_bot_plugins) ，现在本体仅保留核心功能
+
+<details>
+<summary>内置功能</summary>
+
+### 🔧 基础功能
 
-### 2022/12/27 \[v0.1.6.6]
+- 昵称系统（群与群与私聊分开）
+- 签到/我的签到/好感度排行/好感度总排行（影响色图概率和开箱次数，支持配置）
+- 商店/我的金币/购买道具/使用道具/金币排行（完整的商店添加/购买/使用流程）
+- 查看当前群欢迎消息
+- 个人信息查看（群组内权限，聊天频率等）
+- 消息撤回
+- 功能统计可视化
+- 关于
+- 三种样式的帮助菜单
 
-* 添加权限检查依赖注入
+### 🛠️ 管理员功能
 
-### 2022/12/26
+- 管理员帮助
+- 更新群组成员信息
+- 95%的群功能开关
+- 查看群内被动技能状态
+- 自定义群欢迎消息（是真寻的不是管家的！）
+- ban/unban（支持设置 ban 时长）= 群组及用户的黑名单
+- 休息吧/醒来（群组内真寻状态）
 
-* 优化`gamedraw`插件
-* 提供全局被动控制
-* 群被动状态改为图片
-* 修复epic获取到的简介不是中文的bug [@pull/1221](https://github.com/HibiKier/zhenxun_bot/pull/1221)
+### 🧑‍💼 超级用户功能
 
-## 2022/12/24
+- 超级用户帮助
+- 添加/删除权限（是真寻的管理员权限，不是群管理员）
+- 群组管理，退群指令等
+- 广播
+- 自检（检查系统状态）
+- 所有群组/所有好友
+- 退出指定群
+- 更新好友信息/更新群信息
+- 修改群权限
+- 检查更新
+- 重启
+- 添加/删除/查看群白名单
+- 功能开关(更多设置)
+- 功能状态
+- 执行 SQL
+- 重载配置
+- 清理临时数据
+- 增删群认证
+- 同意/拒绝好友/群聊请求
+- 添加/移除/更新插件/插件商店（plugins 库以及扩展库）
+- WebUI API（对真寻前端的支持）
 
-* 修复群管理员权限检测会阻挡超级用户权限
+#### 🛡️ 超级用户的被动技能
 
-### 2022/12/23
+- 邀请入群提醒(别人邀请真寻入群，可配置自动同意)
 
-* 优化`管理员帮助`，`超级用户帮助`图片
-* 重新移植`gamedraw`
-* 修复pil帮助私聊时无法生成
+- 添加好友提醒(别人添加真寻好友，可配置自动同意)
 
-### 2022/12/17
+### 🤖 被动技能
 
-* 修复查看插件仓库当已安装插件版本不一致时出错
+- 群早晚安
 
-### 2022/12/15
+### 👻 看不见的技能
 
-* 修复自定义群欢迎消息无法使用
+- 功能调用统计
+- 聊天记录统计
+- 检测恶意触发命令（将被最高权限 ban 掉 30 分钟，只有最高权限(9 级)可以进行 unban）
+- 自动同意好友/群组请求，加群请求将会提醒管理员，退群提示，加群欢迎等等
+- 群聊时间检测（当群聊最后一人发言时间大于当前 48 小时后将关闭该群所有通知（即被动技能））
+- 群管理员监控，自动为新晋管理员增加权限，为失去群管理员的用户删除权限
+- 群权限系统
+- 定时更新权限
+- 自动配置重载
+- 强制入群保护
+- 自定备份（可配置）
+- 笨蛋检测（当使用功能名称当指令时真寻会跳出来狠狠嘲笑并帮助）
 
-### 2022/12/13
+</details>
 
-* 修复.unban
+## 💖 赞助
 
-### 2022/12/12
+<details>
+<summary>爱发电</summary>
+<a href="https://afdian.com/a/HibiKier">
+<img width="365px" height="450px" src=./docs_image/afd.jpg>
+</a>
+</details>
 
-* 修改HTML帮助禁用提示文本错误
-* 修复HTML帮助私聊无法生成
+### 赞助名单
 
-### 2022/12/11
+(可以告诉我你的 **github** 地址，我偷偷换掉 0v|)
 
-* 词条问题支持真寻的昵称开头与at真寻开头并优化回复
-* 帮助新增HTML生成（新布局），添加配置`TYPE`切换
-* 更正私聊时功能管理回复错误
-* 修复加入新群聊时初始化功能开关错误
-* 添加单例注解
-* 添加统计表
+[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)...
 
-### 2022/12/10
+## 📜 贡献指南
 
-* 重写帮助，删除 `详细帮助` 命令
+欢迎查看我们的 [贡献指南](CONTRIBUTING.md) 和 [行为守则](CODE_OF_CONDUCT.md) 以了解如何参与贡献。
 
-### 2022/12/4
+## ❔ 需要帮助？
 
-* 优化管理代码
+> [!TIP]
+> 发起 [issue](https://github.com/HibiKier/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/11/28
+欢迎前往 [issue](https://github.com/HibiKier/zhenxun_bot/issues/new/choose) 中提出你遇到的问题，或者加入我们的 [用户群](https://qm.qq.com/q/mRNtLSl6uc) 或 [技术群](https://qm.qq.com/q/YYYt5rkMYc)与我们联系
 
-* 修复web_ui群组无法获取
-* 修复web_ui修改插件数据时cmd格式错误
+## 🛠️ 进度追踪
 
-### 2022/11/28
+Project [zhenxun_bot](https://github.com/users/HibiKier/projects/2)
 
-* :bug: Fix a bug in open_cases to get vanilla knives' prices [@pull/1188](https://github.com/HibiKier/zhenxun_bot/pull/1188)
+## 🌟 特别感谢
 
-### 2022/11/24
+首席设计师：[酥酥/coldly-ss](https://github.com/coldly-ss)
 
-* 修复管理员插件加载路径错误
+## 🙏 感谢
 
-### 2022/11/23
-
-* 修复webui插件无法获取修改
-
-### 2022/11/22
-
-* fix switch_rule [@pull/1185](https://github.com/HibiKier/zhenxun_bot/pull/1185)
-
-### 2022/11/21  \[v0.1.6.5]
-
-* 优化manager, hook代码
-* 修复pid搜图 [@pull/1180](https://github.com/HibiKier/zhenxun_bot/pull/1180)
-
-### 2022/11/19
-
-* 修改优化帮助图片生成逻辑
-
-### 2022/11/18
-
-* poetry添加适配器依赖，更新支持py3.10 [@pull/1176](https://github.com/HibiKier/zhenxun_bot/pull/1176)
-
-### 2022/11/13
-
-* 更新天气api
-* 使用道具可以附带额外信息供函数使用
-* 限制帮助图片最小宽度
-
-### 2022/11/12
-
-* 更新yiqing插件数据显示 [@pull/1168](https://github.com/HibiKier/zhenxun_bot/pull/1168)
-
-### 2022/11/11
-
-* fix: B站直播订阅的相关问题 [@pull/1158](https://github.com/HibiKier/zhenxun_bot/pull/1158)
-
-### 2022/10/30
-
-* 商店简介动态行数，根据文字长度自动换行
-
-### 2022/10/28
-
-* 为exec指令进行了SELECT语句适配,添加了查看所有表指令 [@pull/1155](https://github.com/HibiKier/zhenxun_bot/pull/1155)
-* 修复复读 [@pull/1154](https://github.com/HibiKier/zhenxun_bot/pull/1154)
-
-### 2022/10/23
-
-* 复读修改回图片下载
-
-### 2022/10/22
-
-* 更新依赖注入
-
-### 2022/10/16 \[v0.1.6.4]
-
-* 修改商店道具icon可以为空
-
-### 2022/10/15
-
-* nonebot2版本更新为rc1
-* 我的道具改为图片形式
-* 商品添加图标与是否为被动道具（被动道具无法被主动使用）
-* 商品添加使用前方法和使用后方法（类似hook），使用方法具体查看文档或签到商品文件中注册的例子
-* 新增用户使用道具，花费金币(包括插件)及用途记录
-* 更细致的金币使用依赖注入
-* 更多的依赖注入（包含图片获取等等..
-* 修复我的道具仅有被动或主动道具时图片显示错误
-* 色图插件p站反向代理失效 [@pull/1139](https://github.com/HibiKier/zhenxun_bot/pull/1139)
-
-### 2022/10/9
-
-* 修复碧蓝档案角色获取问题，换源 [@pull/1124](https://github.com/HibiKier/zhenxun_bot/pull/1124)
-
-### 2022/10/7
-
-* 修复 B 站请求返回 -401 错误 [@pull/1119](https://github.com/HibiKier/zhenxun_bot/pull/1119)
-* 关闭功能与被动时不再区分大小写，同名时仅被动关闭操作生效
-
-### 2022/9/30
-
-* 修改重置开箱的使用权限 [@pull/1118](https://github.com/HibiKier/zhenxun_bot/pull/1118)
-
-### 2022/9/27
-
-*  更新b站转发解析 [@pull/1117](https://github.com/HibiKier/zhenxun_bot/pull/1117)
-
-### 2022/9/24
-
-* 修复b站订阅 [@pull/1112](https://github.com/HibiKier/zhenxun_bot/pull/1112)
-* fix: 重载赛马娘卡池失败 [@pull/1114](https://github.com/HibiKier/zhenxun_bot/pull/1114)
-
-### 2022/9/19
-
-* 更换bilibili_sub获取用户昵称用的API&尝试修了一下get_video() [@pull/1097](https://github.com/HibiKier/zhenxun_bot/pull/1097)
-* 修复csgo每日开箱可以多开一次
-
-### 2022/9/18
-
-* 修复 bilireq 版本过低导致 B 站视频解析错误 [@pull/1090](https://github.com/HibiKier/zhenxun_bot/pull/1096)
-
-### 2022/9/16
-
-* fix: bilibili_sub, azur_draw_card [@pull/1090](https://github.com/HibiKier/zhenxun_bot/pull/1090)
-* 修复原神资源查询查询完毕后图片存储错误
-* b站订阅发送 与 b站订阅 使用相同开关，即：关闭b站订阅
-
-### 2022/9/10
-
-* 自定义群欢迎消息参数不完全时提示报错
-* 修改bt插件的url地址 [@pull/1067](https://github.com/HibiKier/zhenxun_bot/pull/1067)
-
-### 2022/9/8
-
-* 添加插件数据初始化判断
-
-### 2022/9/4
-
-* 旧词条提供图片迁移（需要重新获取old_model文件，并将数据库中user_qq为0的数据删除）
-
-### 2022/9/3
-
-* 原神玩家查询增加须弥地区 [@pull/1053](https://github.com/HibiKier/zhenxun_bot/pull/1053)
-* av号覆盖全面，且修复av号链接 [@pull/1033](https://github.com/HibiKier/zhenxun_bot/pull/1033)
-* 修复词条含有CQ回答的模糊匹配无法被解析
-* 禁言检测图片在内存中获取图片hash
-* B站订阅在群里中任意群管理员可以统一管理（原来为管理员1无法删除管理员2的订阅）
-* 修复原神资源查询地图api数据变更导致更新的地图不完全
-
-### 2022/8/27
-
-* 修复签到积分双倍后，日志记录获得积分变4倍问题 [@pull/1044](https://github.com/HibiKier/zhenxun_bot/pull/1044)
-
-### 2022/8/26
-
-* 修复群管理员无法添加词条
-* 修复词条关键词"问"前空格问题
-
-### 2022/8/23
-
-* 修了下模糊匹配 issue#1026 [@pull/1026](https://github.com/HibiKier/zhenxun_bot/pull/1026)
-
-### 2022/8/22
-
-* 修复首次安装时词条旧表出错（因为根本就没有这张表！）
-* 取消配置替换定时任务，统一存储
-* 对米游社cookie进行判断，整合米游社签到信息 [@pull/1014](https://github.com/HibiKier/zhenxun_bot/pull/1014)
-* 修正尘歌壶和质变仪图片获取地址 [@pull/1010](https://github.com/HibiKier/zhenxun_bot/pull/1010)
-* 修复词库问答 **很多** 问题[@pull/1012](https://github.com/HibiKier/zhenxun_bot/pull/1012)
-
-### 2022/8/21 \[v0.1.6.3]
-
-* 重构群词条，改为词库Plus，增加 精准|模糊|正则 问题匹配，问题与回答均支持at，image，face，超级用户额外提供 全局|私聊 词库设置，数据迁移目前只提供了问题和回答都是纯文本的词条
-* 修复b站转发解析av号无法解析
-* B站订阅直播订阅支持短号
-* 开箱提供重置开箱命令，重置今日所有开箱数据（重置次数，并不会删除今日已开箱记录）
-* 提供全局字典GDict，通过from utils.utils import GDict导入
-* 适配omega 13w张图的数据结构表（建议删表重导）
-* 除首次启动外将配置替换加入单次定时任务，加快启动速度
-* fix: WordBank.check() [@pull/1008](https://github.com/HibiKier/zhenxun_bot/pull/1008)
-* 改进插件 `我有一个朋友`，避免触发过于频繁 [@pull/1001](https://github.com/HibiKier/zhenxun_bot/pull/1001)
-* 原神便笺新增洞天宝钱和参量质变仪提示 [@pull/1005](https://github.com/HibiKier/zhenxun_bot/pull/1005)
-* 新增米游社签到功能，自动领取（白嫖）米游币 [@pull/991](https://github.com/HibiKier/zhenxun_bot/pull/991)
-
-### 2022/8/14
-
-* 修复epic未获取到时间时出错
-* 修复订阅主播时动态获取的id是直播间id
-
-### 2022/8/8
-
-* 修复赛马娘重载卡池失败的问题 [@pull/969](https://github.com/HibiKier/zhenxun_bot/pull/969)
-
-### 2022/8/3
-
-* 修复 bili动态链接在投稿视频时URL和分割线连在一起 [@pull/951](https://github.com/HibiKier/zhenxun_bot/pull/961)
-* 更新 Epic 免费游戏商城链接拼接规则 [@pull/957](https://github.com/HibiKier/zhenxun_bot/pull/957)
-
-### 2022/8/6
-
-* 修复了原神自动签到返回invalid request的问题，新增查看我的cookie命令 [@pull/971](https://github.com/HibiKier/zhenxun_bot/pull/971)
-
-<br>
-
-__..... 更多更新信息请查看文档__
-
-## Todo
-- [x] 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 界面展示
+
+<div style="display: flex; flex-wrap: wrap; justify-content: space-between;">
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui00.png" alt="webui00" style="width: 100%; height: auto;">
+  </div>
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui01.png" alt="webui01" style="width: 100%; height: auto;">
+  </div>
+
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui02.png" alt="webui02" style="width: 100%; height: auto;">
+  </div>
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui03.png" alt="webui03" style="width: 100%; height: auto;">
+  </div>
+
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui04.png" alt="webui04" style="width: 100%; height: auto;">
+  </div>
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui05.png" alt="webui05" style="width: 100%; height: auto;">
+  </div>
+
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui06.png" alt="webui06" style="width: 100%; height: auto;">
+  </div>
+  <div style="width: 48%; margin-bottom: 10px;">
+    <img src="./docs_image/webui07.png" alt="webui07" style="width: 100%; height: auto;">
+  </div>
+</div>

__version__

@@ -1 +1 @@
-__version__: v0.1.6.6
+__version__: v0.2.4-2c97eea

basic_plugins/admin_bot_manage/__init__.py

@@ -1,32 +0,0 @@
-from pathlib import Path
-
-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(str(Path(__file__).parent.resolve()))

basic_plugins/admin_bot_manage/_data_source.py

@@ -1,384 +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, IMAGE_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
-import ujson as json
-
-
-custom_welcome_msg_json = (
-    Path() / "data" / "custom_welcome_msg" / "custom_welcome_msg.json"
-)
-
-ICON_PATH = IMAGE_PATH / 'other'
-
-
-async def group_current_status(group_id: int) -> str:
-    """
-    说明:
-        获取当前群聊所有通知的开关
-    参数:
-        :param group_id: 群号
-    """
-    _data = group_manager.get_task_data()
-    image_list = []
-    for i, task in enumerate(_data):
-        name = _data[task]
-        name_image = BuildImage(0, 0, plain_text=f"{i+1}.{name}", font_size=20)
-        bk = BuildImage(name_image.w + 200, name_image.h + 20, color=(103, 177, 109), font_size=15)
-        await bk.apaste(name_image, (10, 0), True, "by_height")
-        a_icon = BuildImage(40, 40, background=ICON_PATH / "btn_false.png")
-        if group_manager.check_group_task_status(group_id, task):
-            a_icon = BuildImage(40, 40, background=ICON_PATH / "btn_true.png")
-        b_icon = BuildImage(40, 40, background=ICON_PATH / "btn_false.png")
-        if group_manager.check_task_super_status(task):
-            b_icon = BuildImage(40, 40, background=ICON_PATH / "btn_true.png")
-        await bk.atext((name_image.w + 20, 10), "状态")
-        await bk.apaste(a_icon, (name_image.w + 50, 0), True)
-        await bk.atext((name_image.w + 100, 10), "全局")
-        await bk.apaste(b_icon, (name_image.w + 130, 0), True)
-        image_list.append(bk)
-    w = max([x.w for x in image_list])
-    h = sum([x.h + 10 for x in image_list])
-    A = BuildImage(w + 20, h + 70, font_size=30, color=(119, 97, 177))
-    await A.atext((15, 20), "群被动状态")
-    curr_h = 75
-    for img in image_list:
-        # await img.acircle_corner()
-        await A.apaste(img, (0, curr_h), True)
-        curr_h += img.h + 10
-    return A.pic2bs4()
-
-
-async def custom_group_welcome(
-    msg: str, img_list: List[str], user_id: int, group_id: int
-) -> str:
-    """
-    说明:
-        替换群欢迎消息
-    参数:
-        :param msg: 欢迎消息文本
-        :param img_list: 欢迎消息图片，只取第一张
-        :param user_id: 用户id，用于log记录
-        :param group_id: 群号
-    """
-    img_result = ""
-    result = ""
-    img = img_list[0] if img_list else ""
-    if (DATA_PATH / f"custom_welcome_msg/{group_id}.jpg").exists():
-        (DATA_PATH / f"custom_welcome_msg/{group_id}.jpg").unlink()
-    data = {}
-    if not custom_welcome_msg_json.exists():
-        custom_welcome_msg_json.parent.mkdir(parents=True, exist_ok=True)
-    else:
-        try:
-            data = json.load(open(custom_welcome_msg_json, "r"))
-        except FileNotFoundError:
-            pass
-    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
-
-
-def change_global_task_status(cmd: str) -> str:
-    """
-    说明:
-        修改全局被动任务状态
-    参数:
-        :param cmd: 功能名称
-    """
-    global task_data
-    if not task_data:
-        task_data = group_manager.get_task_data()
-    status = cmd[:2]
-    _cmd = cmd[4:]
-    if '全部被动' in cmd:
-        for task in task_data:
-            if status == "开启":
-                group_manager.open_global_task(task)
-            else:
-                group_manager.close_global_task(task)
-        group_manager.save()
-        return f"已 {status} 全局全部被动技能！"
-    else:
-        modules = [x for x in task_data if task_data[x].lower() == _cmd.lower()]
-        if not modules:
-            return '未查询到该被动任务'
-        if status == "开启":
-            group_manager.open_global_task(modules[0])
-        else:
-            group_manager.close_global_task(modules[0])
-        group_manager.save()
-        return f"已 {status} 全局{_cmd}"
-
-
-async def change_group_switch(cmd: str, group_id: int, is_super: bool = False) -> str:
-    """
-    说明:
-        修改群功能状态
-    参数:
-        :param cmd: 功能名称
-        :param group_id: 群号
-        :param is_super: 是否位超级用户，超级用户用于私聊开关功能状态
-    """
-    global task_data
-    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 group_manager.check_group_task_status(group_id, task):
-                    group_manager.open_group_task(group_id, task)
-            else:
-                if group_manager.check_group_task_status(group_id, task):
-                    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, False)
-            else:
-                group_manager.block_plugin(f, group_id, False)
-        group_manager.save()
-        if group_help_file.exists():
-            group_help_file.unlink()
-        return f"已 {status} 全部功能！"
-    if cmd.lower() in [task_data[x].lower() for x in task_data.keys()]:
-        type_ = "task"
-        modules = [x for x in task_data.keys() if task_data[x].lower() == cmd.lower()]
-    for module in modules:
-        if is_super:
-            module = f"{module}:super"
-        if status == "开启":
-            if type_ == "task":
-                if group_manager.check_group_task_status(group_id, module):
-                    return f"被动 {task_data[module]} 正处于开启状态！不要重复开启."
-                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 group_manager.check_group_task_status(group_id, module):
-                    return f"被动 {task_data[module]} 正处于关闭状态！不要重复关闭."
-                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:
-        nickname = user_info["card"] or user_info["nickname"]
-        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)
-        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,52 +0,0 @@
-from typing import List
-
-from nonebot import on_command
-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
-from utils.depends import ImageList
-
-
-__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(), img: List[str] = ImageList()):
-    msg = arg.extract_plain_text().strip()
-    if not msg and not img:
-        await custom_welcome.finish(__plugin_usage__)
-    try:
-        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,53 +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
-import time
-
-cmd = []
-
-v = time.time()
-
-
-def switch_rule(event: Event) -> bool:
-    """
-    说明:
-        检测文本是否是关闭功能命令
-    参数:
-        :param event: pass
-    """
-    global cmd, v
-    try:
-        if not cmd or time.time() - v > 60 * 60:
-            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]}")
-                cmd.append(f"开启 {_data[key]}")
-                cmd.append(f"关闭 {_data[key]}")
-            _data = plugins2settings_manager.get_data()
-            for key in _data.keys():
-                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
-            v = time.time()
-        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,129 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent, GROUP, PrivateMessageEvent
-from nonebot import on_command, on_message, on_regex
-from nonebot.params import RegexGroup
-
-from utils.message_builder import image
-from ._data_source import (
-    change_group_switch,
-    set_plugin_status,
-    get_plugin_status,
-    group_current_status,
-    set_group_bot_status, change_global_task_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 ("关闭被动" in _cmd or "开启被动" in _cmd) and isinstance(event, PrivateMessageEvent):
-                await switch_rule_matcher.send(change_global_task_status(_cmd))
-            elif 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"已{_cmd[:2]}群聊 {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(image(b64=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,41 +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_IMAGE))

basic_plugins/admin_help/data_source.py

@@ -1,87 +0,0 @@
-import nonebot
-from configs.path_config import IMAGE_PATH
-from nonebot import Driver
-from services.log import logger
-from utils.image_template import help_template
-from utils.image_utils import (BuildImage, build_sort_image, group_image,
-                               text2image)
-from utils.manager import group_manager, plugin_data_manager
-from utils.manager.models import PluginType
-
-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():
-    if not group_manager.get_task_data():
-        group_manager.load_task()
-        logger.info(f"已成功加载 {len(group_manager.get_task_data())} 个被动技能.")
-
-
-async def create_help_image():
-    """
-    创建管理员帮助图片
-    """
-    await _create_help_image()
-
-
-async def _create_help_image():
-    """
-    创建管理员帮助图片
-    """
-    if ADMIN_HELP_IMAGE.exists():
-        return
-    plugin_data_ = plugin_data_manager.get_data()
-    image_list = []
-    task_list = []
-    for plugin_data in [plugin_data_[x] for x in plugin_data_]:
-        try:
-            usage = None
-            if plugin_data.plugin_type == PluginType.ADMIN and plugin_data.usage:
-                usage = await text2image(
-                    plugin_data.usage, padding=5, color=(204, 196, 151)
-                )
-            if usage:
-                await usage.acircle_corner()
-                level = 5
-                if plugin_data.plugin_setting:
-                    level = plugin_data.plugin_setting.level or level
-                image = await help_template(plugin_data.name + f"[{level}]", usage)
-                image_list.append(image)
-            if plugin_data.task:
-                for x in plugin_data.task.keys():
-                    task_list.append(plugin_data.task[x])
-        except Exception as e:
-            logger.warning(
-                f"获取群管理员插件 {plugin_data.model}: {plugin_data.name} 设置失败... {type(e)}：{e}"
-            )
-    task_str = "\n".join(task_list)
-    task_str = "通过 开启/关闭 来控制群被动\n----------\n" + task_str
-    task_image = await text2image(task_str, padding=5, color=(204, 196, 151))
-    task_image = await help_template("被动任务", task_image)
-    image_list.append(task_image)
-    image_group, _ = group_image(image_list)
-    A = await build_sort_image(image_group, color="#f9f6f2", padding_top=180)
-    await A.apaste(
-        BuildImage(0, 0, font="CJGaoDeGuo.otf", plain_text="群管理员帮助", font_size=50),
-        (50, 30),
-        True,
-    )
-    await A.apaste(
-        BuildImage(
-            0,
-            0,
-            font="CJGaoDeGuo.otf",
-            plain_text="注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数",
-            font_size=30,
-            font_color="red",
-        ),
-        (50, 90),
-        True,
-    )
-    await A.asave(ADMIN_HELP_IMAGE)
-    logger.info(f"已成功加载 {len(image_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 import ActionFailed
-from configs.config import NICKNAME, Config
-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=9999, block=False, rule=lambda: 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"],
-                1
-            )
-            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,172 +0,0 @@
-from typing import Tuple, List
-
-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.depends import AtList
-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(),
-    qq: List[int] = AtList()
-):
-    cmd = cmd[0]
-    result = ""
-    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:
-            msg_splt = msg.split()
-            if is_number(msg_splt[0]):
-                qq = int(msg_splt[0])
-                msg = msg_splt[1:]
-                if cmd in [".ban", "/ban"]:
-                    time = parse_ban_time(" ".join(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,62 +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"
-            f" {event.group_id if isinstance(event, GroupMessageEvent) else ''} 将 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,66 +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 = [
-        g["group_id"]
-        for g in await bot.get_group_list()
-        if 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/_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,39 +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 utils.depends import PlaintText
-
-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, msg: str = PlaintText()):
-    if isinstance(event, GroupMessageEvent):
-        await ChatHistory.add_chat_msg(
-            event.user_id, event.group_id, str(event.get_message()), msg
-        )
-    else:
-        await ChatHistory.add_chat_msg(event.user_id, None, str(event.get_message()), msg)
-
-
-# @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,114 +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)?(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)
-    time_now = datetime.now()
-    zero_today = time_now - timedelta(hours=time_now.hour, minutes=time_now.minute, seconds=time_now.second)
-    if date in ["日"]:
-        date_scope = (zero_today, time_now)
-    elif date in ["周"]:
-        date_scope = (time_now - timedelta(days=7), time_now)
-    elif date in ["月"]:
-        date_scope = (time_now - timedelta(days=30), time_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 = time_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,207 +0,0 @@
-from nonebot import on_notice, on_request
-from configs.path_config import IMAGE_PATH, DATA_PATH
-from models.level_user import LevelUser
-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,
-    ActionFailed,
-    GroupIncreaseNoticeEvent,
-    GroupDecreaseNoticeEvent,
-)
-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
-import ujson as 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.get_data().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)
-            # 即刻刷新权限
-            for user_info in await bot.get_group_member_list(group_id=event.group_id):
-                if user_info["role"] in [
-                    "owner",
-                    "admin",
-                ] and not await LevelUser.is_group_flag(
-                    user_info["user_id"], event.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
-                    )
-    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,56 +0,0 @@
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GroupMessageEvent,
-    Message
-)
-from nonebot.params import CommandArg
-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
-from ._utils import GROUP_HELP_PATH
-import os
-
-
-__zx_plugin_name__ = "帮助"
-
-__plugin_configs__ = {
-    "TYPE": {"value": "normal", "help": "帮助图片样式 ['normal', 'HTML']", "default_value": "normal"}
-}
-
-simple_help_image = IMAGE_PATH / "simple_help.png"
-if simple_help_image.exists():
-    simple_help_image.unlink()
-
-
-simple_help = on_command("功能", rule=to_me(), aliases={"help", "帮助"}, priority=1, block=True)
-
-
-@simple_help.handle()
-async def _(bot: Bot, event: MessageEvent, 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 simple_help.send(image(b64=msg))
-        else:
-            await simple_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)
-            await simple_help.send(image(_image_path))
-        else:
-            if not simple_help_image.exists():
-                if simple_help_image.exists():
-                    simple_help_image.unlink()
-                await create_help_img(None)
-            await simple_help.finish(image("simple_help.png"))

basic_plugins/help/_config.py

@@ -1,14 +0,0 @@
-from typing import Optional, List, Any, Union, Dict
-from pydantic import BaseModel
-
-
-class Item(BaseModel):
-    plugin_name: str
-    sta: int
-
-
-class PluginList(BaseModel):
-    plugin_type: str
-    icon: str
-    logo: str
-    items: List[Item]

basic_plugins/help/_data_source.py

@@ -1,71 +0,0 @@
-
-from ._utils import HelpImageBuild
-from utils.image_utils import BuildImage
-from configs.path_config import IMAGE_PATH
-from utils.manager import (
-    plugins2settings_manager,
-    admin_manager,
-)
-from typing import Optional
-import nonebot
-
-
-random_bk_path = IMAGE_PATH / "background" / "help" / "simple_help"
-
-background = IMAGE_PATH / "background" / "0.png"
-
-
-async def create_help_img(group_id: Optional[int]):
-    """
-    说明:
-        生成帮助图片
-    参数:
-        :param group_id: 群号
-    """
-    await HelpImageBuild().build_image(group_id)
-
-
-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
-    ) or admin_manager.get_plugin_module(msg)
-    if module:
-        try:
-            plugin = nonebot.plugin.get_plugin(module)
-            metadata = plugin.metadata
-            if plugin:
-                if is_super:
-                    result = plugin.module.__getattribute__(
-                        "__plugin_superuser_usage__"
-                    )
-                else:
-                    result = (
-                        metadata.usage
-                        if metadata
-                        else 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/help/_utils.py

@@ -1,256 +0,0 @@
-import os
-import random
-from typing import Dict, List, Optional
-
-from configs.config import Config
-from configs.path_config import DATA_PATH, IMAGE_PATH, TEMPLATE_PATH
-from utils.decorator import Singleton
-from utils.image_utils import BuildImage, build_sort_image, group_image
-from utils.manager import group_manager, plugin_data_manager
-from utils.manager.models import PluginData, PluginType
-
-from ._config import Item
-
-GROUP_HELP_PATH = DATA_PATH / "group_help"
-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()
-
-BACKGROUND_PATH = IMAGE_PATH / "background" / "help" / "simple_help"
-
-LOGO_PATH = TEMPLATE_PATH / "menu" / "res" / "logo"
-
-
-@Singleton
-class HelpImageBuild:
-    def __init__(self):
-        self._data: Dict[str, PluginData] = plugin_data_manager.get_data()
-        self._sort_data: Dict[str, List[PluginData]] = {}
-        self._image_list = []
-        self.icon2str = {
-            "normal": "fa fa-cog",
-            "原神相关": "fa fa-circle-o",
-            "常规插件": "fa fa-cubes",
-            "联系管理员": "fa fa-envelope-o",
-            "抽卡相关": "fa fa-credit-card-alt",
-            "来点好康的": "fa fa-picture-o",
-            "数据统计": "fa fa-bar-chart",
-            "一些工具": "fa fa-shopping-cart",
-            "商店": "fa fa-shopping-cart",
-            "其它": "fa fa-tags",
-            "群内小游戏": "fa fa-gamepad",
-        }
-
-    def sort_type(self):
-        """
-        说明:
-            对插件按照菜单类型分类
-        """
-        if not self._sort_data.keys():
-            for key in self._data.keys():
-                plugin_data = self._data[key]
-                if plugin_data.plugin_type == PluginType.NORMAL:
-                    if not self._sort_data.get(plugin_data.menu_type[0]):
-                        self._sort_data[plugin_data.menu_type[0]] = []
-                    self._sort_data[plugin_data.menu_type[0]].append(self._data[key])
-
-    async def build_image(self, group_id: Optional[int]):
-        if group_id:
-            help_image = GROUP_HELP_PATH / f"{group_id}.png"
-        else:
-            help_image = IMAGE_PATH / f"simple_help.png"
-        build_type = Config.get_config("help", "TYPE")
-        if build_type == "HTML":
-            byt = await self.build_html_image(group_id)
-            with open(help_image, "wb") as f:
-                f.write(byt)
-        else:
-            img = await self.build_pil_image(group_id)
-            img.save(help_image)
-
-    async def build_html_image(self, group_id: Optional[int]) -> bytes:
-        from nonebot_plugin_htmlrender import template_to_pic
-        self.sort_type()
-        classify = {}
-        for menu in self._sort_data:
-            for plugin in self._sort_data[menu]:
-                sta = 0
-                if not plugin.plugin_status.status:
-                    if group_id and plugin.plugin_status.block_type in ["all", "group"]:
-                        sta = 2
-                    if not group_id and plugin.plugin_status.block_type in [
-                        "all",
-                        "private",
-                    ]:
-                        sta = 2
-                if group_id and not group_manager.get_plugin_super_status(
-                    plugin.model, group_id
-                ):
-                    sta = 2
-                if group_id and not group_manager.get_plugin_status(
-                    plugin.model, group_id
-                ):
-                    sta = 1
-                if classify.get(menu):
-                    classify[menu].append(Item(plugin_name=plugin.name, sta=sta))
-                else:
-                    classify[menu] = [Item(plugin_name=plugin.name, sta=sta)]
-        max_len = 0
-        flag_index = -1
-        max_data = None
-        plugin_list = []
-        for index, plu in enumerate(classify.keys()):
-            if plu in self.icon2str.keys():
-                icon = self.icon2str[plu]
-            else:
-                icon = "fa fa-pencil-square-o"
-            logo = LOGO_PATH / random.choice(os.listdir(LOGO_PATH))
-            data = {
-                "name": plu if plu != "normal" else "功能",
-                "items": classify[plu],
-                "icon": icon,
-                "logo": str(logo.absolute()),
-            }
-            if len(classify[plu]) > max_len:
-                max_len = len(classify[plu])
-                flag_index = index
-                max_data = data
-            plugin_list.append(data)
-        del plugin_list[flag_index]
-        plugin_list.insert(0, max_data)
-        pic = await template_to_pic(
-            template_path=str((TEMPLATE_PATH / "menu").absolute()),
-            template_name="zhenxun_menu.html",
-            templates={"plugin_list": plugin_list},
-            pages={
-                "viewport": {"width": 1903, "height": 975},
-                "base_url": f"file://{TEMPLATE_PATH}",
-            },
-            wait=2,
-        )
-        return pic
-
-    async def build_pil_image(self, group_id: Optional[int]) -> BuildImage:
-        """
-        说明:
-            构造帮助图片
-        参数:
-            :param group_id: 群号
-        """
-        self._image_list = []
-        self.sort_type()
-        font_size = 24
-        build_type = Config.get_config("help", "TYPE")
-        _image = BuildImage(0, 0, plain_text="1", font_size=font_size)
-        for idx, menu_type in enumerate(self._sort_data.keys()):
-            plugin_list = self._sort_data[menu_type]
-            wh_list = [_image.getsize(x.name) for x in plugin_list]
-            wh_list.append(_image.getsize(menu_type))
-            # sum_height = sum([x[1] for x in wh_list])
-            if build_type == "VV":
-                sum_height = 50 * len(plugin_list) + 10
-            else:
-                sum_height = (font_size + 6) * len(plugin_list) + 10
-            max_width = max([x[0] for x in wh_list]) + 20
-            bk = BuildImage(
-                max_width + 40,
-                sum_height + 50,
-                font_size=30,
-                color="#a7d1fc",
-                font="CJGaoDeGuo.otf",
-            )
-            title_size = bk.getsize(menu_type)
-            max_width = max_width if max_width > title_size[0] else title_size[0]
-            B = BuildImage(
-                max_width + 40,
-                sum_height,
-                font_size=font_size,
-                color="white" if not idx % 2 else "black",
-            )
-            curr_h = 10
-            for i, plugin_data in enumerate(plugin_list):
-                text_color = (255, 255, 255) if idx % 2 else (0, 0, 0)
-                if group_id and not group_manager.get_plugin_status(
-                    plugin_data.model, group_id
-                ):
-                    text_color = (252, 75, 13)
-                pos = None
-                # 禁用状态划线
-                if (
-                    not plugin_data.plugin_status.status
-                    and plugin_data.plugin_status.block_type in ["group", "all"]
-                ) or (group_id and not group_manager.get_plugin_super_status(
-                    plugin_data.model, group_id
-                )):
-                    w = curr_h + int(B.getsize(plugin_data.name)[1] / 2) + 2
-                    pos = (
-                        7,
-                        w,
-                        B.getsize(plugin_data.name)[0] + 35,
-                        w,
-                    )
-                if build_type == "VV":
-                    name_image = await self.build_name_image(
-                        max_width,
-                        plugin_data.name,
-                        "black" if not idx % 2 else "white",
-                        text_color,
-                        pos,
-                    )
-                    await B.apaste(
-                        name_image, (0, curr_h), True, center_type="by_width"
-                    )
-                    curr_h += name_image.h + 5
-                else:
-                    await B.atext(
-                        (10, curr_h), f"{i + 1}.{plugin_data.name}", text_color
-                    )
-                    if pos:
-                        await B.aline(pos, (236, 66, 7), 3)
-                    curr_h += font_size + 5
-            if menu_type == "normal":
-                menu_type = "功能"
-            await bk.atext((0, 14), menu_type, center_type="by_width")
-            await bk.apaste(B, (0, 50))
-            await bk.atransparent(2)
-            # await bk.acircle_corner(point_list=['lt', 'rt'])
-            self._image_list.append(bk)
-        image_group, h = group_image(self._image_list)
-        B = await build_sort_image(
-            image_group,
-            h,
-            background_path=BACKGROUND_PATH,
-            background_handle=lambda image: image.filter("GaussianBlur", 5),
-        )
-        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
-        await B.apaste(
-            BuildImage(
-                0,
-                0,
-                plain_text="注: 红字代表功能被群管理员禁用，红线代表功能正在维护",
-                font_size=24,
-                font="HYWenHei-85W.ttf",
-                font_color=(231, 74, 57),
-            ),
-            (300, 10),
-            True,
-        )
-        return B

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,511 +0,0 @@
-from typing import Optional
-
-import nonebot
-from nonebot.adapters.onebot.v11 import (
-    GroupMessageEvent,
-    PrivateMessageEvent,
-    Bot,
-    Event,
-    MessageEvent,
-    Message,
-    PokeNotifyEvent,
-)
-from nonebot.exception import ActionFailed, IgnoredException
-from nonebot.internal.matcher import Matcher
-
-from models.bag_user import BagUser
-from models.ban_user import BanUser
-from models.friend_user import FriendUser
-from models.group_member_info import GroupInfoUser
-from models.level_user import LevelUser
-from models.user_shop_gold_log import UserShopGoldLog
-from utils.decorator import Singleton
-from utils.manager import (
-    plugins2block_manager,
-    StaticData,
-    plugins2settings_manager,
-    group_manager,
-    admin_manager,
-    plugins_manager,
-    plugins2cd_manager,
-    plugins2count_manager,
-)
-from utils.message_builder import at
-from utils.utils import FreqLimiter
-from configs.config import Config
-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)
-
-
-async def send_msg(msg: str, bot: Bot, event: MessageEvent):
-    """
-    说明:
-        发送信息
-    参数:
-        :param msg: pass
-        :param bot: pass
-        :param event: pass
-    """
-    if "[uname]" in msg:
-        uname = event.sender.card or event.sender.nickname
-        msg = msg.replace("[uname]", uname)
-    if "[nickname]" in msg:
-        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)
-        msg = msg.replace("[nickname]", nickname)
-    if "[at]" in msg and isinstance(event, GroupMessageEvent):
-        msg = msg.replace("[at]", str(at(event.user_id)))
-    try:
-        if isinstance(event, GroupMessageEvent):
-            status_message_manager.add(event.group_id)
-            await bot.send_group_msg(group_id=event.group_id, message=Message(msg))
-        else:
-            status_message_manager.add(event.user_id)
-            await bot.send_private_msg(user_id=event.user_id, message=Message(msg))
-    except ActionFailed:
-        pass
-
-
-class IsSuperuserException(Exception):
-    pass
-
-
-@Singleton
-class AuthChecker:
-    """
-    权限检查
-    """
-
-    def __init__(self):
-        self._flmt = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-        self._flmt_g = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-        self._flmt_s = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-        self._flmt_c = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
-
-    async def auth(self, matcher: Matcher, bot: Bot, event: Event):
-        """
-        说明:
-            权限检查
-        参数:
-            :param matcher: matcher
-            :param bot: bot
-            :param event: event
-        """
-        try:
-            plugin_name = matcher.plugin_name
-            cost_gold = await self.auth_cost(plugin_name, bot, event)
-            if str(event.user_id) not in bot.config.superusers:
-                await self.auth_basic(plugin_name, bot, event)
-                self.auth_group(plugin_name, bot, event)
-                await self.auth_admin(plugin_name, matcher, bot, event)
-                await self.auth_plugin(plugin_name, matcher, bot, event)
-                await self.auth_limit(plugin_name, bot, event)
-                if cost_gold:
-                    await BagUser.spend_gold(event.user_id, event.group_id, cost_gold)
-        except IsSuperuserException:
-            return
-
-    async def auth_limit(self, plugin_name: str, bot: Bot, event: Event):
-        """
-        说明:
-            插件限制
-        参数:
-            :param plugin_name: 模块名
-            :param bot: bot
-            :param event: event
-        """
-        if plugins2cd_manager.check_plugin_cd_status(plugin_name):
-            plugin_cd_data = plugins2cd_manager.get_plugin_cd_data(plugin_name)
-            check_type = plugin_cd_data.check_type
-            limit_type = plugin_cd_data.limit_type
-            msg = 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(plugin_name).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(plugin_name, cd_type_):
-                    if msg:
-                        await send_msg(msg, bot, event)
-                    raise IgnoredException(f"{plugin_name} 正在cd中...")
-                else:
-                    plugins2cd_manager.start_cd(plugin_name, cd_type_)
-        # Block
-        if plugins2block_manager.check_plugin_block_status(plugin_name):
-            plugin_block_data = plugins2block_manager.get_plugin_block_data(plugin_name)
-            check_type = plugin_block_data.check_type
-            limit_type = plugin_block_data.limit_type
-            msg = 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_, plugin_name):
-                    if msg:
-                        await send_msg(msg, bot, event)
-                    raise IgnoredException(f"{event.user_id}正在调用{plugin_name}....")
-                else:
-                    plugins2block_manager.set_true(block_type_, plugin_name)
-        # Count
-        if (
-            plugins2count_manager.check_plugin_count_status(plugin_name)
-            and event.user_id not in bot.config.superusers
-        ):
-            plugin_count_data = plugins2count_manager.get_plugin_count_data(plugin_name)
-            limit_type = plugin_count_data.limit_type
-            msg = 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(plugin_name, count_type_):
-                if msg:
-                    await send_msg(msg, bot, event)
-                raise IgnoredException(f"{plugin_name} count次数限制...")
-            else:
-                plugins2count_manager.increase(plugin_name, count_type_)
-
-    async def auth_plugin(self, plugin_name: str, matcher: Matcher, bot: Bot, event: Event):
-        """
-        说明:
-            插件状态
-        参数:
-            :param plugin_name: 模块名
-            :param matcher: matcher
-            :param bot: bot
-            :param event: event
-        """
-        if plugin_name in plugins2settings_manager.keys() and matcher.priority not in [
-            1,
-            999,
-        ]:
-            # 戳一戳单独判断
-            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 plugins2settings_manager[
-                    plugin_name
-                ].level > group_manager.get_group_level(event.group_id):
-                    try:
-                        if (
-                            self._flmt_g.check(event.user_id)
-                            and plugin_name not in ignore_rst_module
-                        ):
-                            self._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, plugin_name)
-                    raise IgnoredException("群权限不足")
-                # 插件状态
-                if not group_manager.get_plugin_status(plugin_name, event.group_id):
-                    try:
-                        if plugin_name not in ignore_rst_module and self._flmt_s.check(
-                            event.group_id
-                        ):
-                            self._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, plugin_name)
-                    raise IgnoredException("未开启此功能...")
-                # 管理员禁用
-                if not group_manager.get_plugin_status(
-                    f"{plugin_name}:super", event.group_id
-                ):
-                    try:
-                        if (
-                            self._flmt_s.check(event.group_id)
-                            and plugin_name not in ignore_rst_module
-                        ):
-                            self._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, plugin_name)
-                    raise IgnoredException("管理员禁用了此群该功能...")
-                # 群聊禁用
-                if not plugins_manager.get_plugin_status(
-                    plugin_name, block_type="group"
-                ):
-                    try:
-                        if (
-                            self._flmt_c.check(event.group_id)
-                            and plugin_name not in ignore_rst_module
-                        ):
-                            self._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, plugin_name)
-                    raise IgnoredException("该插件在群聊中已被禁用...")
-            else:
-                # 私聊禁用
-                if not plugins_manager.get_plugin_status(
-                    plugin_name, block_type="private"
-                ):
-                    try:
-                        if self._flmt_c.check(event.user_id):
-                            self._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, plugin_name)
-                    raise IgnoredException("该插件在私聊中已被禁用...")
-            # 维护
-            if not plugins_manager.get_plugin_status(plugin_name, block_type="all"):
-                if isinstance(
-                    event, GroupMessageEvent
-                ) and group_manager.check_group_is_white(event.group_id):
-                    raise IsSuperuserException()
-                try:
-                    if isinstance(event, GroupMessageEvent):
-                        if (
-                            self._flmt_c.check(event.group_id)
-                            and plugin_name not in ignore_rst_module
-                        ):
-                            self._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, plugin_name)
-                raise IgnoredException("此功能正在维护...")
-
-    async def auth_admin(self, plugin_name: str, matcher: Matcher, bot: Bot, event: Event):
-        """
-        说明:
-            管理员命令 个人权限
-        参数:
-            :param plugin_name: 模块名
-            :param matcher: matcher
-            :param bot: bot
-            :param event: event
-        """
-        if plugin_name in admin_manager.keys() and matcher.priority not in [1, 999]:
-            if isinstance(event, GroupMessageEvent):
-                # 个人权限
-                if (
-                    not await LevelUser.check_level(
-                        event.user_id,
-                        event.group_id,
-                        admin_manager.get_plugin_level(plugin_name),
-                    )
-                    and admin_manager.get_plugin_level(plugin_name) > 0
-                ):
-                    try:
-                        if self._flmt.check(event.user_id):
-                            self._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(plugin_name)}",
-                            )
-                    except ActionFailed:
-                        pass
-                    set_block_limit_false(event, plugin_name)
-                    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(plugin_name)
-                ):
-                    try:
-                        await bot.send_private_msg(
-                            user_id=event.user_id,
-                            message=f"你的权限不足喔，该功能需要的权限等级：{admin_manager.get_plugin_level(plugin_name)}",
-                        )
-                    except ActionFailed:
-                        pass
-                    set_block_limit_false(event, plugin_name)
-                    if event.is_tome():
-                        status_message_manager.add(event.user_id)
-                    raise IgnoredException("权限不足")
-
-    def auth_group(self, plugin_name: str, bot: Bot, event: Event):
-        """
-        说明:
-            群黑名单检测 群总开关检测
-        参数:
-            :param plugin_name: 模块名
-            :param bot: bot
-            :param event: event
-        """
-        if isinstance(event, GroupMessageEvent) or plugin_name in 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
-
-    async def auth_basic(self, plugin_name: str, bot: Bot, event: Event):
-        """
-        说明:
-            检测是否满足超级用户权限，是否被ban等
-        参数:
-            :param plugin_name: 模块名
-            :param bot: bot
-            :param event: event
-        """
-        try:
-            if (
-                (
-                    not isinstance(event, MessageEvent)
-                    and plugin_name 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 plugins2settings_manager.get_plugin_data(plugin_name)
-                and not plugins2settings_manager.get_plugin_data(
-                    plugin_name
-                ).limit_superuser
-            ):
-                raise IsSuperuserException()
-            _plugin = nonebot.plugin.get_plugin(plugin_name)
-            _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
-            ):
-                raise IsSuperuserException()
-        except AttributeError:
-            pass
-
-    async def auth_cost(self, plugin_name: str, bot: Bot, event: Event) -> int:
-        """
-        说明:
-            检测是否满足金币条件
-        参数:
-            :param plugin_name: 模块名
-            :param bot: bot
-            :param event: event
-        """
-        cost_gold = 0
-        if isinstance(event, GroupMessageEvent) and (
-            psm := plugins2settings_manager.get_plugin_data(plugin_name)
-        ):
-            if psm.cost_gold > 0:
-                if (
-                    await BagUser.get_gold(event.user_id, event.group_id)
-                    < psm.cost_gold
-                ):
-                    await send_msg(f"金币不足..该功能需要{psm.cost_gold}金币..", bot, event)
-                    raise IgnoredException(f"{plugin_name} 金币限制...")
-                # 当插件不阻塞超级用户时，超级用户提前扣除金币
-                if (
-                    str(event.user_id) in bot.config.superusers
-                    and not psm.limit_superuser
-                ):
-                    await BagUser.spend_gold(
-                        event.user_id, event.group_id, psm.cost_gold
-                    )
-                await UserShopGoldLog.add_shop_log(
-                    event.user_id, event.group_id, 2, plugin_name, psm.cost_gold, 1
-                )
-                cost_gold = psm.cost_gold
-        return cost_gold

basic_plugins/hooks/auth_hook.py

@@ -1,36 +0,0 @@
-from typing import Optional
-
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    Event,
-)
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, run_postprocessor
-from nonebot.typing import T_State
-
-from ._utils import (
-    set_block_limit_false,
-    AuthChecker,
-)
-
-
-# # 权限检测
-@run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: Event):
-    await AuthChecker().auth(matcher, bot, event)
-
-
-# 解除命令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)

basic_plugins/hooks/ban_hook.py

@@ -1,97 +0,0 @@
-from nonebot.matcher import Matcher
-from nonebot.message import run_preprocessor, IgnoredException
-from nonebot.typing import T_State
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    Event,
-    MessageEvent,
-    ActionFailed,
-    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 hasattr(event, "user_id") and (
-        (
-            (isinstance(event, MessageEvent) or isinstance(event, PokeNotifyEvent))
-            and matcher.priority not in [1, 999]
-        )
-        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 != 999:
-                    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 != 999:
-                    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.typing import T_State
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    ActionFailed,
-    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, 999]:
-        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,43 +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 nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    PrivateMessageEvent,
-    GroupMessageEvent,
-)
-
-
-# 为什么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("有命令就别说话了")
-
-
-
-

basic_plugins/hooks/task_hook.py

@@ -1,56 +0,0 @@
-from nonebot.exception import MockApiException
-from nonebot.adapters.onebot.v11 import Bot, Message
-from utils.manager import group_manager
-from services.log import logger
-from typing import Dict, Any
-import re
-
-
-@Bot.on_calling_api
-async def _(bot: Bot, api: str, data: Dict[str, Any]):
-    r = None
-    task = None
-    group_id = None
-    try:
-        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"]
-    except Exception as e:
-        logger.error(f"TaskHook ERROR {type(e)}：{e}")
-    else:
-        if task and group_id:
-            if (
-                group_manager.get_group_level(group_id) < 0
-                or not group_manager.check_task_status(task, group_id)
-            ):
-                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,59 +0,0 @@
-from configs.path_config import DATA_PATH
-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_plugin_info import init_plugin_info
-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 services.log import logger
-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
-async def _():
-    """
-    初始化数据
-    """
-    config_file = DATA_PATH / "configs" / "plugins2config.yaml"
-    _flag = not config_file.exists()
-    init()
-    init_plugin_info()
-    init_plugins_settings()
-    init_plugins_cd_limit()
-    init_plugins_block_limit()
-    init_plugins_count_limit()
-    init_plugins_data()
-    init_plugins_config()
-    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):
-    """
-    遍历查看插件加载情况
-    """
-    msg = ""
-    for plugin in plugins_manager.keys():
-        data = plugins_manager.get(plugin)
-        if data.error:
-            msg += f'{plugin}:{data.plugin_name}\n'
-    if msg and bot.config.superusers:
-        msg = "以下插件加载失败..\n" + msg
-        await bot.send_private_msg(
-            user_id=int(list(bot.config.superusers)[0]), message=msg.strip()
-        )

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,62 +0,0 @@
-from utils.manager import (
-    none_plugin_count_manager,
-    plugins2count_manager,
-    plugins2cd_manager,
-    plugins2settings_manager,
-    plugins2block_manager,
-    plugins_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.plugin_name for x in get_matchers(True)]
-    plugins_manager_list = list(plugins_manager.keys())
-    for module in plugins_manager_list:
-        try:
-            if module not in modules or none_plugin_count_manager.check(module):
-                try:
-                    plugin_name = plugins_manager.get(module).plugin_name
-                except (AttributeError, KeyError):
-                    plugin_name = ""
-                if none_plugin_count_manager.check(module):
-                    try:
-                        plugins2settings_manager.delete(module)
-                        plugins2count_manager.delete(module)
-                        plugins2cd_manager.delete(module)
-                        plugins2block_manager.delete(module)
-                        plugins_manager.delete(module)
-                        plugins_manager.save()
-                        # resources_manager.remove_resource(module)
-                        none_plugin_count_manager.delete(module)
-                        logger.info(f"{module}:{plugin_name} 插件疑似已删除，清除对应插件数据...")
-                    except Exception as e:
-                        logger.exception(
-                            f"{module}:{plugin_name} 插件疑似已删除，清除对应插件数据失败...{type(e)}：{e}"
-                        )
-                else:
-                    none_plugin_count_manager.add_count(module)
-                    logger.info(
-                        f"{module}:{plugin_name} 插件疑似已删除，"
-                        f"加载{none_plugin_count_manager._max_count}次失败后将清除对应插件数据，"
-                        f"当前次数：{none_plugin_count_manager.get(module)}"
-                    )
-            else:
-                none_plugin_count_manager.reset(module)
-        except Exception as e:
-            logger.error(f"清除插件数据错误 {type(e)}：{e}")
-    plugins2settings_manager.save()
-    plugins2count_manager.save()
-    plugins2cd_manager.save()
-    plugins2block_manager.save()
-    plugins_manager.save()
-    none_plugin_count_manager.save()

basic_plugins/init_plugin_config/init_plugin_info.py

@@ -1,124 +0,0 @@
-import random
-from types import ModuleType
-from typing import Any
-
-from configs.config import Config
-from services import logger
-from utils.manager import (plugin_data_manager, plugins2block_manager,
-                           plugins2cd_manager, plugins2count_manager,
-                           plugins2settings_manager, plugins_manager)
-from utils.manager.models import (Plugin, PluginBlock, PluginCd, PluginCount,
-                                  PluginData, PluginSetting, PluginType)
-from utils.utils import get_matchers
-
-
-def get_attr(module: ModuleType, name: str, default: Any = None) -> Any:
-    """
-    说明:
-        获取属性
-    参数:
-        :param module: module
-        :param name: name
-        :param default: default
-    """
-    return getattr(module, name) if hasattr(module, name) else default
-
-
-def init_plugin_info():
-
-    for matcher in [x for x in get_matchers(True) if x.plugin]:
-        try:
-            plugin = matcher.plugin
-            metadata = plugin.metadata
-            extra = metadata.extra if metadata else {}
-            if hasattr(plugin, "module"):
-                module = plugin.module
-                plugin_model = matcher.plugin_name
-                plugin_name = (
-                    metadata.name
-                    if metadata and metadata.name
-                    else get_attr(module, "__zx_plugin_name__", matcher.plugin_name)
-                )
-                if not plugin_name:
-                    logger.warning(f"配置文件 模块：{plugin_model} 获取 plugin_name 失败...")
-                    continue
-                if "[Admin]" in plugin_name:
-                    plugin_type = PluginType.ADMIN
-                    plugin_name = plugin_name.replace("[Admin]", "").strip()
-                elif "[Hidden]" in plugin_name:
-                    plugin_type = PluginType.HIDDEN
-                    plugin_name = plugin_name.replace("[Hidden]", "").strip()
-                elif "[Superuser]" in plugin_name:
-                    plugin_type = PluginType.SUPERUSER
-                    plugin_name = plugin_name.replace("[Superuser]", "").strip()
-                else:
-                    plugin_type = PluginType.NORMAL
-                plugin_usage = (
-                    metadata.usage
-                    if metadata and metadata.usage
-                    else get_attr(module, "__plugin_usage__")
-                )
-                plugin_des = (
-                    metadata.description
-                    if metadata and metadata.description
-                    else get_attr(module, "__plugin_des__")
-                )
-                menu_type = get_attr(module, "__plugin_type__") or ("normal",)
-                plugin_setting = get_attr(module, "__plugin_settings__")
-                if plugin_setting:
-                    plugin_setting = PluginSetting(**plugin_setting)
-                    plugin_setting.plugin_type = menu_type
-                plugin_superuser_usage = get_attr(module, "__plugin_super_usage__")
-                plugin_task = get_attr(module, "__plugin_task__")
-                plugin_version = extra.get("__plugin_version__") or get_attr(
-                    module, "__plugin_version__"
-                )
-                plugin_author = extra.get("__plugin_author__") or get_attr(
-                    module, "__plugin_author__"
-                )
-                plugin_cd = get_attr(module, "__plugin_cd_limit__")
-                if plugin_cd:
-                    plugin_cd = PluginCd(**plugin_cd)
-                plugin_block = get_attr(module, "__plugin_block_limit__")
-                if plugin_block:
-                    plugin_block = PluginBlock(**plugin_block)
-                plugin_count = get_attr(module, "__plugin_count_limit__")
-                if plugin_count:
-                    plugin_count = PluginCount(**plugin_count)
-                plugin_resources = get_attr(module, "__plugin_resources__")
-                plugin_configs = get_attr(module, "__plugin_configs__")
-                if settings := plugins2settings_manager.get(plugin_model):
-                    plugin_setting = settings
-                if plugin_cd_limit := plugins2cd_manager.get(plugin_model):
-                    plugin_cd = plugin_cd_limit
-                if plugin_block_limit := plugins2block_manager.get(plugin_model):
-                    plugin_block = plugin_block_limit
-                if plugin_count_limit := plugins2count_manager.get(plugin_model):
-                    plugin_count = plugin_count_limit
-                if plugin_cfg := Config.get(plugin_model):
-                    plugin_configs = plugin_cfg
-                plugin_status = plugins_manager.get(plugin_model)
-                if not plugin_status:
-                    plugin_status = Plugin(plugin_name=plugin_model)
-                plugin_status.author = plugin_author
-                plugin_status.version = plugin_version
-                plugin_data = PluginData(
-                    model=plugin_model,
-                    name=plugin_name.strip(),
-                    plugin_type=plugin_type,
-                    usage=plugin_usage,
-                    superuser_usage=plugin_superuser_usage,
-                    des=plugin_des,
-                    task=plugin_task,
-                    menu_type=menu_type,
-                    plugin_setting=plugin_setting,
-                    plugin_cd=plugin_cd,
-                    plugin_block=plugin_block,
-                    plugin_count=plugin_count,
-                    plugin_resources=plugin_resources,
-                    plugin_configs=plugin_configs,
-                    plugin_status=plugin_status,
-                )
-                plugin_data_manager.add_plugin_info(plugin_data)
-        except Exception as e:
-            logger.error(f"构造插件数据失败 {matcher.plugin_name} - {type(e)}：{e}")

basic_plugins/init_plugin_config/init_plugins_config.py

@@ -1,159 +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, plugin_data_manager
-from configs.config import Config
-from services.log import logger
-from utils.text_utils import prompt2cn
-from utils.utils import get_matchers
-from configs.path_config import DATA_PATH
-from ruamel import yaml
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_config():
-    """
-    初始化插件数据配置
-    """
-    plugins2config_file = DATA_PATH / "configs" / "plugins2config.yaml"
-    _data = Config.get_data()
-    # 优先使用 metadata 数据
-    for matcher in get_matchers(True):
-        if plugin_data := plugin_data_manager.get(matcher.plugin_name):
-            # 插件配置版本更新或为Version为None或不在存储配置内，当使用metadata时，必定更新
-            if plugin_data.plugin_configs and (
-                isinstance(plugin_data.plugin_status.version, str)
-                or (
-                    plugin_data.plugin_status.version is None
-                    or (
-                        _data.get(matcher.plugin_name)
-                        and _data[matcher.plugin_name].keys()
-                        != plugin_data.plugin_configs.keys()
-                    )
-                    or plugin_data.plugin_status.version
-                    > plugins_manager.get(matcher.plugin_name).version
-                    or matcher.plugin_name not in _data.keys()
-                )
-            ):
-                plugin_configs = plugin_data.plugin_configs
-                for key in plugin_configs:
-                    if isinstance(plugin_data.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]
-                        )
-            elif plugin_configs := _data.get(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
-            )
-    _replace_config()
-
-
-def _replace_config():
-    """
-    说明:
-        定时任务加载的配置读取替换
-    """
-    # 再开始读取用户配置
-    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():
-            try:
-                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)
-            except AttributeError as e:
-                raise AttributeError(
-                    f"{e}\n" + prompt2cn("可能为config.yaml配置文件填写不规范", 46)
-                )
-    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,57 +0,0 @@
-
-from ruamel.yaml import YAML
-from utils.manager import plugins_manager, plugin_data_manager
-from utils.utils import get_matchers
-from services.log import logger
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-_yaml = YAML(typ="safe")
-
-
-def init_plugins_data():
-    """
-    初始化插件数据信息
-    """
-    for matcher in get_matchers(True):
-        _plugin = matcher.plugin
-        if not _plugin:
-            continue
-        try:
-            _module = _plugin.module
-        except AttributeError:
-            if matcher.plugin_name not in plugins_manager.keys():
-                plugins_manager.add_plugin_data(
-                    matcher.plugin_name, matcher.plugin_name, error=True
-                )
-            else:
-                plugins_manager[matcher.plugin_name].error = True
-        else:
-            if plugin_data := plugin_data_manager.get(matcher.plugin_name):
-                try:
-                    plugin_version = plugin_data.plugin_status.version
-                    plugin_name = plugin_data.name
-                    plugin_author = plugin_data.plugin_status.author
-                    if matcher.plugin_name in plugins_manager.keys():
-                        plugins_manager[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 isinstance(plugin_version, str) or plugins_manager[matcher.plugin_name].version is None or (
-                        plugin_version is not None
-                        and plugin_version > float(plugins_manager[matcher.plugin_name].version)
-                    ):
-                        plugins_manager[matcher.plugin_name].plugin_name = plugin_name
-                        plugins_manager[matcher.plugin_name].author = plugin_author
-                        plugins_manager[matcher.plugin_name].version = plugin_version
-                except Exception as e:
-                    logger.error(f"插件数据 {matcher.plugin_name} 加载发生错误 {type(e)}：{e}")
-    plugins_manager.save()

basic_plugins/init_plugin_config/init_plugins_limit.py

@@ -1,64 +0,0 @@
-from utils.manager import (
-    plugins2cd_manager,
-    plugins2block_manager,
-    plugins2count_manager,
-    plugin_data_manager,
-)
-from utils.utils import get_matchers
-from configs.path_config import DATA_PATH
-
-
-def init_plugins_cd_limit():
-    """
-    加载 cd 限制
-    """
-    plugins2cd_file = DATA_PATH / "configs" / "plugins2cd.yaml"
-    plugins2cd_file.parent.mkdir(exist_ok=True, parents=True)
-    for matcher in get_matchers(True):
-        if not plugins2cd_manager.get_plugin_cd_data(matcher.plugin_name) and (
-            plugin_data := plugin_data_manager.get(matcher.plugin_name)
-        ):
-            if plugin_data.plugin_cd:
-                plugins2cd_manager.add_cd_limit(
-                    matcher.plugin_name, plugin_data.plugin_cd
-                )
-    if not plugins2cd_manager.keys():
-        plugins2cd_manager.add_cd_limit("这是一个示例")
-    plugins2cd_manager.save()
-    plugins2cd_manager.reload_cd_limit()
-
-
-def init_plugins_block_limit():
-    """
-    加载阻塞限制
-    """
-    for matcher in get_matchers(True):
-        if not plugins2block_manager.get_plugin_block_data(matcher.plugin_name) and (
-            plugin_data := plugin_data_manager.get(matcher.plugin_name)
-        ):
-            if plugin_data.plugin_block:
-                plugins2block_manager.add_block_limit(
-                    matcher.plugin_name, plugin_data.plugin_block
-                )
-    if not plugins2block_manager.keys():
-        plugins2block_manager.add_block_limit("这是一个示例")
-    plugins2block_manager.save()
-    plugins2block_manager.reload_block_limit()
-
-
-def init_plugins_count_limit():
-    """
-    加载次数限制
-    """
-    for matcher in get_matchers(True):
-        if not plugins2count_manager.get_plugin_count_data(matcher.plugin_name) and (
-            plugin_data := plugin_data_manager.get(matcher.plugin_name)
-        ):
-            if plugin_data.plugin_count:
-                plugins2count_manager.add_count_limit(
-                    matcher.plugin_name, plugin_data.plugin_count
-                )
-    if not plugins2count_manager.keys():
-        plugins2count_manager.add_count_limit("这是一个示例")
-    plugins2count_manager.save()
-    plugins2count_manager.reload_count_limit()

basic_plugins/init_plugin_config/init_plugins_resources.py

@@ -1,25 +0,0 @@
-from utils.manager import resources_manager, plugin_data_manager
-from utils.utils import get_matchers
-from services.log import logger
-from pathlib import Path
-
-
-def init_plugins_resources():
-    """
-    资源文件路径的移动
-    """
-    for matcher in get_matchers(True):
-        if plugin_data := plugin_data_manager.get(matcher.plugin_name):
-            try:
-                _module = matcher.plugin.module
-            except AttributeError:
-                logger.warning(f"插件 {matcher.plugin_name} 加载失败...，资源控制未加载...")
-            else:
-                if resources := plugin_data.plugin_resources:
-                    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,42 +0,0 @@
-from utils.manager import plugins2settings_manager, admin_manager, plugin_data_manager
-from services.log import logger
-from utils.manager.models import PluginType
-from utils.utils import get_matchers
-import nonebot
-
-
-def init_plugins_settings():
-    """
-    初始化插件设置，从插件中获取 __zx_plugin_name__，__plugin_cmd__，__plugin_settings__
-    """
-    for x in plugins2settings_manager.keys():
-        try:
-            _plugin = nonebot.plugin.get_plugin(x)
-            _module = _plugin.module
-            _module.__getattribute__("__zx_plugin_name__")
-        except (KeyError, AttributeError) as e:
-            logger.warning(f"配置文件 模块：{x} 获取 plugin_name 失败...{e}")
-    for matcher in get_matchers(True):
-        try:
-            if matcher.plugin_name not in plugins2settings_manager.keys():
-                _plugin = matcher.plugin
-                try:
-                    _module = _plugin.module
-                except AttributeError:
-                    logger.warning(f"插件 {matcher.plugin_name} 加载失败...，插件控制未加载.")
-                else:
-                    if plugin_data := plugin_data_manager.get(matcher.plugin_name):
-                        if plugin_settings := plugin_data.plugin_setting:
-                            # 管理员命令
-                            if plugin_data.plugin_type == PluginType.ADMIN:
-                                admin_manager.add_admin_plugin_settings(
-                                    matcher.plugin_name, plugin_settings.cmd, plugin_settings.level
-                                )
-                            else:
-                                plugins2settings_manager.add_plugin_settings(
-                                    matcher.plugin_name, plugin_settings
-                                )
-        except Exception as e:
-            logger.error(f'{matcher.plugin_name} 初始化 plugin_settings 发生错误 {type(e)}：{e}')
-    plugins2settings_manager.save()
-    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,
-    ActionFailed,
-    FriendRequestEvent,
-    GroupRequestEvent,
-    MessageEvent,
-)
-from models.friend_user import FriendUser
-from datetime import datetime
-from configs.config import NICKNAME, Config
-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=999, block=False, rule=lambda: 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,207 +0,0 @@
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, PrivateMessageEvent, Message, MessageEvent
-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_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["昵称", "昵称系统"],
-}
-__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: MessageEvent, 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")
-    if 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/plugin_shop/__init__.py

@@ -1,68 +0,0 @@
-from nonebot import on_command, on_regex
-
-from .data_source import show_plugin_repo, install_plugin, uninstall_plugin, download_json
-from services.log import logger
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message, MessageEvent
-from nonebot.params import CommandArg
-
-from utils.message_builder import image
-from nonebot.permission import SUPERUSER
-
-
-__zx_plugin_name__ = "插件商店 [Superuser]"
-__plugin_usage__ = """
-usage：
-    下载安装插件
-    指令：
-        查看插件仓库
-        更新插件仓库
-        安装插件 [name/id] （重新安装等同于更新）
-        卸载插件 [name/id]
-""".strip()
-__plugin_des__ = "从真寻适配仓库中下载插件"
-__plugin_cmd__ = ["查看插件仓库", "更新插件仓库", "安装插件 [name/id]", "卸载插件 [name/id]"]
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-
-show_repo = on_regex("^查看插件仓库$", priority=1, block=True, permission=SUPERUSER)
-
-update_repo = on_regex("^更新插件仓库$", priority=1, block=True, permission=SUPERUSER)
-
-install_plugin_matcher = on_command("安装插件", priority=1, block=True, permission=SUPERUSER)
-
-uninstall_plugin_matcher = on_command("卸载插件", priority=1, block=True, permission=SUPERUSER)
-
-
-@install_plugin_matcher.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    arg = arg.extract_plain_text().strip()
-    msg = await install_plugin(arg)
-    await install_plugin_matcher.send(msg)
-
-
-@uninstall_plugin_matcher.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    arg = arg.extract_plain_text().strip()
-    msg = await uninstall_plugin(arg)
-    await install_plugin_matcher.send(msg)
-
-
-@update_repo.handle()
-async def _(bot: Bot, event: MessageEvent):
-    code = await download_json()
-    if code == 200:
-        await update_repo.finish("更新插件仓库信息成功！")
-    await update_repo.send("更新插件仓库信息失败！")
-    
-
-@show_repo.handle()
-async def _(bot: Bot, event: MessageEvent):
-    msg = await show_plugin_repo()
-    if isinstance(msg, int):
-        await show_repo.finish("文件下载失败或解压失败..")
-    await show_repo.send(image(b64=msg))
-    logger.info(
-        f"(USER {event.user_id}, GROUP {event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
-        f" 查看插件仓库"
-    )
-

basic_plugins/plugin_shop/data_source.py

@@ -1,199 +0,0 @@
-import os
-import shutil
-import zipfile
-from pathlib import Path
-from typing import Union, Tuple
-from utils.manager import plugins_manager
-
-import ujson as json
-
-from services import logger
-from utils.http_utils import AsyncHttpx
-from configs.path_config import TEMP_PATH, DATA_PATH
-from utils.image_utils import text2image, BuildImage
-from utils.utils import is_number
-
-path = DATA_PATH / "plugin_shop"
-if not path.exists():
-    path.mkdir(parents=True, exist_ok=True)
-
-repo_json_url = "https://github.com/zhenxun-org/nonebot_plugins_zhenxun_bot/archive/refs/heads/index.zip"
-repo_zip_path = TEMP_PATH / "plugin_repo_json.zip"
-plugin_json = path / "zhenxun_plugins.json"
-
-extensive_plugin_path = Path() / "extensive_plugin"
-
-path = DATA_PATH / "plugin_shop"
-if not path.exists():
-    path.mkdir(parents=True, exist_ok=True)
-if not extensive_plugin_path.exists():
-    extensive_plugin_path.mkdir(parents=True, exist_ok=True)
-
-data = {}
-
-
-async def install_plugin(name: str) -> str:
-    """
-    安装插件
-    :param name: 插件名或下标
-    """
-    try:
-        if is_number(name):
-            name, code = await get_plugin_name(int(name))
-            if code != 200:
-                return name
-        plugin_url = data[name]["download_url"]
-        url = (await AsyncHttpx.get(plugin_url)).headers.get("Location")
-        zip_file = TEMP_PATH / f"{name}.zip"
-        if zip_file.exists():
-            zip_file.unlink()
-        if await AsyncHttpx.download_file(url, zip_file):
-            logger.debug("开始解压插件压缩包...")
-            # 解压
-            zf = zipfile.ZipFile(zip_file, "r")
-            extract_path = TEMP_PATH / f"{name}"
-            if extract_path.exists():
-                shutil.rmtree(extract_path.absolute(), ignore_errors=True)
-            extract_path.mkdir(exist_ok=True, parents=True)
-            for file in zf.namelist():
-                zf.extract(file, extract_path)
-            zf.close()
-            logger.debug("解压插件压缩包完成...")
-            logger.debug("开始移动插件文件夹...")
-            if (extensive_plugin_path / f"{name}").exists():
-                logger.debug("extensive_plugin目录下文件夹已存在，删除该目录插件文件夹...")
-                shutil.rmtree(
-                    (extensive_plugin_path / f"{name}").absolute(), ignore_errors=True
-                )
-            extract_path.rename(extensive_plugin_path / f"{name}")
-            tmp = ""
-            if "pyproject.toml" in os.listdir(extensive_plugin_path / f"{name}"):
-                tmp = "检测到该插件含有额外依赖，当前安装无法保证依赖完全安装成功。"
-                os.system(
-                    f"poetry run pip install -r {(extensive_plugin_path / f'{name}' / 'pyproject.toml').absolute()}"
-                )
-            elif "requirements.txt" in os.listdir(extensive_plugin_path / f"{name}"):
-                tmp = "检测到该插件含有额外依赖，当前安装无法保证依赖完全安装成功。"
-                os.system(
-                    f"poetry run pip install -r {(extensive_plugin_path / f'{name}' / 'requirements.txt').absolute()}"
-                )
-            with open(extensive_plugin_path / f"{name}" / "plugin_info.json", "w") as f:
-                json.dump(data[name], f, ensure_ascii=False, indent=4)
-            logger.debug("移动插件文件夹完成...")
-            logger.info(f"成功安装插件 {name} 成功！\n{tmp}")
-        return f"成功安装插件 {name}，请重启真寻！"
-    except Exception as e:
-        logger.error(f"安装插件 {name} 失败 {type(e)}：{e}")
-        return f"安装插件 {name} 失败 {type(e)}：{e}"
-
-
-async def uninstall_plugin(name: str) -> str:
-    """
-    删除插件
-    :param name: 插件名或下标
-    """
-    try:
-        if is_number(name):
-            name, code = await get_plugin_name(int(name))
-            if code != 200:
-                return name
-        if name not in os.listdir(extensive_plugin_path):
-            return f"未安装 {name} 插件！"
-        shutil.rmtree((extensive_plugin_path / name).absolute(), ignore_errors=True)
-        logger.info(f"插件 {name} 删除成功！")
-        return f"插件 {name} 删除成功！"
-    except Exception as e:
-        logger.error(f"删除插件 {name} 失败 {type(e)}：{e}")
-        return f"删除插件 {name} 失败 {type(e)}：{e}"
-
-
-async def show_plugin_repo() -> Union[int, str]:
-    """
-    获取插件仓库数据并格式化
-    """
-    if not plugin_json.exists():
-        code = await download_json()
-        if code != 200:
-            return code
-    plugin_info = json.load(open(plugin_json, "r", encoding="utf8"))
-    plugins_data = plugins_manager.get_data()
-    load_plugin_list = plugins_data.keys()
-    image_list = []
-    w, h = 0, 0
-    line_height = 10
-    for i, key in enumerate(plugin_info.keys()):
-        data[key] = {
-            "名称": plugin_info[key]["plugin_name"],
-            "模块": key,
-            "作者": plugin_info[key]["author"],
-            "版本": plugin_info[key]["version"],
-            "简介": plugin_info[key]["introduction"],
-            "download_url": plugin_info[key]["download_url"],
-            "github_url": plugin_info[key]["github_url"],
-        }
-        status = ""
-        version = ""
-        if key in load_plugin_list:
-            status = "<f font_color=#1a7e30>[已安装]</f>"
-            version = f"<f font_color=#1a7e30>[{plugins_data[key].version}]</f>"
-        s = (
-            f'id：{i+1}\n名称：{plugin_info[key]["plugin_name"]}'
-            f' \t\t{status}\n'
-            f"模块：{key}\n"
-            f'作者：{plugin_info[key]["author"]}\n'
-            f'版本：{plugin_info[key]["version"]} \t\t{version}\n'
-            f'简介：{plugin_info[key]["introduction"]}\n'
-            f"-------------------"
-        )
-        img = await text2image(s, font_size=20, color="#f9f6f2")
-        w = w if w > img.w else img.w
-        h += img.h + line_height
-        image_list.append(img)
-    A = BuildImage(w + 50, h + 50, color="#f9f6f2")
-    cur_h = 25
-    for img in image_list:
-        await A.apaste(img, (25, cur_h))
-        cur_h += img.h + line_height
-    return A.pic2bs4()
-
-
-async def download_json() -> int:
-    """
-    下载插件库json文件
-    """
-    try:
-        url = (await AsyncHttpx.get(repo_json_url)).headers.get("Location")
-        if repo_zip_path.exists():
-            repo_zip_path.unlink()
-        if await AsyncHttpx.download_file(url, repo_zip_path):
-            zf = zipfile.ZipFile(repo_zip_path, "r")
-            extract_path = path / "temp"
-            for file in zf.namelist():
-                zf.extract(file, extract_path)
-            zf.close()
-            if plugin_json.exists():
-                plugin_json.unlink()
-            (
-                extract_path
-                / "nonebot_plugins_zhenxun_bot-index"
-                / "zhenxun_plugins.json"
-            ).rename(plugin_json)
-            shutil.rmtree(extract_path.absolute(), ignore_errors=True)
-            return 200
-    except Exception as e:
-        logger.error(f"下载插件库压缩包失败或解压失败 {type(e)}：{e}")
-    return 999
-
-
-async def get_plugin_name(name: int) -> Tuple[str, int]:
-    """
-    通过下标获取插件名
-    :param name: 下标
-    """
-    name = int(name)
-    if not data:
-        await show_plugin_repo()
-    if name < 1 or name > len(data.keys()):
-        return "下标超过上下限！", 999
-    name = list(data.keys())[name - 1]
-    return name, 200

basic_plugins/scripts.py

@@ -1,218 +0,0 @@
-import random
-
-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 GDict
-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"
-        ),  # 新增原神群号绑定字段
-        (
-            "ALTER TABLE genshin ADD login_ticket VARCHAR(255) DEFAULT '';",
-            "genshin"
-        ),  # 新增米游社login_ticket绑定字段
-        (
-            "ALTER TABLE genshin ADD stuid VARCHAR(255) DEFAULT '';",
-            "genshin"
-        ),  # 新增米游社stuid绑定字段
-        (
-            "ALTER TABLE genshin ADD stoken VARCHAR(255) DEFAULT '';",
-            "genshin"
-        ),  # 新增米游社stoken绑定字段
-        (
-            "ALTER TABLE chat_history ADD plain_text Text;",
-            "chat_history"
-        ),  # 新增纯文本
-        (
-            "ALTER TABLE goods_info ADD daily_limit Integer DEFAULT 0;",
-            "goods_info"
-        ),  # 新增纯文本
-        (
-            "ALTER TABLE goods_info ADD daily_purchase_limit Json DEFAULT '{}';",
-            "goods_info"
-        ),  # 新增纯文本
-    ]
-    for sql in sql_str + GDict.get('run_sql', []):
-        try:
-            if isinstance(sql, str):
-                flag = f'{random.randint(1, 10000)}'
-            else:
-                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)
-
-
-@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,23 +0,0 @@
-from configs.config import Config
-from nonebot import Driver
-from utils.decorator.shop import shop_register
-import nonebot
-
-driver: Driver = nonebot.get_driver()
-
-
-Config.add_plugin_config(
-    "shop",
-    "IMPORT_DEFAULT_SHOP_GOODS",
-    True,
-    help_="导入商店自带的三个商品",
-    default_value=True
-)
-
-
-nonebot.load_plugins("basic_plugins/shop")
-
-
-@driver.on_bot_connect
-async def _():
-    await shop_register.load_register()

basic_plugins/shop/buy.py

@@ -1,109 +0,0 @@
-from nonebot import on_command
-
-from models.user_shop_gold_log import UserShopGoldLog
-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)
-        flag, n = await GoodsInfo.check_user_daily_purchase(
-            goods, event.user_id, event.group_id, num
-        )
-        if flag:
-            await buy.finish(f"该次购买将超过每日次数限制，目前该道具还可以购买{n}次哦", at_sender=True)
-        if await BagUser.buy_property(event.user_id, event.group_id, goods, num):
-            await GoodsInfo.add_user_daily_purchase(
-                goods, event.user_id, event.group_id, 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} 成功！"
-            )
-            await UserShopGoldLog.add_shop_log(
-                event.user_id,
-                event.group_id,
-                0,
-                goods.goods_name,
-                num,
-                goods.goods_price * num * goods.goods_discount,
-            )
-        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,57 +0,0 @@
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message, ActionFailed
-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.image_utils import text2image
-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):
-    msg = await BagUser.get_user_total_gold(event.user_id, event.group_id)
-    try:
-        await my_gold.send(msg)
-    except ActionFailed:
-        await my_gold.send(image(b64=(await text2image(msg, color="#f9f6f2", padding=10)).pic2bs4()))
-
-
-@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/__init__.py

@@ -1,45 +0,0 @@
-from nonebot import on_command
-
-from utils.message_builder import image
-from ._data_source import create_bag_image
-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:
-        await my_props.send(image(b64=await create_bag_image(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/my_props/_data_source.py

@@ -1,121 +0,0 @@
-from typing import Dict, List, Optional
-
-from models.bag_user import BagUser
-from models.goods_info import GoodsInfo
-from utils.image_utils import BuildImage
-from configs.path_config import IMAGE_PATH
-
-
-icon_path = IMAGE_PATH / "shop_icon"
-
-
-async def create_bag_image(props: Dict[str, int]):
-    """
-    说明:
-        创建背包道具图片
-    参数:
-        :param props: 道具仓库字典
-    """
-    goods_list = await GoodsInfo.get_all_goods()
-    active_props = await _init_prop(props, [x for x in goods_list if not x.is_passive])
-    passive_props = await _init_prop(props, [x for x in goods_list if x.is_passive])
-    active_w = 0
-    active_h = 0
-    passive_w = 0
-    passive_h = 0
-    if active_props:
-        img = BuildImage(
-            active_props.w,
-            active_props.h + 70,
-            font="CJGaoDeGuo.otf",
-            font_size=30,
-            color="#f9f6f2",
-        )
-        await img.apaste(active_props, (0, 70))
-        await img.atext((0, 30), "主动道具")
-        active_props = img
-        active_w = img.w
-        active_h = img.h
-    if passive_props:
-        img = BuildImage(
-            passive_props.w,
-            passive_props.h + 70,
-            font="CJGaoDeGuo.otf",
-            font_size=30,
-            color="#f9f6f2",
-        )
-        await img.apaste(passive_props, (0, 70))
-        await img.atext((0, 30), "被动道具")
-        passive_props = img
-        passive_w = img.w
-        passive_h = img.h
-    A = BuildImage(
-        active_w + passive_w + 100,
-        max(active_h, passive_h) + 60,
-        font="CJGaoDeGuo.otf",
-        font_size=30,
-        color="#f9f6f2",
-    )
-    curr_w = 50
-    if active_props:
-        await A.apaste(active_props, (curr_w, 0))
-        curr_w += active_props.w + 10
-    if passive_props:
-        await A.apaste(passive_props, (curr_w, 0))
-    if active_props and passive_props:
-        await A.aline(
-            (active_props.w + 45, 70, active_props.w + 45, A.h - 20), fill=(0, 0, 0)
-        )
-    return A.pic2bs4()
-
-
-async def _init_prop(
-    props: Dict[str, int], _props: List[GoodsInfo]
-) -> Optional[BuildImage]:
-    """
-    说明:
-        构造道具列表图片
-    参数:
-        :param props: 道具仓库字典
-        :param _props: 道具列表
-    """
-    active_name = [x.goods_name for x in _props]
-    name_list = [x for x in props.keys() if x in active_name]
-    if not name_list:
-        return None
-    temp_img = BuildImage(0, 0, font_size=20)
-    image_list = []
-    num_list = []
-    for i, name in enumerate(name_list):
-        img = BuildImage(
-            temp_img.getsize(name)[0] + 50,
-            30,
-            font="msyh.ttf",
-            font_size=20,
-            color="#f9f6f2",
-        )
-        await img.atext((30, 5), f"{i + 1}.{name}")
-        goods = [x for x in _props if x.goods_name == name][0]
-        if goods.icon and (icon_path / goods.icon).exists():
-            icon = BuildImage(30, 30, background=icon_path / goods.icon)
-            await img.apaste(icon, alpha=True)
-        image_list.append(img)
-        num_list.append(
-            BuildImage(
-                30, 30, font_size=20, font="msyh.ttf", plain_text=f"×{props[name]}"
-            )
-        )
-    max_w = 0
-    num_max_w = 0
-    h = 0
-    for img, num in zip(image_list, num_list):
-        h += img.h
-        max_w = max_w if max_w > img.w else img.w
-        num_max_w = num_max_w if num_max_w > num.w else num.w
-    A = BuildImage(max_w + num_max_w + 30, h, color="#f9f6f2")
-    curr_h = 0
-    for img, num in zip(image_list, num_list):
-        await A.apaste(img, (0, curr_h))
-        await A.apaste(num, (max_w + 20, curr_h + 5), True)
-        curr_h += img.h
-    return A

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,139 +0,0 @@
-from .data_source import create_shop_help, delete_goods, update_goods, register_goods, parse_goods_info, GoodsInfo
-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, scheduler
-from nonebot.params import CommandArg
-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"
-}
-
-
-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(name, at_sender=True)
-            logger.info(f"USER {event.user_id} 修改商品 {name} 数据 {text} 失败")
-
-
-@scheduler.scheduled_job(
-    "cron",
-    hour=0,
-    minute=0,
-)
-async def _():
-    try:
-        await GoodsInfo.reset_daily_purchase()
-        logger.info("商品每日限购次数重置成功...")
-    except Exception as e:
-        logger.error(f"商品每日限购次数重置发生错误 {type(e)}：{e}")

basic_plugins/shop/shop_handle/data_source.py

@@ -1,359 +0,0 @@
-from PIL import Image
-
-from models.goods_info import GoodsInfo
-from utils.image_utils import BuildImage, text2image
-from utils.utils import is_number
-from configs.path_config import IMAGE_PATH
-from typing import Optional, Union, Tuple
-from utils.utils import GDict
-import time
-
-icon_path = IMAGE_PATH / 'shop_icon'
-
-
-GDict['run_sql'].append("ALTER TABLE goods_info ADD is_passive boolean DEFAULT False;")
-GDict['run_sql'].append("ALTER TABLE goods_info ADD icon VARCHAR(255);")
-
-
-# 创建商店界面
-async def create_shop_help() -> str:
-    """
-    制作商店图片
-    :return: 图片base64
-    """
-    goods_lst = await GoodsInfo.get_all_goods()
-    _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:
-            _list.append(goods)
-    # A = BuildImage(1100, h, color="#f9f6f2")
-    total_n = 0
-    image_list = []
-    for idx, goods in enumerate(_list):
-        name_image = BuildImage(
-            580, 40, font_size=25, color="#e67b6b", font="CJGaoDeGuo.otf"
-        )
-        await name_image.atext(
-            (15, 0), f"{idx + 1}.{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")
-        if goods.goods_discount != 1:
-            discount_price = int(goods.goods_discount * goods.goods_price)
-            old_price_image = BuildImage(0, 0, plain_text=str(goods.goods_price), font_color=(194, 194, 194), font="CJGaoDeGuo.otf", font_size=15)
-            await old_price_image.aline((0, int(old_price_image.h / 2), old_price_image.w + 1, int(old_price_image.h / 2)), (0, 0, 0))
-            await name_image.apaste(
-                old_price_image, (440, 0), True
-            )
-            await name_image.atext(
-                (440, 15), str(discount_price), (255, 255, 255)
-            )
-        else:
-            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,
-            ),
-            f" 金币",
-            center_type="by_height",
-        )
-        des_image = None
-        font_img = BuildImage(
-            600, 80, font_size=20, color="#a29ad6", font="CJGaoDeGuo.otf"
-        )
-        p = font_img.getsize('简介：')[0] + 20
-        if goods.goods_description:
-            des_list = goods.goods_description.split('\n')
-            desc = ''
-            for des in des_list:
-                if font_img.getsize(des)[0] > font_img.w - p - 20:
-                    msg = ''
-                    tmp = ''
-                    for i in range(len(des)):
-                        if font_img.getsize(tmp)[0] < font_img.w - p - 20:
-                            tmp += des[i]
-                        else:
-                            msg += tmp + '\n'
-                            tmp = des[i]
-                    desc += msg
-                    if tmp:
-                        desc += tmp
-                else:
-                    desc += des + '\n'
-            if desc[-1] == '\n':
-                desc = desc[:-1]
-            des_image = await text2image(desc, color="#a29ad6")
-        goods_image = BuildImage(
-            600, (50 + des_image.h) if des_image else 50, font_size=20, color="#a29ad6", font="CJGaoDeGuo.otf"
-        )
-        if des_image:
-            await goods_image.atext((15, 50), '简介：')
-            await goods_image.apaste(des_image, (p, 50))
-        await name_image.acircle_corner(5)
-        await goods_image.apaste(name_image, (0, 5), True, center_type="by_width")
-        await goods_image.acircle_corner(20)
-        bk = BuildImage(1180, (50 + des_image.h) if des_image else 50, font_size=15, color="#f9f6f2", font="CJGaoDeGuo.otf")
-        if goods.icon and (icon_path / goods.icon).exists():
-            icon = BuildImage(70, 70, background=icon_path / goods.icon)
-            await bk.apaste(icon)
-        await bk.apaste(goods_image, (70, 0), alpha=True)
-        n = 0
-        _w = 650
-        # 添加限时图标和时间
-        if goods.goods_limit_time > 0:
-            n += 140
-            _limit_time_logo = BuildImage(
-                40, 40, background=f"{IMAGE_PATH}/other/time.png"
-            )
-            await bk.apaste(_limit_time_logo, (_w + 50, 0), True)
-            await bk.apaste(
-                BuildImage(0, 0, plain_text="限时！", font_size=23, font="CJGaoDeGuo.otf"),
-                (_w + 90, 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((_w + 55, 38), str(y_m_d))
-            await bk.atext((_w + 65, 57), str(h_m))
-            _w += 140
-        if goods.goods_discount != 1:
-            n += 140
-            _discount_logo = BuildImage(30, 30, background=f"{IMAGE_PATH}/other/discount.png")
-            await bk.apaste(_discount_logo, (_w + 50, 10), True)
-            await bk.apaste(
-                BuildImage(0, 0, plain_text="折扣！", font_size=23, font="CJGaoDeGuo.otf"),
-                (_w + 90, 15),
-                True,
-            )
-            await bk.apaste(
-                BuildImage(0, 0, plain_text=f"{10 * goods.goods_discount:.1f} 折", font_size=30, font="CJGaoDeGuo.otf", font_color=(85, 156, 75)),
-                (_w + 50, 44),
-                True,
-            )
-            _w += 140
-        if goods.daily_limit != 0:
-            n += 140
-            _daily_limit_logo = BuildImage(35, 35, background=f"{IMAGE_PATH}/other/daily_limit.png")
-            await bk.apaste(_daily_limit_logo, (_w + 50, 10), True)
-            await bk.apaste(
-                BuildImage(0, 0, plain_text="限购！", font_size=23, font="CJGaoDeGuo.otf"),
-                (_w + 90, 20),
-                True,
-            )
-            await bk.apaste(
-                BuildImage(0, 0, plain_text=f"{goods.daily_limit}", font_size=30, font="CJGaoDeGuo.otf"),
-                (_w + 72, 45),
-                True,
-            )
-        if total_n < n:
-            total_n = n
-        if n:
-            await bk.aline((650, -1, 650 + n, -1), "#a29ad6", 5)
-            # await bk.aline((650, 80, 650 + n, 80), "#a29ad6", 5)
-
-        # 添加限时图标和时间
-        image_list.append(bk)
-        # await A.apaste(bk, (0, current_h), True)
-        # current_h += 90
-    h = 0
-    current_h = 0
-    for img in image_list:
-        h += img.h + 10
-    A = BuildImage(1100, h, color="#f9f6f2")
-    for img in image_list:
-        await A.apaste(img, (0, current_h), True)
-        current_h += img.h + 10
-    w = 950
-    if total_n:
-        w += total_n
-    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")
-    zx_img = BuildImage(0, 0, background=f"{IMAGE_PATH}/zhenxun/toukan_3.png")
-    zx_img.transpose(Image.FLIP_LEFT_RIGHT)
-    zx_img.replace_color_tran(((240, 240, 240), (255, 255, 255)), (249, 246, 242))
-    await shop.apaste(zx_img, (0, 100))
-    shop.paste(A, (20 + zx_img.w, 230))
-    await shop.apaste(shop_logo, (450, 30), True)
-    shop.text(
-        (int((1000 - shop.getsize("注【通过 序号 或者 商品名称 购买】")[0]) / 2), 170),
-        "注【通过 序号 或者 商品名称 购买】",
-    )
-    shop.text((20 + zx_img.w, 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,
-    daily_limit: Optional[int] = 0,
-    is_passive: Optional[bool] = False,
-    icon: Optional[str] = None,
-) -> bool:
-    """
-    添加商品
-    例如：                                                  折扣：可选参数↓  限时时间:可选，单位为小时
-        添加商品 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 daily_limit: 每日购买次数限制
-    :param is_passive: 是否为被动
-    :param icon: 图标
-    :return: 是否添加成功
-    """
-    if not await GoodsInfo.get_goods_info(name):
-        limit_time = float(limit_time) if limit_time else limit_time
-        discount = discount if discount is not 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, daily_limit, is_passive, icon
-        )
-    return False
-
-
-# 删除商品
-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) -> Tuple[bool, str, str]:
-    """
-    更新商品信息
-    :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 False, "序号错误，没有该序号的商品...", ""
-            goods = goods_lst[int(kwargs["name"]) - 1]
-        else:
-            goods = await GoodsInfo.get_goods_info(kwargs["name"])
-            if not goods:
-                return False, "名称错误，没有该名称的商品...", ""
-        name: str = goods.goods_name
-        price = goods.goods_price
-        des = goods.goods_description
-        discount = goods.goods_discount
-        limit_time = goods.goods_limit_time
-        daily_limit = goods.daily_limit
-        is_passive = goods.is_passive
-        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),
-            ) if kwargs["limit_time"] != 0 else 0
-            tmp += f"限时至： {new_time}\n" if new_time else "取消了限时\n"
-            limit_time = kwargs["limit_time"]
-        if kwargs.get("daily_limit"):
-            tmp += f'每日购买限制：{daily_limit} --> {kwargs["daily_limit"]}\n' if daily_limit else "取消了购买限制\n"
-            daily_limit = int(kwargs["daily_limit"])
-        if kwargs.get("is_passive"):
-            tmp += f'被动道具：{is_passive} --> {kwargs["is_passive"]}\n'
-            des = kwargs["is_passive"]
-        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
-            ),
-            daily_limit,
-            is_passive
-        )
-        return True, 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]
-            elif sp[0] == "daily_limit":
-                if not is_number(sp[1]) or float(sp[1]) < 0:
-                    return "daily_limit参数不合法，必须为数字且大于0！"
-                data["daily_limit"] = sp[1]
-    return data

basic_plugins/shop/use/__init__.py

@@ -1,107 +0,0 @@
-from typing import Any, Tuple
-
-from nonebot import on_command, on_regex
-
-from models.user_shop_gold_log import UserShopGoldLog
-from services.log import logger
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message
-from nonebot.params import CommandArg, RegexGroup
-
-from utils.decorator.shop import NotMeetUseConditionsException
-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 .data_source import effect, register_use, func_manager, build_params
-
-
-__zx_plugin_name__ = "商店 - 使用道具"
-__plugin_usage__ = """
-usage：
-    普通的使用道具
-    指令：
-        使用道具 [序号或道具名称] ?[数量]=1 ?[其他信息]
-        示例：使用道具好感度双倍加持卡         使用道具好感度双倍加持卡
-        示例：使用道具1                     使用第一个道具
-        示例：使用道具1 10                  使用10个第一个道具       
-        示例：使用道具1 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": ["商店", "使用道具"],
-}
-
-
-use_props = on_command(r"使用道具", priority=5, block=True, permission=GROUP)
-
-
-@use_props.handle()
-async def _(bot: Bot, event: GroupMessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text()
-    num = 1
-    text = ""
-    prop_n = None
-    index = None
-    split = msg.split()
-    if size := len(split):
-        if size == 1:
-            prop_n = split[0].strip()
-            index = 1
-        if size > 1 and is_number(split[1].strip()):
-            prop_n = split[0].strip()
-            num = int(split[1].strip())
-            index = 2
-    else:
-        await use_props.finish("缺少参数，请查看帮助", at_sender=True)
-    if index:
-        text = " ".join(split[index:])
-    property_ = await BagUser.get_property(event.user_id, event.group_id, True)
-    if property_:
-        name = None
-        if prop_n and is_number(prop_n):
-            if 0 < int(prop_n) <= len(property_):
-                name = list(property_.keys())[int(prop_n) - 1]
-            else:
-                await use_props.finish("仔细看看自己的道具仓库有没有这个道具？", at_sender=True)
-        else:
-            if prop_n not in property_.keys():
-                await use_props.finish("道具名称错误！", at_sender=True)
-            name = prop_n
-        _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} 个！")
-        model, kwargs = build_params(bot, event, name, num, text)
-        try:
-            await func_manager.run_handle(type_="before_handle", param=model, **kwargs)
-        except NotMeetUseConditionsException as e:
-            await use_props.finish(e.get_info(), at_sender=True)
-        async with db.transaction():
-            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, text, event.message):
-                    await use_props.send(msg, at_sender=True)
-                logger.info(
-                    f"USER {event.user_id} GROUP {event.group_id} 使用道具 {name} {num} 次成功"
-                )
-                await UserShopGoldLog.add_shop_log(
-                    event.user_id, event.group_id, 1, 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} 次失败"
-                )
-        await func_manager.run_handle(type_="after_handle", param=model, **kwargs)
-    else:
-        await use_props.send("您的背包里没有任何的道具噢", at_sender=True)

basic_plugins/shop/use/data_source.py

@@ -1,236 +0,0 @@
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageSegment, Message
-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, Callable, List, Tuple, Dict, Any
-from types import MappingProxyType
-import inspect
-import asyncio
-
-
-class GoodsUseFuncManager:
-    def __init__(self):
-        self._data = {}
-
-    def register_use_before_handle(self, goods_name: str, fun_list: List[Callable]):
-        """
-        说明:
-            注册商品使用前函数
-        参数:
-            :param goods_name: 商品名称
-            :param fun_list: 函数列表
-        """
-        if fun_list:
-            self._data[goods_name]["before_handle"] = fun_list
-            logger.info(f"register_use_before_handle 成功注册商品：{goods_name} 的{len(fun_list)}个使用前函数")
-
-    def register_use_after_handle(self, goods_name: str, fun_list: List[Callable]):
-        """
-        说明:
-            注册商品使用后函数
-        参数:
-            :param goods_name: 商品名称
-            :param fun_list: 函数列表
-        """
-        if fun_list:
-            self._data[goods_name]["after_handle"] = fun_list
-            logger.info(f"register_use_after_handle 成功注册商品：{goods_name} 的{len(fun_list)}个使用后函数")
-
-    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
-
-    def _parse_args(self, args_: MappingProxyType, param: ShopParam, **kwargs):
-        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_
-
-    async def use(
-        self, param: ShopParam, **kwargs
-    ) -> Optional[Union[str, MessageSegment]]:
-        """
-        使用道具
-        :param param: BaseModel
-        :param kwargs: kwargs
-        """
-        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"](
-                        *self._parse_args(args, param, **kwargs)
-                    )
-                else:
-                    return self._data[goods_name]["func"](
-                        *self._parse_args(args, param, **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,
-                    )
-
-    async def run_handle(self, goods_name: str, type_: str, param: ShopParam, **kwargs):
-        if self._data[goods_name].get(type_):
-            for func in self._data[goods_name].get(type_):
-                args = inspect.signature(func).parameters
-                if args and list(args.keys())[0] != "kwargs":
-                    if asyncio.iscoroutinefunction(func):
-                        await func(*self._parse_args(args, param, **kwargs))
-                    else:
-                        func(*self._parse_args(args, param, **kwargs))
-                else:
-                    if asyncio.iscoroutinefunction(func):
-                        await func(**kwargs)
-                    else:
-                        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, text: str):
-        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,
-                "message": event.message,
-                "text": text
-            }
-        )
-
-
-func_manager = GoodsUseFuncManager()
-
-
-def build_params(
-    bot: Bot, event: GroupMessageEvent, goods_name: str, num: int, text: str
-) -> Tuple[ShopParam, Dict[str, Any]]:
-    """
-    说明:
-        构造参数
-    参数:
-        :param bot: bot
-        :param event: event
-        :param goods_name: 商品名称
-        :param num: 数量
-        :param text: 其他信息
-    :return:
-    """
-    _kwargs = func_manager.get_kwargs(goods_name)
-    return (
-        func_manager.init_model(goods_name, bot, event, num, text),
-        {
-            **_kwargs,
-            "_bot": bot,
-            "event": event,
-            "group_id": event.group_id,
-            "user_id": event.user_id,
-            "num": num,
-            "text": text,
-            "message": event.message,
-            "goods_name": goods_name,
-        },
-    )
-
-
-async def effect(
-    bot: Bot, event: GroupMessageEvent, goods_name: str, num: int, text: str, message: Message
-) -> Optional[Union[str, MessageSegment]]:
-    """
-    商品生效
-    :param bot: Bot
-    :param event: GroupMessageEvent
-    :param goods_name: 商品名称
-    :param num: 使用数量
-    :param text: 其他信息
-    :param message: Message
-    :return: 使用是否成功
-    """
-    # 优先使用注册的商品插件
-    # try:
-    if func_manager.exists(goods_name):
-        _kwargs = func_manager.get_kwargs(goods_name)
-        model, kwargs = build_params(bot, event, goods_name, num, text)
-        return await func_manager.use(model, **kwargs)
-    # except Exception as e:
-    #     logger.error(f"use 商品生效函数effect 发生错误 {type(e)}：{e}")
-    return None
-
-
-def register_use(goods_name: str, func: Callable, **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/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 group_handle.send("同意群聊请求失败，未找到此id的请求..")
-        else:
-            flag = await requests_manager.refused(bot, id_, "group")
-        if flag == 1:
-            await group_handle.send(f"{cmd[:2]}群聊请求失败，该请求已失效..")
-            requests_manager.delete_request(id_, "group")
-        elif flag == 2:
-            await group_handle.send(f"{cmd[:2]}群聊请求失败，未找到此id的请求..")
-        else:
-            await group_handle.send(f"{cmd[:2]}群聊请求成功！")
-    else:
-        await group_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 clear_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,86 +0,0 @@
-from nonebot.adapters.onebot.v11 import Message, Bot, MessageEvent
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from utils.message_builder import custom_forward_msg
-from services.db_context import db
-from nonebot.params import CommandArg
-from services.log import logger
-
-import asyncio
-
-__zx_plugin_name__ = "执行sql [Superuser]"
-__plugin_usage__ = """
-usage：
-    执行一段sql语句
-    指令：
-        exec [sql语句] ([查询页数，19条/页])
-        查看所有表
-""".strip()
-__plugin_des__ = "执行一段sql语句"
-__plugin_cmd__ = [
-    "exec [sql语句]",
-]
-__plugin_version__ = 0.2
-__plugin_author__ = "HibiKier"
-
-
-exec_ = on_command("exec", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
-tables = on_command("查看所有表", rule=to_me(), permission=SUPERUSER, priority=1, block=True)
-
-
-@exec_.handle()
-async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
-    sql = arg.extract_plain_text().strip()
-    async with db.transaction():
-        try:
-            # 判断是否为SELECT语句
-            if sql.lower().startswith("select"):
-                # 分割语句
-                try:
-                    page = int(sql.split(" ")[-1]) - 1
-                    sql_list = sql.split(" ")[:-1]
-                except ValueError:
-                    page = 0
-                    sql_list = sql.split(" ")
-                # 拼接语句
-                sql = " ".join(sql_list)
-                query = db.text(sql)
-                res = await db.all(query)
-                msg_list = [f"第{page+1}页查询结果："]
-                # logger.info(res)
-                # 获取所有字段
-                keys = res[0].keys()
-                # 每页10条
-                for i in res[page * 10 : (page + 1) * 10]:
-                    msg = ""
-                    for key in keys:
-                        msg += f"{key}: {i[key]}\n"
-                    msg += f"第{page+1}页第{res.index(i)+1}条"
-                    msg_list.append(msg)
-                # 检查是私聊还是群聊
-                try:
-                    forward_msg_list = custom_forward_msg(msg_list, bot.self_id)
-                    await bot.send_group_forward_msg(group_id=event.group_id, messages=forward_msg_list)
-                except:
-                    for msg in msg_list:
-                        await exec_.send(msg)
-                        await asyncio.sleep(0.2)
-                return
-            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}")
-
-
-@tables.handle()
-async def _(bot: Bot, event: MessageEvent):
-    # 获取所有表
-    query = db.text("select tablename from pg_tables where schemaname = 'public'")
-    res = await db.all(query)
-    msg = "数据库中的所有表名：\n"
-    for tablename in res:
-        msg += str(tablename["tablename"]) + "\n"
-    await tables.finish(msg)

basic_plugins/super_cmd/manager_group.py

@@ -1,204 +0,0 @@
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GROUP,
-    GroupMessageEvent,
-    Message,
-    ActionFailed,
-)
-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.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,70 +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"],
-            1
-        ):
-            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,24 +0,0 @@
-from nonebot import on_command
-from nonebot.permission import SUPERUSER
-from nonebot.rule import to_me
-from utils.message_builder import image
-from .data_source import create_help_image, SUPERUSER_HELP_IMAGE
-
-
-__zx_plugin_name__ = '超级用户帮助 [Superuser]'
-
-
-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,84 +0,0 @@
-
-import nonebot
-from configs.path_config import IMAGE_PATH
-from nonebot import Driver
-from services.log import logger
-from utils.image_template import help_template
-from utils.image_utils import (BuildImage, build_sort_image, group_image,
-                               text2image)
-from utils.manager import plugin_data_manager
-from utils.manager.models import PluginType
-
-driver: Driver = nonebot.get_driver()
-
-SUPERUSER_HELP_IMAGE = IMAGE_PATH / "superuser_help.png"
-
-
-@driver.on_bot_connect
-async def create_help_image():
-    """
-    创建超级用户帮助图片
-    """
-    if SUPERUSER_HELP_IMAGE.exists():
-        return
-    plugin_data_ = plugin_data_manager.get_data()
-    image_list = []
-    task_list = []
-    for plugin_data in [
-        plugin_data_[x]
-        for x in plugin_data_
-        if plugin_data_[x].name != "超级用户帮助 [Superuser]"
-    ]:
-        try:
-            if plugin_data.plugin_type in [PluginType.SUPERUSER, PluginType.ADMIN]:
-                usage = None
-                if (
-                    plugin_data.plugin_type == PluginType.SUPERUSER
-                    and plugin_data.usage
-                ):
-                    usage = await text2image(
-                        plugin_data.usage, padding=5, color=(204, 196, 151)
-                    )
-                if plugin_data.superuser_usage:
-                    usage = await text2image(
-                        plugin_data.superuser_usage, padding=5, color=(204, 196, 151)
-                    )
-                if usage:
-                    await usage.acircle_corner()
-                    image = await help_template(plugin_data.name, usage)
-                    image_list.append(image)
-            if plugin_data.task:
-                for x in plugin_data.task.keys():
-                    task_list.append(plugin_data.task[x])
-        except Exception as e:
-            logger.warning(
-                f"获取超级用户插件 {plugin_data.model}: {plugin_data.name} 设置失败... {type(e)}：{e}"
-            )
-    task_str = "\n".join(task_list)
-    task_str = "通过私聊 开启被动/关闭被动 + [被动名称] 来控制全局被动\n----------\n" + task_str
-    task_image = await text2image(
-        task_str, padding=5, color=(204, 196, 151)
-    )
-    task_image = await help_template("被动任务", task_image)
-    image_list.append(task_image)
-    image_group, _ = group_image(image_list)
-    A = await build_sort_image(image_group, color="#f9f6f2", padding_top=180)
-    await A.apaste(
-        BuildImage(0, 0, font="CJGaoDeGuo.otf", plain_text="超级用户帮助", font_size=50),
-        (50, 30),
-        True,
-    )
-    await A.apaste(
-        BuildImage(
-            0,
-            0,
-            font="CJGaoDeGuo.otf",
-            plain_text="注: ‘*’ 代表可有多个相同参数 ‘?’ 代表可省略该参数",
-            font_size=30,
-            font_color="red",
-        ),
-        (50, 90),
-        True,
-    )
-    await A.asave(SUPERUSER_HELP_IMAGE)
-    logger.info(f"已成功加载 {len(image_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,20 +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.register_adapter(OneBotV11Adapter)
+# driver.register_adapter(KaiheilaAdapter)
+# driver.register_adapter(DoDoAdapter)
+# driver.register_adapter(DiscordAdapter)
+
+from zhenxun.services.db_context import disconnect, init
+
 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("extensive_plugin")
-# 最后加载权限控制
-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,29 +0,0 @@
-from typing import Optional
-from pathlib import Path
-from .utils import ConfigsManager
-
-import platform
-if platform.system() == "Linux":
-    import os
-    hostip = os.popen("cat /etc/resolv.conf | grep nameserver | awk '{ print $2 }'").read().replace("\n","")
-
-# 回复消息名称
-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"
-# 如果是WLS 可以 f"http://{hostip}:7890" 使用寄主机的代理
-SYSTEM_PROXY: Optional[str] = None  # 全局代理
-
-
-Config = ConfigsManager(Path() / "data" / "configs" / "plugins2config.yaml")

configs/path_config.py

@@ -1,47 +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"
-# 网页模板路径
-TEMPLATE_PATH = Path() / "resources" / "template"
-
-
-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,236 +0,0 @@
-import copy
-from typing import Optional, Any, Union
-from pathlib import Path
-from ruamel.yaml import YAML
-from ruamel import yaml
-from ruamel.yaml.scanner import ScannerError
-
-
-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 not self._data:
-                    self.file.unlink()
-                    raise ValueError(
-                        "配置文件为空！\n"
-                        "***********************************************************\n"
-                        "****** 配置文件 plugins2config.yaml 为空，已删除，请重启 ******\n"
-                        "***********************************************************"
-                    )
-            if self._simple_file.exists():
-                try:
-                    with open(self._simple_file, "r", encoding="utf8") as f:
-                        self._simple_data = _yaml.load(f)
-                except ScannerError as e:
-                    raise ScannerError(
-                        f"{e}\n**********************************************\n"
-                        f"****** 可能为config.yaml配置文件填写不规范 ******\n"
-                        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: Any, auto_save: bool = False, save_simple_data: bool = True):
-        """
-        设置配置值
-        :param module: 模块名
-        :param key: 配置名称
-        :param value: 值
-        :param auto_save: 自动保存
-        :param save_simple_data: 保存至config.yaml
-        """
-        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
-            if auto_save:
-                self.save(save_simple_data=save_simple_data)
-
-    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:  Any):
-        """
-        设置配置默认值
-        :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()
-        if self._simple_file.exists():
-            with open(self._simple_file, "r", encoding="utf8") as f:
-                self._simple_data = _yaml.load(f)
-        for key in self._simple_data.keys():
-            for k in self._simple_data[key].keys():
-                self._data[key][k]["value"] = self._simple_data[key][k]
-        self.save()
-
-    def get_admin_level_data(self):
-        """
-        获取管理插件等级
-        """
-        return self._admin_level_data
-
-    def get_data(self):
-        return copy.deepcopy(self._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]