fix: 修复头像裁剪容器高度异常

- 穿透设置 cropperjs 动态插入的 cropper-canvas 高度
- 解决头像上传裁剪区域只显示 100px 的问题

.eslintignore

@@ -1,8 +0,0 @@
-/build/
-/config/
-/dist/
-/*.js
-/test/unit/coverage/
-/node_modules/*
-/dist*
-/src/main.ts

.eslintrc.js

@@ -1,75 +0,0 @@
-// @ts-check
-const { defineConfig } = require('eslint-define-config')
-module.exports = defineConfig({
-  root: true,
-  env: {
-    browser: true,
-    node: true,
-    es6: true
-  },
-  parser: 'vue-eslint-parser',
-  parserOptions: {
-    parser: '@typescript-eslint/parser',
-    ecmaVersion: 2020,
-    sourceType: 'module',
-    jsxPragma: 'React',
-    ecmaFeatures: {
-      jsx: true
-    }
-  },
-  extends: [
-    'plugin:vue/vue3-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'prettier',
-    'plugin:prettier/recommended',
-    '@unocss'
-  ],
-  rules: {
-    'vue/no-setup-props-destructure': 'off',
-    'vue/script-setup-uses-vars': 'error',
-    'vue/no-reserved-component-names': 'off',
-    '@typescript-eslint/ban-ts-ignore': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/no-var-requires': 'off',
-    '@typescript-eslint/no-empty-function': 'off',
-    'vue/custom-event-name-casing': 'off',
-    'no-use-before-define': 'off',
-    '@typescript-eslint/no-use-before-define': 'off',
-    '@typescript-eslint/ban-ts-comment': 'off',
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-unused-vars': 'off',
-    'no-unused-vars': 'off',
-    'space-before-function-paren': 'off',
-
-    'vue/attributes-order': 'off',
-    'vue/one-component-per-file': 'off',
-    'vue/html-closing-bracket-newline': 'off',
-    'vue/max-attributes-per-line': 'off',
-    'vue/multiline-html-element-content-newline': 'off',
-    'vue/singleline-html-element-content-newline': 'off',
-    'vue/attribute-hyphenation': 'off',
-    'vue/require-default-prop': 'off',
-    'vue/require-explicit-emits': 'off',
-    'vue/require-toggle-inside-transition': 'off',
-    'vue/html-self-closing': [
-      'error',
-      {
-        html: {
-          void: 'always',
-          normal: 'never',
-          component: 'always'
-        },
-        svg: 'always',
-        math: 'always'
-      }
-    ],
-    'vue/multi-word-component-names': 'off',
-    'vue/no-v-html': 'off',
-    'prettier/prettier': 'off', // 芋艿：默认关闭 prettier 的 ESLint 校验，因为我们使用的是 IDE 的 Prettier 插件
-    '@unocss/order': 'off', // 芋艿：禁用 unocss 【css】顺序的提示，因为暂时不需要这么严格，警告也有点繁琐
-    '@unocss/order-attributify': 'off' // 芋艿：禁用 unocss 【属性】顺序的提示，因为暂时不需要这么严格，警告也有点繁琐
-  }
-})

.gitignore

@@ -7,3 +7,4 @@ pnpm-debug
 auto-*.d.ts
 .idea
 .history
+output/

.vscode/settings.json

@@ -1,5 +1,7 @@
 {
-  "typescript.tsdk": "node_modules/typescript/lib",
+  "typescript.tsdk": "./node_modules/typescript/lib",
+  "volar.tsPlugin": true,
+  "volar.tsPluginStatus": false,
   "npm.packageManager": "pnpm",
   "editor.tabSize": 2,
   "prettier.printWidth": 100, // 超过最大值换行
@@ -83,54 +85,75 @@
     "editor.defaultFormatter": "esbenp.prettier-vscode"
   },
   "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": "explicit",
-    "source.fixAll.stylelint": "explicit"
+    "source.fixAll.eslint": "explicit"
   },
   "editor.formatOnSave": true,
   "[vue]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode"
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit",
+      "source.fixAll.stylelint": "explicit"
+    }
   },
   "i18n-ally.localesPaths": ["src/locales"],
   "i18n-ally.keystyle": "nested",
   "i18n-ally.sortKeys": true,
-  "i18n-ally.namespace": false,
+  "i18n-ally.namespace": true,
   "i18n-ally.enabledParsers": ["ts"],
   "i18n-ally.sourceLanguage": "en",
   "i18n-ally.displayLanguage": "zh-CN",
   "i18n-ally.enabledFrameworks": ["vue", "react"],
   "cSpell.words": [
-    "brotli",
-    "browserslist",
-    "codemirror",
-    "commitlint",
-    "cropperjs",
-    "echart",
-    "echarts",
-    "esnext",
-    "esno",
-    "iconify",
-    "INTLIFY",
-    "lintstagedrc",
-    "logicflow",
-    "nprogress",
-    "pinia",
-    "pnpm",
-    "qrcode",
-    "sider",
-    "sortablejs",
-    "stylelint",
-    "svgs",
-    "unocss",
-    "unplugin",
-    "unref",
-    "videojs",
-    "VITE",
-    "vitejs",
-    "vueuse",
-    "wangeditor",
     "xingyu",
     "yudao",
-    "zxcvbn"
+    "unocss",
+    "browserslist",
+    "esnext",
+    "unplugin",
+    "qrcode",
+    "sider",
+    "pinia",
+    "sider",
+    "nprogress",
+    "INTLIFY",
+    "stylelint",
+    "esno",
+    "vitejs",
+    "sortablejs",
+    "codemirror",
+    "iconify",
+    "commitlint",
+    "videojs",
+    "echarts",
+    "wangeditor",
+    "cropperjs",
+    "logicflow",
+    "vueuse",
+    "zxcvbn",
+    "lintstagedrc",
+    "brotli",
+    "sider",
+    "pnpm"
+  ],
+  "vetur.format.scriptInitialIndent": true,
+  "vetur.format.styleInitialIndent": true,
+  "vetur.validation.script": false,
+  "MicroPython.executeButton": [
+    {
+      "text": "▶",
+      "tooltip": "运行",
+      "alignment": "left",
+      "command": "extension.executeFile",
+      "priority": 3.5
+    }
+  ],
+  "MicroPython.syncButton": [
+    {
+      "text": "$(sync)",
+      "tooltip": "同步",
+      "alignment": "left",
+      "command": "extension.execute",
+      "priority": 4
+    }
   ],
   // 控制相关文件嵌套展示
   "explorer.fileNesting.enabled": true,
@@ -139,8 +162,7 @@
     "*.ts": "$(capture).test.ts, $(capture).test.tsx",
     "*.tsx": "$(capture).test.ts, $(capture).test.tsx",
     "*.env": "$(capture).env.*",
-    "package.json": "pnpm-lock.yaml,yarn.lock,LICENSE,README*,CHANGELOG*,CNAME,.gitattributes,.eslintrc-auto-import.json,.gitignore,prettier.config.js,stylelint.config.js,commitlint.config.js,.stylelintignore,.prettierignore,.gitpod.yml,.eslintrc.js,.eslintignore"
+    "package.json": "pnpm-lock.yaml,yarn.lock,LICENSE,README*,CHANGELOG*,CNAME,.gitattributes,.gitignore,prettier.config.js,stylelint.config.js,commitlint.config.js,.stylelintignore,.prettierignore,.gitpod.yml,.eslintrc.js,.eslintignore"
   },
-  "terminal.integrated.scrollback": 10000,
-  "nuxt.isNuxtApp": false
+  "terminal.integrated.scrollback": 10000
 }

README.md

@@ -87,7 +87,7 @@
 
 * 通用模块（必选）：系统功能、基础设施
 * 通用模块（可选）：工作流程、支付系统、数据报表、会员中心
-* 业务系统（按需）：ERP 系统、CRM 系统、商城系统、微信公众号、AI 大模型
+* 业务系统（按需）：Mall 电子商城、OA 办公自动化、ERP 企业资源计划系统、WMS 仓库管理系统、CRM 客户关系管理、CMS 内容管理系统、MES 执行制造系统、AI 大模型平台、IoT 物联网系统、IM 即时通讯系统、Mobile 手机移动端、Report 数据大屏
 
 ### 系统功能
 
@@ -222,18 +222,44 @@
 
 ![功能图](/.image/common/mall-preview.png)
 
+### 会员中心
+
+|     | 功能   | 描述                               |
+|-----|------|----------------------------------|
+| 🚀  | 会员管理 | 会员是 C 端的消费者，该功能用于会员的搜索与管理        |
+| 🚀  | 会员标签 | 对会员的标签进行创建、查询、修改、删除等操作           |
+| 🚀  | 会员等级 | 对会员的等级、成长值进行管理，可用于订单折扣等会员权益      |
+| 🚀  | 会员分组 | 对会员进行分组，用于用户画像、内容推送等运营手段         |
+| 🚀  | 积分签到 | 回馈给签到、消费等行为的积分，会员可订单抵现、积分兑换等途径消耗 |
+
 ### ERP 系统
 
 演示地址：<https://doc.iocoder.cn/erp-preview/>
 
 ![功能图](/.image/common/erp-feature.png)
 
+### WMS 系统
+
+演示地址：<https://doc.iocoder.cn/wms-preview/>
+
+![功能图](/.image/common/wms-feature.png)
+
+![预览图](/.image/common/wms-preview.png)
+
 ### CRM 系统
 
 演示地址：<https://doc.iocoder.cn/crm-preview/>
 
 ![功能图](/.image/common/crm-feature.png)
 
+### MES 系统
+
+演示地址：<https://doc.iocoder.cn/mes-preview/>
+
+![功能图](/.image/common/mes-feature.png)
+
+![功能图](/.image/common/mes-preview.png)
+
 ### AI 大模型
 
 演示地址：<https://doc.iocoder.cn/ai-preview/>
@@ -242,6 +268,35 @@
 
 ![功能图](/.image/common/ai-preview.gif)
 
+### MES 系统
+
+演示地址：<https://doc.iocoder.cn/mes-preview/>
+
+![功能图](/.image/common/mes-feature.png)
+
+![预览图](/.image/common/mes-preview.png)
+
+### IoT 物联网
+
+演示地址：<https://doc.iocoder.cn/iot/build>
+
+![功能图](/.image/common/iot-feature.png)
+
+![预览图](/.image/common/iot-preview.png)
+
+### IM 即时通讯
+
+演示地址（Vue3 + Element Plus）：<http://dashboard-vue3.yudao.iocoder.cn>
+
+使用文档：<https://doc.iocoder.cn/im-preview/>
+
+
+![功能图](/.image/common/im-feature.png)
+
+| 聊天界面 | 聊天管理 |
+| --- | --- |
+| ![聊天界面](/.image/common/im-preview-home.png) | ![聊天管理](/.image/common/im-preview-manager.png) |
+
 ## 🐷 演示图
 
 ### 系统功能

build/vite/index.ts

@@ -2,8 +2,7 @@ import { resolve } from 'path'
 import Vue from '@vitejs/plugin-vue'
 import VueJsx from '@vitejs/plugin-vue-jsx'
 import progress from 'vite-plugin-progress'
-import EslintPlugin from 'vite-plugin-eslint'
-import PurgeIcons from 'vite-plugin-purge-icons'
+import EslintPlugin from 'vite-plugin-eslint2'
 import { ViteEjsPlugin } from 'vite-plugin-ejs'
 // @ts-ignore
 import ElementPlus from 'unplugin-element-plus/vite'
@@ -29,7 +28,6 @@ export function createVitePlugins() {
     VueJsx(),
     UnoCSS(),
     progress(),
-    PurgeIcons(),
     ElementPlus({}),
     AutoImport({
       include: [
@@ -64,7 +62,7 @@ export function createVitePlugins() {
       dts: 'src/types/auto-components.d.ts',
       // 自定义组件的解析器
       resolvers: [ElementPlusResolver()],
-      globs: ["src/components/**/**.{vue, md}", '!src/components/DiyEditor/components/mobile/**']
+      globs: ['src/components/**/**.{vue, md}', '!src/components/DiyEditor/components/mobile/**']
     }),
     EslintPlugin({
       cache: false,
@@ -77,7 +75,7 @@ export function createVitePlugins() {
     }),
     createSvgIconsPlugin({
       iconDirs: [pathResolve('src/assets/svgs')],
-      symbolId: 'icon-[dir]-[name]',
+      symbolId: 'icon-[dir]-[name]'
     }),
     viteCompression({
       verbose: true, // 是否在控制台输出压缩结果

build/vite/optimize.ts

@@ -2,22 +2,18 @@ const include = [
   'qs',
   'url',
   'vue',
-  'sass',
   'mitt',
   'axios',
   'pinia',
   'dayjs',
   'qrcode',
-  'unocss',
   'vue-router',
   'vue-types',
-  'vue-i18n',
   'crypto-js',
   'cropperjs',
   'lodash-es',
   'nprogress',
   'web-storage-cache',
-  '@iconify/iconify',
   '@vueuse/core',
   '@zxcvbn-ts/core',
   'echarts/core',
@@ -91,18 +87,9 @@ const include = [
   'element-plus/es/components/dropdown-menu/style/css',
   'element-plus/es/components/dropdown-item/style/css',
   'element-plus/es/components/skeleton/style/css',
-  'element-plus/es/components/skeleton/style/css',
-  'element-plus/es/components/backtop/style/css',
-  'element-plus/es/components/menu/style/css',
-  'element-plus/es/components/sub-menu/style/css',
-  'element-plus/es/components/menu-item/style/css',
-  'element-plus/es/components/dropdown/style/css',
+  'element-plus/es/components/skeleton-item/style/css',
   'element-plus/es/components/tree/style/css',
-  'element-plus/es/components/dropdown-menu/style/css',
-  'element-plus/es/components/dropdown-item/style/css',
   'element-plus/es/components/badge/style/css',
-  'element-plus/es/components/breadcrumb/style/css',
-  'element-plus/es/components/breadcrumb-item/style/css',
   'element-plus/es/components/image/style/css',
   'element-plus/es/components/collapse-transition/style/css',
   'element-plus/es/components/timeline/style/css',
@@ -119,6 +106,6 @@ const include = [
   'element-plus/es/components/progress/style/css'
 ]
 
-const exclude = ['@iconify/json']
+const exclude: string[] = []
 
 export { include, exclude }

eslint.config.mjs

@@ -0,0 +1,115 @@
+import pluginVue from 'eslint-plugin-vue'
+import tseslint from 'typescript-eslint'
+import unocss from '@unocss/eslint-config/flat'
+import autoImportGlobals from './.eslintrc-auto-import.json' with { type: 'json' }
+
+export default tseslint.config(
+  // Global ignores (replaces .eslintignore)
+  {
+    ignores: [
+      'build/',
+      'config/',
+      'dist/',
+      'dist*/',
+      '*.js',
+      '*.mjs',
+      '!eslint.config.mjs',
+      'test/unit/coverage/',
+      'node_modules/',
+      'src/main.ts',
+      'src/types/auto-components.d.ts'
+    ]
+  },
+
+  // Base TypeScript config
+  ...tseslint.configs.recommended,
+
+  // Vue recommended config
+  ...pluginVue.configs['flat/recommended'],
+
+  // UnoCSS config
+  unocss,
+
+  // Vue files use vue-eslint-parser with TypeScript parser
+  {
+    files: ['**/*.vue'],
+    languageOptions: {
+      parserOptions: {
+        parser: tseslint.parser
+      }
+    }
+  },
+
+  // Main rules config
+  {
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      globals: {
+        ...autoImportGlobals.globals
+      },
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    rules: {
+      // Vue rules
+      'vue/no-reserved-component-names': 'off',
+      'vue/custom-event-name-casing': 'off',
+      'vue/attributes-order': 'off',
+      'vue/one-component-per-file': 'off',
+      'vue/html-closing-bracket-newline': 'off',
+      'vue/max-attributes-per-line': 'off',
+      'vue/multiline-html-element-content-newline': 'off',
+      'vue/singleline-html-element-content-newline': 'off',
+      'vue/attribute-hyphenation': 'off',
+      'vue/require-default-prop': 'off',
+      'vue/require-explicit-emits': 'off',
+      'vue/require-toggle-inside-transition': 'off',
+      'vue/html-self-closing': [
+        'error',
+        {
+          html: {
+            void: 'always',
+            normal: 'never',
+            component: 'always'
+          },
+          svg: 'always',
+          math: 'always'
+        }
+      ],
+      'vue/multi-word-component-names': 'off',
+      'vue/no-v-html': 'off',
+
+      // TypeScript rules
+      '@typescript-eslint/ban-ts-comment': 'off',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-empty-function': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unused-expressions': 'off',
+      '@typescript-eslint/no-unsafe-function-type': 'off',
+      '@typescript-eslint/no-wrapper-object-types': 'off',
+      '@typescript-eslint/no-this-alias': 'off',
+      '@typescript-eslint/no-empty-object-type': 'off',
+      'vue/no-ref-as-operand': 'off',
+      'vue/no-mutating-props': 'off',
+      'vue/no-side-effects-in-computed-properties': 'off',
+      'no-use-before-define': 'off',
+      '@typescript-eslint/no-use-before-define': 'off',
+      'no-unused-vars': 'off',
+      'space-before-function-paren': 'off',
+
+      // UnoCSS rules - 芋艿：禁用 unocss 顺序提示
+      '@unocss/order': 'off',
+      '@unocss/order-attributify': 'off',
+      'unocss/order': 'off',
+      'unocss/order-attributify': 'off'
+    }
+  }
+)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "yudao-ui-admin-vue3",
-  "version": "2026.01-snapshot",
+  "version": "2026.05-snapshot",
   "description": "基于vue3、vite4、element-plus、typesScript",
   "author": "xingyu",
   "private": false,
@@ -8,139 +8,137 @@
     "i": "pnpm install",
     "dev": "vite --mode env.local",
     "dev-server": "vite --mode dev",
-    "ts:check": "vue-tsc --noEmit",
-    "build:local": "node --max_old_space_size=4096 ./node_modules/vite/bin/vite.js build",
-    "build:dev": "node --max_old_space_size=4096 ./node_modules/vite/bin/vite.js build --mode dev",
-    "build:test": "node --max_old_space_size=4096 ./node_modules/vite/bin/vite.js build --mode test",
-    "build:stage": "node --max_old_space_size=4096 ./node_modules/vite/bin/vite.js build --mode stage",
-    "build:prod": "node --max_old_space_size=4096 ./node_modules/vite/bin/vite.js build --mode prod",
+    "ts:check": "node --max_old_space_size=8192 ./node_modules/vue-tsc/bin/vue-tsc.js --noEmit",
+    "build:local": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode env.local",
+    "build:dev": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode dev",
+    "build:test": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode test",
+    "build:stage": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode stage",
+    "build:prod": "node --max_old_space_size=8192 ./node_modules/vite/bin/vite.js build --mode prod",
     "serve:dev": "vite preview --mode dev",
     "serve:prod": "vite preview --mode prod",
     "preview": "pnpm build:local && vite preview",
     "clean": "npx rimraf node_modules",
     "clean:cache": "npx rimraf node_modules/.cache",
-    "lint:eslint": "eslint --fix --ext .js,.ts,.vue ./src",
+    "lint:eslint": "eslint --fix ./src",
     "lint:format": "prettier --write --loglevel warn \"src/**/*.{js,ts,json,tsx,css,less,scss,vue,html,md}\"",
     "lint:style": "stylelint --fix \"./src/**/*.{vue,less,postcss,css,scss}\" --cache --cache-location node_modules/.cache/stylelint/",
     "lint:lint-staged": "lint-staged -c "
   },
   "dependencies": {
     "@element-plus/icons-vue": "2.3.2",
-    "@form-create/designer": "^3.2.6",
-    "@form-create/element-ui": "^3.2.11",
-    "@iconify/iconify": "^3.1.1",
+    "@form-create/designer": "^3.4.0",
+    "@form-create/element-ui": "^3.2.38",
+    "@iconify/vue": "^5.0.1",
     "@microsoft/fetch-event-source": "^2.0.1",
     "@videojs-player/vue": "^1.0.0",
-    "@vueuse/core": "^10.9.0",
-    "@wangeditor-next/editor": "^5.6.46",
+    "@vueuse/core": "^14.3.0",
+    "@wangeditor-next/editor": "^5.7.0",
     "@wangeditor-next/editor-for-vue": "^5.1.14",
-    "@wangeditor-next/plugin-mention": "^1.0.16",
+    "@wangeditor-next/plugin-mention": "^2.0.0",
     "@zxcvbn-ts/core": "^3.0.4",
     "animate.css": "^4.1.1",
-    "axios": "1.9.0",
+    "axios": "1.16.0",
     "benz-amr-recorder": "^1.1.5",
-    "bpmn-js-token-simulation": "^0.36.0",
+    "bpmn-js-token-simulation": "^0.39.3",
     "camunda-bpmn-moddle": "^7.0.1",
-    "cropperjs": "^1.6.1",
+    "cropperjs": "^2.1.1",
     "crypto-js": "^4.2.0",
-    "dayjs": "^1.11.10",
-    "diagram-js": "^12.8.0",
-    "driver.js": "^1.3.1",
-    "echarts": "^5.5.0",
+    "dayjs": "^1.11.20",
+    "dhtmlx-gantt": "^9.1.1",
+    "diagram-js": "^15.14.0",
+    "driver.js": "^1.4.0",
+    "echarts": "^6.0.0",
     "echarts-wordcloud": "^2.1.0",
-    "element-plus": "2.11.1",
+    "element-plus": "2.13.7",
     "fast-xml-parser": "^4.3.2",
-    "highlight.js": "^11.9.0",
-    "jsencrypt": "^3.3.2",
-    "jsoneditor": "^10.1.3",
-    "lodash-es": "^4.17.21",
-    "markdown-it": "^14.1.0",
-    "markmap-common": "^0.16.0",
-    "markmap-lib": "^0.16.1",
-    "markmap-toolbar": "^0.17.0",
-    "markmap-view": "^0.16.0",
-    "min-dash": "^4.1.1",
+    "highlight.js": "^11.11.1",
+    "jsbarcode": "^3.12.3",
+    "jsencrypt": "^3.5.4",
+    "jsoneditor": "^10.4.3",
+    "livekit-client": "^2.18.9",
+    "lodash-es": "^4.18.1",
+    "markdown-it": "^14.1.1",
+    "markmap-common": "^0.18.9",
+    "markmap-lib": "^0.18.12",
+    "markmap-toolbar": "^0.18.12",
+    "markmap-view": "^0.18.12",
+    "min-dash": "^5.0.0",
     "mitt": "^3.0.1",
     "nprogress": "^0.2.0",
-    "pinia": "^2.1.7",
-    "pinia-plugin-persistedstate": "^3.2.1",
-    "qrcode": "^1.5.3",
-    "qs": "^6.12.0",
-    "snabbdom": "^3.6.2",
-    "sortablejs": "^1.15.3",
+    "pinia": "^3.0.4",
+    "pinia-plugin-persistedstate": "^4.7.1",
+    "qrcode": "^1.5.4",
+    "qs": "^6.15.1",
+    "snabbdom": "^3.6.3",
+    "sortablejs": "^1.15.7",
     "steady-xml": "^0.1.0",
-    "url": "^0.11.3",
-    "video.js": "^7.21.5",
-    "vue": "3.5.12",
-    "vue-dompurify-html": "^4.1.4",
-    "vue-i18n": "9.10.2",
-    "vue-router": "4.4.5",
-    "vue-types": "^5.1.1",
+    "tyme4ts": "^1.4.6",
+    "url": "^0.11.4",
+    "video.js": "^8.23.8",
+    "vue": "3.5.34",
+    "vue-dompurify-html": "^5.3.0",
+    "vue-i18n": "11.4.0",
+    "vue-router": "5.0.6",
+    "vue-types": "^6.0.0",
     "vue3-print-nb": "^0.1.4",
-    "vue3-signature": "^0.2.4",
+    "vue3-signature": "^0.4.4",
     "vuedraggable": "^4.1.0",
     "web-storage-cache": "^1.1.1",
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.0.1",
-    "@commitlint/config-conventional": "^19.0.0",
-    "@iconify/json": "^2.2.187",
-    "@intlify/unplugin-vue-i18n": "^2.0.0",
-    "@purge-icons/generated": "^0.9.0",
-    "@types/jsoneditor": "^9.9.5",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
+    "@iconify/json": "^2.2.470",
+    "@intlify/unplugin-vue-i18n": "^11.1.2",
+    "@types/jsoneditor": "^9.9.6",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^20.11.21",
+    "@types/node": "^25.6.0",
     "@types/nprogress": "^0.2.3",
-    "@types/qrcode": "^1.5.5",
-    "@types/qs": "^6.9.12",
-    "@typescript-eslint/eslint-plugin": "^7.1.0",
-    "@typescript-eslint/parser": "^7.1.0",
-    "@unocss/eslint-config": "^0.57.4",
-    "@unocss/eslint-plugin": "66.1.0-beta.5",
-    "@unocss/transformer-variant-group": "^0.58.5",
-    "@vitejs/plugin-legacy": "^5.3.1",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "@vitejs/plugin-vue-jsx": "^3.1.0",
-    "autoprefixer": "^10.4.17",
-    "bpmn-js": "^17.9.2",
-    "bpmn-js-properties-panel": "5.23.0",
-    "consola": "^3.2.3",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-define-config": "^2.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-vue": "^9.22.0",
-    "lint-staged": "^15.2.2",
-    "postcss": "^8.4.35",
-    "postcss-html": "^1.6.0",
+    "@types/qrcode": "^1.5.6",
+    "@types/qs": "^6.15.0",
+    "@unocss/eslint-config": "^66.6.8",
+    "@unocss/eslint-plugin": "66.6.8",
+    "@unocss/transformer-variant-group": "^66.6.8",
+    "@vitejs/plugin-legacy": "^8.0.1",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vitejs/plugin-vue-jsx": "^5.1.5",
+    "autoprefixer": "^10.5.0",
+    "bpmn-js": "^18.16.1",
+    "bpmn-js-properties-panel": "5.54.0",
+    "consola": "^3.4.2",
+    "eslint": "^10.3.0",
+    "eslint-plugin-vue": "^10.9.1",
+    "lint-staged": "^16.4.0",
+    "postcss": "^8.5.14",
+    "postcss-html": "^1.8.1",
     "postcss-scss": "^4.0.9",
-    "prettier": "^3.2.5",
-    "prettier-eslint": "^16.3.0",
-    "rimraf": "^5.0.5",
-    "rollup": "^4.12.0",
-    "sass": "^1.69.5",
-    "stylelint": "^16.2.1",
+    "prettier": "^3.8.3",
+    "prettier-eslint": "^16.4.2",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.60.3",
+    "sass": "^1.99.0",
+    "stylelint": "^17.11.0",
     "stylelint-config-html": "^1.1.0",
-    "stylelint-config-recommended": "^14.0.0",
-    "stylelint-config-standard": "^36.0.0",
-    "stylelint-order": "^6.0.4",
-    "terser": "^5.28.1",
-    "typescript": "5.3.3",
-    "unocss": "^0.58.5",
-    "unplugin-auto-import": "^0.16.7",
-    "unplugin-element-plus": "^0.8.0",
-    "unplugin-vue-components": "^0.25.2",
-    "vite": "5.1.4",
+    "stylelint-config-recommended": "^18.0.0",
+    "stylelint-config-standard": "^40.0.0",
+    "stylelint-order": "^8.1.1",
+    "terser": "^5.46.2",
+    "typescript": "6.0.3",
+    "typescript-eslint": "^8.59.2",
+    "unocss": "^66.6.8",
+    "unplugin-auto-import": "^21.0.0",
+    "unplugin-element-plus": "^0.11.2",
+    "unplugin-vue-components": "^32.0.0",
+    "vite": "8.0.10",
     "vite-plugin-compression": "^0.5.1",
     "vite-plugin-ejs": "^1.7.0",
-    "vite-plugin-eslint": "^1.8.1",
+    "vite-plugin-eslint2": "^5.1.0",
     "vite-plugin-progress": "^0.0.7",
-    "vite-plugin-purge-icons": "^0.10.0",
-    "vite-plugin-svg-icons-ng": "^1.3.1",
-    "vite-plugin-top-level-await": "^1.4.4",
-    "vue-eslint-parser": "^9.3.2",
-    "vue-tsc": "^1.8.27"
+    "vite-plugin-svg-icons-ng": "^1.9.0",
+    "vite-plugin-top-level-await": "^1.6.0",
+    "vue-eslint-parser": "^10.4.0",
+    "vue-tsc": "^3.2.8"
   },
   "license": "MIT",
   "repository": {
@@ -153,7 +151,7 @@
   "homepage": "https://gitee.com/yudaocode/yudao-ui-admin-vue3",
   "web-types": "./web-types.json",
   "engines": {
-    "node": ">= 16.0.0",
+    "node": ">= 20.19.0",
     "pnpm": ">=8.6.0"
   }
 }

src/api/im/channel/material/index.ts

@@ -0,0 +1,18 @@
+import request from '@/config/axios'
+
+// 用户端能看到的频道素材详情
+export interface ImChannelMaterialRespVO {
+  id: number
+  channelId: number
+  type: number
+  title: string
+  coverUrl?: string
+  summary?: string
+  content?: string
+  url?: string
+}
+
+// 获取频道素材详情；用于客户端点击图文卡片渲染详情页
+export const getChannelMaterial = (id: number) => {
+  return request.get<ImChannelMaterialRespVO>({ url: '/im/channel/material/get', params: { id } })
+}

src/api/im/face/pack/index.ts

@@ -0,0 +1,23 @@
+import request from '@/config/axios'
+
+// 用户端表情包项（精简版）
+export interface ImFacePackUserItemVO {
+  id: number
+  url: string
+  name?: string
+  width: number
+  height: number
+}
+
+// 用户端表情包 + 嵌套 items
+export interface ImFacePackUserVO {
+  id: number
+  name: string
+  icon?: string
+  items: ImFacePackUserItemVO[]
+}
+
+// 拉取所有启用的系统表情包（含表情列表）
+export const getFacePackList = () => {
+  return request.get<ImFacePackUserVO[]>({ url: '/im/face-pack/list' })
+}

src/api/im/face/useritem/index.ts

@@ -0,0 +1,33 @@
+import request from '@/config/axios'
+
+// 个人表情
+export interface ImFaceUserItemVO {
+  id: number
+  url: string
+  name?: string
+  width: number
+  height: number
+}
+
+// 添加个人表情请求
+export interface ImFaceUserItemSaveReqVO {
+  url: string
+  name?: string
+  width: number
+  height: number
+}
+
+// 获取我的个人表情列表
+export const getFaceUserItemList = () => {
+  return request.get<ImFaceUserItemVO[]>({ url: '/im/face-user-item/list' })
+}
+
+// 添加个人表情
+export const createFaceUserItem = (data: ImFaceUserItemSaveReqVO) => {
+  return request.post<number>({ url: '/im/face-user-item/create', data })
+}
+
+// 删除个人表情
+export const deleteFaceUserItem = (id: number) => {
+  return request.delete({ url: '/im/face-user-item/delete', params: { id } })
+}

src/api/im/friend/index.ts

@@ -0,0 +1,62 @@
+import request from '@/config/axios'
+
+// IM 好友 Response VO
+export interface ImFriendRespVO {
+  id: number // 关系记录编号
+  friendUserId: number // 好友的用户编号
+  silent?: boolean // 是否免打扰
+  displayName?: string // 好友展示备注（仅自己可见）
+  displayNamePinyin?: string // 备注的拼音（小写无空格，前端按首字母分桶 / 拼音搜索）
+  addSource?: number // 添加来源；参见 ImFriendAddSourceEnum
+  pinned?: boolean // 是否置顶联系人
+  blocked?: boolean // 是否拉黑
+  status?: number // 好友状态（0=正常，1=已删除）
+  addTime?: string // 添加好友时间
+  deleteTime?: string // 删除好友时间
+  // 聚合字段（自 AdminUser）
+  nickname?: string // 好友昵称
+  nicknamePinyin?: string // 昵称的拼音（小写无空格，前端按首字母分桶 / 拼音搜索）
+  avatar?: string // 好友头像
+}
+
+// IM 好友更新 Request VO
+export interface ImFriendUpdateReqVO {
+  friendUserId: number // 好友的用户编号
+  silent?: boolean // 是否免打扰
+  displayName?: string // 好友展示备注
+  pinned?: boolean // 是否置顶联系人
+}
+
+// 获得当前登录用户的好友列表
+export const getMyFriendList = () => {
+  return request.get<ImFriendRespVO[]>({ url: '/im/friend/list' })
+}
+
+// 获得好友详情
+export const getFriend = (friendUserId: number | string) => {
+  return request.get<ImFriendRespVO>({ url: '/im/friend/get', params: { friendUserId } })
+}
+
+// 删除好友（单向软删除）
+export const deleteFriend = (friendUserId: number | string, clear: boolean) => {
+  return request.delete<boolean>({
+    url: '/im/friend/delete',
+    params: { friendUserId, clear }
+  })
+}
+
+// 更新好友信息（备注 / 免打扰 / 联系人置顶）
+export const updateFriend = (data: ImFriendUpdateReqVO) => {
+  return request.put<boolean>({ url: '/im/friend/update', data })
+}
+
+// 拉黑好友（必须先是好友；单边屏蔽对方私聊消息）
+export const blockFriend = (friendUserId: number | string) => {
+  return request.put<boolean>({ url: '/im/friend/block', params: { friendUserId } })
+}
+
+// 移出黑名单
+export const unblockFriend = (friendUserId: number | string) => {
+  return request.put<boolean>({ url: '/im/friend/unblock', params: { friendUserId } })
+}
+

src/api/im/friend/request/index.ts

@@ -0,0 +1,65 @@
+import request from '@/config/axios'
+
+// IM 好友申请 Response VO
+export interface ImFriendRequestRespVO {
+  id: number // 申请编号
+  fromUserId: number // 发起方用户编号
+  toUserId: number // 接收方用户编号
+  handleResult: number // 处理结果；0=未处理；1=同意；2=拒绝
+  applyContent?: string // 申请理由
+  handleContent?: string // 处理理由（接收方拒绝时可选填）
+  addSource?: number // 添加来源；参见 ImFriendAddSourceEnum
+  handleTime?: string // 处理时间
+  createTime: string // 申请创建时间
+  // 聚合字段（自 AdminUser）
+  fromNickname?: string // 发起方昵称
+  fromAvatar?: string // 发起方头像
+  toNickname?: string // 接收方昵称
+  toAvatar?: string // 接收方头像
+}
+
+// IM 好友申请发起 Request VO
+export interface ImFriendRequestApplyReqVO {
+  toUserId: number // 接收方用户编号
+  applyContent?: string // 申请理由
+  displayName?: string // 对接收方的备注（仅自己可见）
+  addSource?: number // 添加来源
+}
+
+// 发起好友申请
+export const applyFriendRequest = (data: ImFriendRequestApplyReqVO) => {
+  return request.post<number | null>({ url: '/im/friend-request/apply', data })
+}
+
+// 同意好友申请
+export const agreeFriendRequest = (id: number | string) => {
+  return request.put<boolean>({ url: '/im/friend-request/agree', params: { id } })
+}
+
+// 拒绝好友申请
+export const refuseFriendRequest = (id: number | string, handleContent?: string) => {
+  return request.put<boolean>({
+    url: '/im/friend-request/refuse',
+    params: { id, handleContent }
+  })
+}
+
+// 查询「我相关」的好友申请列表（游标分页：传 maxId 加载更多）
+export const getMyFriendRequestList = (limit: number, maxId?: number) => {
+  const params: Record<string, number> = { limit }
+  if (maxId != null) {
+    params.maxId = maxId
+  }
+  return request.get<ImFriendRequestRespVO[]>({
+    url: '/im/friend-request/list',
+    params
+  })
+}
+
+// 按 id 单查「我相关」的申请记录（带越权过滤；WebSocket 通知到达后用）
+export const getMyFriendRequest = (id: number) => {
+  return request.get<ImFriendRequestRespVO | null>({
+    url: '/im/friend-request/get',
+    params: { id }
+  })
+}

src/api/im/group/index.ts

@@ -0,0 +1,137 @@
+import request from '@/config/axios'
+import type { ImGroupMessageRespVO } from '@/api/im/message/group'
+
+// 群 Response VO
+export interface ImGroupRespVO {
+  id: number // 编号
+  name: string // 群名称
+  ownerUserId: number // 群主用户编号
+  avatar?: string // 群头像
+  notice?: string // 群公告
+  banned?: boolean // 是否封禁
+  mutedAll?: boolean // 是否全群禁言
+  joinApproval?: boolean // 进群是否需群主 / 管理员审批
+  bannedTime?: string // 封禁时间
+  status: number // 群状态（0=正常，1=已解散）
+  dissolvedTime?: string // 解散时间
+  createTime?: string // 创建时间
+  pinnedMessages?: ImGroupMessageRespVO[] // 群置顶消息列表（后端关联回填，仅当登录用户是群成员时非空）
+}
+
+// 群消息置顶 / 取消置顶 Request VO
+export interface ImGroupMessagePinReqVO {
+  id: number // 群编号
+  messageId: number // 消息编号
+}
+
+// 群创建 Request VO
+export interface ImGroupCreateReqVO {
+  name: string // 群名称
+  memberUserIds?: number[] // 初始成员用户编号列表（建群同时邀请的好友，不含创建者自己）
+  joinApproval?: boolean // 进群是否需审批；不传默认 false 自由进群
+}
+
+// 群更新 Request VO
+export interface ImGroupUpdateReqVO {
+  id: number // 群编号
+  name?: string // 群名称
+  avatar?: string // 群头像
+  notice?: string // 群公告
+  joinApproval?: boolean // 进群是否需审批
+}
+
+// 添加 / 撤销群管理员 Request VO
+export interface ImGroupAdminReqVO {
+  id: number // 群编号
+  userIds: number[] // 目标用户编号列表
+}
+
+// 群主转让 Request VO
+export interface ImGroupTransferOwnerReqVO {
+  id: number // 群编号
+  newOwnerUserId: number // 新群主用户编号
+}
+
+// 全群禁言 / 取消 Request VO
+export interface ImGroupMuteAllReqVO {
+  id: number // 群编号
+  mutedAll: boolean // 是否全群禁言
+}
+
+// 成员禁言 Request VO
+export interface ImGroupMuteMemberReqVO {
+  id: number // 群编号
+  userId: number // 被禁言的用户编号
+  mutedSeconds: number // 禁言时长（秒），0 表示永久禁言
+}
+
+// 取消成员禁言 Request VO
+export interface ImGroupCancelMuteMemberReqVO {
+  id: number // 群编号
+  userId: number // 被取消禁言的用户编号
+}
+
+// 获得当前登录用户的群列表
+export const getMyGroupList = () => {
+  return request.get<ImGroupRespVO[]>({ url: '/im/group/list' })
+}
+
+// 获得群详情
+export const getGroup = (id: number | string) => {
+  return request.get<ImGroupRespVO>({ url: '/im/group/get', params: { id } })
+}
+
+// 创建群
+export const createGroup = (data: ImGroupCreateReqVO) => {
+  return request.post<ImGroupRespVO>({ url: '/im/group/create', data })
+}
+
+// 更新群
+export const updateGroup = (data: ImGroupUpdateReqVO) => {
+  return request.put<ImGroupRespVO>({ url: '/im/group/update', data })
+}
+
+// 解散群
+export const dissolveGroup = (id: number | string) => {
+  return request.delete<boolean>({ url: '/im/group/dissolve', params: { id } })
+}
+
+// 添加群管理员（仅群主可调）
+export const addGroupAdmin = (data: ImGroupAdminReqVO) => {
+  return request.put<boolean>({ url: '/im/group/add-admin', data })
+}
+
+// 撤销群管理员（仅群主可调）
+export const removeGroupAdmin = (data: ImGroupAdminReqVO) => {
+  return request.put<boolean>({ url: '/im/group/remove-admin', data })
+}
+
+// 转让群主（仅老群主可调；旧群主转让后降为普通成员）
+export const transferGroupOwner = (data: ImGroupTransferOwnerReqVO) => {
+  return request.put<boolean>({ url: '/im/group/transfer-owner', data })
+}
+
+// 置顶群消息（仅群主 / 管理员可调）
+export const pinGroupMessage = (data: ImGroupMessagePinReqVO) => {
+  return request.put<boolean>({ url: '/im/group/pin-message', data })
+}
+
+// 取消置顶群消息（仅群主 / 管理员可调）
+export const unpinGroupMessage = (data: ImGroupMessagePinReqVO) => {
+  return request.put<boolean>({ url: '/im/group/unpin-message', data })
+}
+
+// 全群禁言 / 取消（仅群主 / 管理员可调）
+export const muteAll = (data: ImGroupMuteAllReqVO) => {
+  return request.put<boolean>({ url: '/im/group/mute-all', data })
+}
+
+// 禁言成员
+export const muteMember = (data: ImGroupMuteMemberReqVO) => {
+  return request.put<boolean>({ url: '/im/group/mute-member', data })
+}
+
+// 取消成员禁言
+export const cancelMuteMember = (data: ImGroupCancelMuteMemberReqVO) => {
+  return request.put<boolean>({ url: '/im/group/cancel-mute-member', data })
+}

src/api/im/group/member/index.ts

@@ -0,0 +1,76 @@
+import request from '@/config/axios'
+
+// 群成员 Response VO
+export interface ImGroupMemberRespVO {
+  id: number // 编号
+  groupId: number // 群编号
+  userId: number // 用户编号
+  displayUserName?: string // 组内显示名（群主设置的备注）
+  groupRemark?: string // 群备注（当前用户对群的备注）
+  silent?: boolean // 是否免打扰
+  status?: number // 成员状态（0=在群，1=退群）
+  role?: number // 成员角色，参见 ImGroupMemberRole 枚举
+  joinTime?: string // 入群时间
+  quitTime?: string // 退群时间
+  muteEndTime?: string // 禁言到期时间
+  createTime?: string // 创建时间
+  // 聚合字段（自 AdminUser）
+  nickname?: string // 用户昵称
+  avatar?: string // 用户头像
+}
+
+// 群成员邀请 Request VO
+export interface ImGroupMemberInviteReqVO {
+  groupId: number // 群编号
+  memberUserIds: number[] // 被邀请的用户编号列表
+}
+
+// 群成员移除 Request VO
+export interface ImGroupMemberRemoveReqVO {
+  groupId: number // 群编号
+  memberUserIds: number[] // 被移除的用户编号列表
+}
+
+// 群成员更新 Request VO
+export interface ImGroupMemberUpdateReqVO {
+  groupId: number // 群编号
+  displayUserName?: string // 群内昵称
+  groupRemark?: string // 群备注
+  silent?: boolean // 是否免打扰
+}
+
+// 邀请用户加入群
+export const inviteGroupMember = (data: ImGroupMemberInviteReqVO) => {
+  return request.post<boolean>({ url: '/im/group/invite', data })
+}
+
+// 退出群
+export const quitGroup = (groupId: number | string) => {
+  return request.delete<boolean>({ url: '/im/group/quit', params: { groupId } })
+}
+
+// 移除群成员
+export const removeGroupMember = (data: ImGroupMemberRemoveReqVO) => {
+  return request.delete<boolean>({ url: '/im/group/kicking', data })
+}
+
+// 获得群成员详情
+export const getGroupMember = (groupId: number, userId: number) => {
+  return request.get<ImGroupMemberRespVO>({
+    url: '/im/group-member/get',
+    params: { groupId, userId }
+  })
+}
+
+// 获得指定群的成员列表（聚合 AdminUser 昵称 / 头像）
+export const getGroupMemberList = (groupId: number | string) => {
+  return request.get<ImGroupMemberRespVO[]>({
+    url: '/im/group-member/list',
+    params: { groupId }
+  })
+}
+
+// 更新群成员
+export const updateGroupMember = (data: ImGroupMemberUpdateReqVO) => {
+  return request.put<boolean>({ url: '/im/group-member/update', data })
+}

src/api/im/group/request/index.ts

@@ -0,0 +1,71 @@
+import request from '@/config/axios'
+
+// IM 加群申请 Response VO
+export interface ImGroupRequestRespVO {
+  id: number // 申请编号
+  groupId: number // 群编号
+  userId: number // 申请人 / 被邀请人用户编号
+  inviterUserId?: number // 邀请人；NULL 表示用户主动申请
+  handleResult: number // 处理结果；0=未处理；1=同意；2=拒绝
+  applyContent?: string // 申请理由
+  handleContent?: string // 处理理由（拒绝时可选填）
+  handleUserId?: number // 处理人用户编号
+  addSource?: number // 加入来源；参见 ImGroupAddSourceEnum
+  handleTime?: string // 处理时间
+  createTime: string // 申请创建时间
+  // 聚合字段
+  userNickname?: string // 申请人 / 被邀请人昵称
+  userAvatar?: string // 申请人 / 被邀请人头像
+  inviterNickname?: string // 邀请人昵称
+  inviterAvatar?: string // 邀请人头像
+  groupName?: string // 群名称
+  groupAvatar?: string // 群头像
+}
+
+// IM 加群申请发起 Request VO
+export interface ImGroupRequestApplyReqVO {
+  groupId: number // 群编号
+  applyContent?: string // 申请理由
+  addSource?: number // 加入来源
+}
+
+// 申请加群
+export const applyJoinGroup = (data: ImGroupRequestApplyReqVO) => {
+  return request.post<number | null>({ url: '/im/group-request/apply', data })
+}
+
+// 同意加群申请（群主或管理员）
+export const agreeGroupRequest = (id: number | string) => {
+  return request.put<boolean>({ url: '/im/group-request/agree', params: { id } })
+}
+
+// 拒绝加群申请（群主或管理员）
+export const refuseGroupRequest = (id: number | string, handleContent?: string) => {
+  return request.put<boolean>({
+    url: '/im/group-request/refuse',
+    params: { id, handleContent }
+  })
+}
+
+// 查询「我管理的所有群」下的未处理加群申请列表（不分页）；前端 store 据此派生横幅红点 + Drawer 列表
+export const getUnhandledRequestList = () => {
+  return request.get<ImGroupRequestRespVO[]>({
+    url: '/im/group-request/unhandled-list'
+  })
+}
+
+// 查询指定群下的全部加群申请（含已处理）；仅群主 / 管理员可查
+export const getGroupRequestListByGroupId = (groupId: number) => {
+  return request.get<ImGroupRequestRespVO[]>({
+    url: '/im/group-request/list-by-group',
+    params: { groupId }
+  })
+}
+
+// 按 id 单查申请记录（带越权过滤；WebSocket 通知到达后用）
+export const getMyGroupRequest = (id: number) => {
+  return request.get<ImGroupRequestRespVO | null>({
+    url: '/im/group-request/get',
+    params: { id }
+  })
+}

src/api/im/manager/channel/index.ts

@@ -0,0 +1,41 @@
+import request from '@/config/axios'
+
+export interface ImManagerChannelVO {
+  id: number
+  code: string
+  name: string
+  avatar?: string
+  sort: number
+  status: number
+  createTime?: Date
+}
+
+// 获得频道分页
+export const getManagerChannelPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/channel/page', params })
+}
+
+// 获得频道详情
+export const getManagerChannel = (id: number) => {
+  return request.get({ url: '/im/manager/channel/get', params: { id } })
+}
+
+// 新增频道
+export const createManagerChannel = (data: ImManagerChannelVO) => {
+  return request.post({ url: '/im/manager/channel/create', data })
+}
+
+// 修改频道
+export const updateManagerChannel = (data: ImManagerChannelVO) => {
+  return request.put({ url: '/im/manager/channel/update', data })
+}
+
+// 删除频道
+export const deleteManagerChannel = (id: number) => {
+  return request.delete({ url: '/im/manager/channel/delete', params: { id } })
+}
+
+// 获得启用的频道精简列表（表单选择用）
+export const getSimpleChannelList = () => {
+  return request.get<ImManagerChannelVO[]>({ url: '/im/manager/channel/simple-list' })
+}

src/api/im/manager/channel/material/index.ts

@@ -0,0 +1,47 @@
+import request from '@/config/axios'
+
+export interface ImManagerChannelMaterialVO {
+  id: number
+  channelId: number
+  channelName?: string
+  type: number
+  title: string
+  coverUrl?: string
+  summary?: string
+  content?: string
+  url?: string
+  createTime?: Date
+}
+
+// 获得素材分页
+export const getManagerChannelMaterialPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/channel-material/page', params })
+}
+
+// 获得指定频道下的素材精简列表
+export const getSimpleManagerChannelMaterialList = (channelId: number) => {
+  return request.get({
+    url: '/im/manager/channel-material/simple-list',
+    params: { channelId }
+  })
+}
+
+// 获得素材详情
+export const getManagerChannelMaterial = (id: number) => {
+  return request.get({ url: '/im/manager/channel-material/get', params: { id } })
+}
+
+// 新增素材
+export const createManagerChannelMaterial = (data: ImManagerChannelMaterialVO) => {
+  return request.post({ url: '/im/manager/channel-material/create', data })
+}
+
+// 修改素材
+export const updateManagerChannelMaterial = (data: ImManagerChannelMaterialVO) => {
+  return request.put({ url: '/im/manager/channel-material/update', data })
+}
+
+// 删除素材
+export const deleteManagerChannelMaterial = (id: number) => {
+  return request.delete({ url: '/im/manager/channel-material/delete', params: { id } })
+}

src/api/im/manager/channel/message/index.ts

@@ -0,0 +1,34 @@
+import request from '@/config/axios'
+
+export interface ImManagerChannelMessageVO {
+  id: number
+  channelId: number
+  channelName?: string
+  materialId: number
+  materialTitle?: string
+  materialCoverUrl?: string
+  type: number
+  content?: string
+  receiverUserIds?: number[]
+  sendTime?: Date
+}
+
+export interface ImManagerChannelMessageSendReqVO {
+  materialId: number
+  receiverUserIds?: number[]
+}
+
+// 立即推送频道消息
+export const sendManagerChannelMessage = (data: ImManagerChannelMessageSendReqVO) => {
+  return request.post({ url: '/im/manager/channel-message/send', data })
+}
+
+// 删除频道消息
+export const deleteManagerChannelMessage = (id: number) => {
+  return request.delete({ url: '/im/manager/channel-message/delete', params: { id } })
+}
+
+// 获得频道消息分页
+export const getManagerChannelMessagePage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/channel-message/page', params })
+}

src/api/im/manager/face/item/index.ts

@@ -0,0 +1,46 @@
+import request from '@/config/axios'
+
+export interface ImManagerFacePackItemVO {
+  id: number
+  packId: number
+  url: string
+  name?: string
+  width: number
+  height: number
+  sort: number
+  status: number
+  createTime?: Date
+}
+
+// 获得表情分页
+export const getManagerFacePackItemPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/face-pack-item/page', params })
+}
+
+// 获得表情详情
+export const getManagerFacePackItem = (id: number) => {
+  return request.get({ url: '/im/manager/face-pack-item/get', params: { id } })
+}
+
+// 新增表情
+export const createManagerFacePackItem = (data: ImManagerFacePackItemVO) => {
+  return request.post({ url: '/im/manager/face-pack-item/create', data })
+}
+
+// 修改表情
+export const updateManagerFacePackItem = (data: ImManagerFacePackItemVO) => {
+  return request.put({ url: '/im/manager/face-pack-item/update', data })
+}
+
+// 删除表情
+export const deleteManagerFacePackItem = (id: number) => {
+  return request.delete({ url: '/im/manager/face-pack-item/delete', params: { id } })
+}
+
+// 批量删除表情
+export const deleteManagerFacePackItemList = (ids: number[]) => {
+  return request.delete({
+    url: '/im/manager/face-pack-item/delete-list',
+    params: { ids: ids.join(',') }
+  })
+}

src/api/im/manager/face/pack/index.ts

@@ -0,0 +1,43 @@
+import request from '@/config/axios'
+
+export interface ImManagerFacePackVO {
+  id: number
+  name: string
+  icon?: string
+  sort: number
+  status: number
+  createTime?: Date
+}
+
+// 获得表情包分页
+export const getManagerFacePackPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/face-pack/page', params })
+}
+
+// 获得表情包详情
+export const getManagerFacePack = (id: number) => {
+  return request.get({ url: '/im/manager/face-pack/get', params: { id } })
+}
+
+// 新增表情包
+export const createManagerFacePack = (data: ImManagerFacePackVO) => {
+  return request.post({ url: '/im/manager/face-pack/create', data })
+}
+
+// 修改表情包
+export const updateManagerFacePack = (data: ImManagerFacePackVO) => {
+  return request.put({ url: '/im/manager/face-pack/update', data })
+}
+
+// 删除表情包
+export const deleteManagerFacePack = (id: number) => {
+  return request.delete({ url: '/im/manager/face-pack/delete', params: { id } })
+}
+
+// 批量删除表情包
+export const deleteManagerFacePackList = (ids: number[]) => {
+  return request.delete({
+    url: '/im/manager/face-pack/delete-list',
+    params: { ids: ids.join(',') }
+  })
+}

src/api/im/manager/face/userItem/index.ts

@@ -0,0 +1,22 @@
+import request from '@/config/axios'
+
+export interface ImManagerFaceUserItemVO {
+  id: number
+  userId: number
+  userNickname?: string
+  url: string
+  name?: string
+  width?: number
+  height?: number
+  createTime?: Date
+}
+
+// 获得用户表情分页
+export const getManagerFaceUserItemPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/face-user-item/page', params })
+}
+
+// 删除用户表情
+export const deleteManagerFaceUserItem = (id: number) => {
+  return request.delete({ url: '/im/manager/face-user-item/delete', params: { id } })
+}

src/api/im/manager/friend/index.ts

@@ -0,0 +1,23 @@
+import request from '@/config/axios'
+
+export interface ImManagerFriendVO {
+  id: number
+  userId: number
+  userNickname?: string
+  friendUserId: number
+  friendNickname?: string
+  displayName?: string
+  addSource?: number
+  silent: boolean
+  pinned: boolean
+  blocked: boolean
+  status: number
+  addTime?: Date
+  deleteTime?: Date
+  createTime: Date
+}
+
+// 获得好友关系分页
+export const getManagerFriendPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/friend/page', params })
+}

src/api/im/manager/friend/request/index.ts

@@ -0,0 +1,21 @@
+import request from '@/config/axios'
+
+export interface ImManagerFriendRequestVO {
+  id: number
+  fromUserId: number
+  fromNickname?: string
+  toUserId: number
+  toNickname?: string
+  applyContent?: string
+  displayName?: string
+  addSource?: number
+  handleResult: number
+  handleContent?: string
+  handleTime?: Date
+  createTime: Date
+}
+
+// 获得好友申请分页
+export const getManagerFriendRequestPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/friend-request/page', params })
+}

src/api/im/manager/group/index.ts

@@ -0,0 +1,62 @@
+import request from '@/config/axios'
+
+export interface ImManagerGroupVO {
+  id: number
+  name: string
+  avatar?: string
+  notice?: string
+  ownerUserId: number
+  ownerNickname?: string
+  memberCount?: number
+  status: number
+  banned: boolean
+  mutedAll?: boolean // 是否全群禁言
+  bannedReason?: string
+  bannedTime?: Date
+  dissolvedTime?: Date
+  createTime: Date
+}
+
+export interface ImManagerGroupMemberVO {
+  userId: number
+  nickname?: string
+  avatar?: string
+  displayUserName?: string
+  groupRemark?: string
+  silent?: boolean
+  status: number
+  role?: number // 成员角色，参见 ImGroupMemberRole 枚举
+  joinTime?: Date
+  quitTime?: Date
+  muteEndTime?: Date // 禁言到期时间
+}
+
+// 获得群分页
+export const getManagerGroupPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/group/page', params })
+}
+
+// 获得群详情
+export const getManagerGroup = (id: number) => {
+  return request.get({ url: '/im/manager/group/get', params: { id } })
+}
+
+// 封禁群
+export const banManagerGroup = (data: { id: number; reason: string }) => {
+  return request.put({ url: '/im/manager/group/ban', data })
+}
+
+// 解封群
+export const unbanManagerGroup = (id: number) => {
+  return request.put({ url: '/im/manager/group/unban', params: { id } })
+}
+
+// 解散群
+export const dissolveManagerGroup = (id: number) => {
+  return request.delete({ url: '/im/manager/group/dissolve', params: { id } })
+}
+
+// 获得群成员列表（含已退群成员，由前端按需过滤）
+export const getManagerGroupMemberList = (groupId: number) => {
+  return request.get({ url: '/im/manager/group/member/list', params: { groupId } })
+}

src/api/im/manager/group/request/index.ts

@@ -0,0 +1,24 @@
+import request from '@/config/axios'
+
+export interface ImManagerGroupRequestVO {
+  id: number
+  groupId: number
+  groupName?: string
+  userId: number
+  userNickname?: string
+  inviterUserId?: number
+  inviterNickname?: string
+  applyContent?: string
+  addSource?: number
+  handleResult: number
+  handleUserId?: number
+  handleNickname?: string
+  handleContent?: string
+  handleTime?: Date
+  createTime: Date
+}
+
+// 获得加群申请分页
+export const getManagerGroupRequestPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/group-request/page', params })
+}

src/api/im/manager/message/group/index.ts

@@ -0,0 +1,29 @@
+import request from '@/config/axios'
+
+export interface ImManagerGroupMessageVO {
+  id: number
+  clientMessageId?: string
+  groupId: number
+  groupName?: string
+  senderId: number
+  senderNickname?: string
+  type: number
+  content: string
+  status: number
+  atUserIds?: number[]
+  // 与 atUserIds 同长度；后端对找不到 / 已删除的成员返回 null，UI 用 `?.[idx] || userId` 回退到 userId 渲染
+  atUserNicknames?: (string | null)[]
+  receiptStatus?: number
+  sendTime: Date
+  createTime: Date
+}
+
+// 获得群聊消息分页
+export const getManagerGroupMessagePage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/message/group/page', params })
+}
+
+// 获得群聊消息详情
+export const getManagerGroupMessage = (id: number) => {
+  return request.get({ url: '/im/manager/message/group/get', params: { id } })
+}

src/api/im/manager/message/private/index.ts

@@ -0,0 +1,25 @@
+import request from '@/config/axios'
+
+export interface ImManagerPrivateMessageVO {
+  id: number
+  clientMessageId?: string
+  senderId: number
+  senderNickname?: string
+  receiverId: number
+  receiverNickname?: string
+  type: number
+  content: string
+  status: number
+  sendTime: Date
+  createTime: Date
+}
+
+// 获得私聊消息分页
+export const getManagerPrivateMessagePage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/message/private/page', params })
+}
+
+// 获得私聊消息详情
+export const getManagerPrivateMessage = (id: number) => {
+  return request.get({ url: '/im/manager/message/private/get', params: { id } })
+}

src/api/im/manager/rtc/index.ts

@@ -0,0 +1,40 @@
+import request from '@/config/axios'
+
+export interface ImManagerRtcCallVO {
+  id: number
+  room: string
+  conversationType: number
+  mediaType: number
+  inviterUserId: number
+  inviterNickname?: string
+  groupId?: number
+  groupName?: string
+  status: number
+  endReason?: number
+  startTime: Date
+  acceptTime?: Date
+  endTime?: Date
+  createTime: Date
+}
+
+export interface ImManagerRtcParticipantVO {
+  id: number
+  callId: number
+  userId: number
+  userNickname?: string
+  role: number
+  status: number
+  inviteTime: Date
+  acceptTime?: Date
+  leaveTime?: Date
+}
+
+// 获得通话记录分页
+export const getManagerRtcCallPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/rtc/page', params })
+}
+
+// 获得通话参与者列表
+export const getManagerRtcCallParticipantList = (id: number) => {
+  return request.get({ url: '/im/manager/rtc/participant-list', params: { id } })
+}

src/api/im/manager/sensitiveword/index.ts

@@ -0,0 +1,43 @@
+import request from '@/config/axios'
+
+export interface ImManagerSensitiveWordVO {
+  id: number
+  word: string
+  status: number
+  creator?: string
+  creatorName?: string
+  createTime?: Date
+}
+
+// 获得敏感词分页
+export const getManagerSensitiveWordPage = (params: PageParam) => {
+  return request.get({ url: '/im/manager/sensitive-word/page', params })
+}
+
+// 获得敏感词详情
+export const getManagerSensitiveWord = (id: number) => {
+  return request.get({ url: '/im/manager/sensitive-word/get', params: { id } })
+}
+
+// 新增敏感词
+export const createManagerSensitiveWord = (data: ImManagerSensitiveWordVO) => {
+  return request.post({ url: '/im/manager/sensitive-word/create', data })
+}
+
+// 修改敏感词
+export const updateManagerSensitiveWord = (data: ImManagerSensitiveWordVO) => {
+  return request.put({ url: '/im/manager/sensitive-word/update', data })
+}
+
+// 删除敏感词
+export const deleteManagerSensitiveWord = (id: number) => {
+  return request.delete({ url: '/im/manager/sensitive-word/delete', params: { id } })
+}
+
+// 批量删除敏感词
+export const deleteManagerSensitiveWordList = (ids: number[]) => {
+  return request.delete({
+    url: '/im/manager/sensitive-word/delete-list',
+    params: { ids: ids.join(',') }
+  })
+}

src/api/im/manager/statistics/index.ts

@@ -0,0 +1,70 @@
+import request from '@/config/axios'
+
+export interface ImStatisticsOverviewVO {
+  totalUser: number
+  newUserToday: number
+  totalGroup: number
+  newGroupToday: number
+  activeUserDaily: number
+  activeUserWeekly: number
+  activeUserMonthly: number
+  privateMessageToday: number
+  groupMessageToday: number
+  privateMessageYesterday: number
+  groupMessageYesterday: number
+}
+
+export interface ImStatisticsTrendVO {
+  dates: string[]
+  series: Record<string, number[]>
+}
+
+export interface ImStatisticsMessageTypeVO {
+  type: number // 参见 ImMessageTypeEnum 枚举类，由前端按 DICT_TYPE.IM_MESSAGE_TYPE 翻译
+  value: number
+}
+
+export interface ImStatisticsGroupSizeVO {
+  range: string
+  count: number
+}
+
+export interface ImStatisticsTopSenderVO {
+  userId: number
+  nickname: string
+  messageCount: number
+}
+
+// 获得 KPI 概览
+export const getStatisticsOverview = (): Promise<ImStatisticsOverviewVO> => {
+  return request.get<ImStatisticsOverviewVO>({ url: '/im/manager/statistics/overview' })
+}
+
+// 获得消息趋势（私聊 + 群聊双线）
+export const getMessageTrend = (days: number): Promise<ImStatisticsTrendVO> => {
+  return request.get<ImStatisticsTrendVO>({ url: '/im/manager/statistics/message-trend', params: { days } })
+}
+
+// 获得用户趋势（新增注册 + 日活双线）
+export const getUserTrend = (days: number): Promise<ImStatisticsTrendVO> => {
+  return request.get<ImStatisticsTrendVO>({ url: '/im/manager/statistics/user-trend', params: { days } })
+}
+
+// 获得消息类型分布（最近 30 天）
+export const getMessageTypeDistribution = (): Promise<ImStatisticsMessageTypeVO[]> => {
+  return request.get<ImStatisticsMessageTypeVO[]>({
+    url: '/im/manager/statistics/message-type-distribution'
+  })
+}
+
+// 获得群规模分布
+export const getGroupSizeDistribution = (): Promise<ImStatisticsGroupSizeVO[]> => {
+  return request.get<ImStatisticsGroupSizeVO[]>({
+    url: '/im/manager/statistics/group-size-distribution'
+  })
+}
+
+// 获得消息 TOP 发送者（最近 30 天）
+export const getTopSenders = (): Promise<ImStatisticsTopSenderVO[]> => {
+  return request.get<ImStatisticsTopSenderVO[]>({ url: '/im/manager/statistics/top-senders' })
+}

src/api/im/message/channel/index.ts

@@ -0,0 +1,30 @@
+import request from '@/config/axios'
+
+export interface ImChannelMessageRespVO {
+  id: number
+  clientMessageId?: string
+  channelId: number
+  materialId: number
+  type: number
+  content: string
+  /** 当前用户已读态；pull 时按 Redis 游标计算填充，多端同步使用 */
+  status?: number
+  sendTime: string
+}
+
+// 拉取当前用户应收的频道消息（离线增量）；按 minId 游标分页
+export const pullChannelMessages = (params: { minId: number; size?: number }, signal?: AbortSignal) => {
+  return request.get<ImChannelMessageRespVO[]>({
+    url: '/im/channel/message/pull',
+    params,
+    signal
+  })
+}
+
+// 上报频道消息已读位置；切到频道会话或拉到新消息后调
+export const readChannelMessages = (channelId: number, messageId: number) => {
+  return request.put({
+    url: '/im/channel/message/read',
+    params: { channelId, messageId }
+  })
+}

src/api/im/message/group/index.ts

@@ -0,0 +1,76 @@
+import request from '@/config/axios'
+
+// 群聊消息 Response VO
+export interface ImGroupMessageRespVO {
+  id: number // 消息编号
+  clientMessageId: string // 客户端消息编号
+  senderId: number // 发送人编号
+  groupId: number // 群编号
+  type: number // 消息类型
+  content: string // 消息内容（JSON 格式）
+  status: number // 消息状态
+  sendTime: string // 发送时间
+  atUserIds?: number[] // @ 目标用户编号列表
+  receiverUserIds?: number[] // 定向接收用户编号列表
+  receiptStatus?: number // 回执状态
+  readCount?: number // 已读人数（回执消息、且发送人为当前用户时有值）
+}
+
+// 群聊消息发送 Request VO
+export interface ImGroupMessageSendReqVO {
+  clientMessageId: string // 客户端消息编号
+  groupId: number // 群编号
+  type: number // 消息类型
+  content: string // 消息内容（JSON 格式）
+  atUserIds?: number[] // @ 目标用户编号列表
+  receipt?: boolean // 是否需要回执
+}
+
+// 群聊历史消息列表 Request VO
+export interface ImGroupMessageListReqVO {
+  groupId: number | string // 群编号
+  maxId?: number | string // 起始消息编号（不含），为空则从最新消息开始
+  limit: number // 拉取数量（1 ~ 200）
+}
+
+// 发送群聊消息
+export const sendGroupMessage = (data: ImGroupMessageSendReqVO) => {
+  return request.post<ImGroupMessageRespVO>({ url: '/im/message/group/send', data })
+}
+
+// 拉取群聊消息（增量）
+export const pullGroupMessages = (
+  params: { minId: number | string; size: number },
+  signal?: AbortSignal
+) => {
+  return request.get<ImGroupMessageRespVO[]>({ url: '/im/message/group/pull', params, signal })
+}
+
+// 查询群聊历史消息
+export const getGroupMessageList = (params: ImGroupMessageListReqVO) => {
+  return request.get<ImGroupMessageRespVO[]>({ url: '/im/message/group/list', params })
+}
+
+// 标记群聊消息已读
+export const readGroupMessages = (groupId: number | string, messageId: number | string) => {
+  return request.put<boolean>({
+    url: '/im/message/group/read',
+    params: { groupId, messageId }
+  })
+}
+
+// 撤回群聊消息
+export const recallGroupMessage = (id: number | string) => {
+  return request.delete<ImGroupMessageRespVO>({
+    url: '/im/message/group/recall',
+    params: { id }
+  })
+}
+
+// 获取群消息已读用户列表
+export const getGroupReadUsers = (params: {
+  groupId: number | string
+  messageId: number | string
+}) => {
+  return request.get<number[]>({ url: '/im/message/group/get-read-user-ids', params })
+}

src/api/im/message/private/index.ts

@@ -0,0 +1,71 @@
+import request from '@/config/axios'
+
+// 私聊消息 Response VO
+export interface ImPrivateMessageRespVO {
+  id: number // 消息编号
+  clientMessageId: string // 客户端消息编号
+  senderId: number // 发送人编号
+  receiverId: number // 接收人编号
+  type: number // 消息类型
+  content: string // 消息内容（JSON 格式）
+  status: number // 消息状态
+  sendTime: string // 发送时间
+}
+
+// 私聊消息发送 Request VO
+export interface ImPrivateMessageSendReqVO {
+  clientMessageId: string // 客户端消息编号
+  receiverId: number // 接收人编号
+  type: number // 消息类型
+  content: string // 消息内容（JSON 格式）
+}
+
+// 私聊历史消息列表 Request VO
+export interface ImPrivateMessageListReqVO {
+  receiverId: number | string // 接收人编号（对方）
+  maxId?: number | string // 起始消息编号（不含），为空则从最新消息开始
+  limit: number // 拉取数量（1 ~ 200）
+}
+
+// 发送私聊消息
+export const sendPrivateMessage = (data: ImPrivateMessageSendReqVO) => {
+  return request.post<ImPrivateMessageRespVO>({ url: '/im/message/private/send', data })
+}
+
+// 拉取私聊消息（增量）
+export const pullPrivateMessages = (
+  params: { minId: number | string; size: number },
+  signal?: AbortSignal
+) => {
+  return request.get<ImPrivateMessageRespVO[]>({ url: '/im/message/private/pull', params, signal })
+}
+
+// 查询私聊历史消息
+export const getPrivateMessageList = (params: ImPrivateMessageListReqVO) => {
+  return request.get<ImPrivateMessageRespVO[]>({ url: '/im/message/private/list', params })
+}
+
+// 标记私聊消息已读
+export const readPrivateMessages = (receiverId: number | string, messageId: number | string) => {
+  return request.put<boolean>({
+    url: '/im/message/private/read',
+    params: { receiverId, messageId }
+  })
+}
+
+// 查询对方已读到我发的最大消息 id（多端 / 离线后用于补齐已读状态）
+export const getPrivateMaxReadMessageId = (peerId: number | string, signal?: AbortSignal) => {
+  return request.get<number | null>({
+    url: '/im/message/private/max-read-message-id',
+    params: { peerId },
+    signal
+  })
+}
+
+// 撤回私聊消息
+export const recallPrivateMessage = (id: number | string) => {
+  return request.delete<ImPrivateMessageRespVO>({
+    url: '/im/message/private/recall',
+    params: { id }
+  })
+}

src/api/im/rtc/index.ts

@@ -0,0 +1,88 @@
+import request from '@/config/axios'
+
+// 创建新通话请求 VO
+export interface ImRtcCallCreateReqVO {
+  conversationType: number
+  mediaType: number
+  groupId?: number
+  inviteeIds: number[] // 被邀请的用户编号集合；私聊必传 1 个对端，群聊必传至少 1 人
+}
+
+// 通话中追加邀请请求 VO；仅群通话可用
+export interface ImRtcCallInviteReqVO {
+  room: string
+  inviteeIds: number[]
+}
+
+// 通话会话 VO；create / join / accept / refreshToken 共用
+export interface ImRtcCallRespVO {
+  room: string // 业务通话编号（同时作为 LiveKit 房间名）
+  livekitUrl: string
+  token?: string // ENDED 状态时为 null（无需 connect LiveKit）
+  conversationType: number
+  mediaType: number
+  status: number
+  endReason?: number // 结束原因；仅 status=ENDED 时有值
+  inviterId: number
+  groupId?: number
+  inviteeIds?: number[]
+  joinedUserIds?: number[]
+}
+
+// 群活跃通话查询响应；不含 token
+export interface ImRtcGroupCallRespVO {
+  room: string
+  groupId: number
+  mediaType: number
+  inviterId: number
+  joinedUserIds?: number[]
+  inviteeIds?: number[]
+}
+
+// 创建新通话；私聊或群聊根据 conversationType 区分
+export const createCall = (data: ImRtcCallCreateReqVO) => {
+  return request.post<ImRtcCallRespVO>({ url: '/im/rtc/create', data })
+}
+
+// 通话中追加邀请；仅群通话可用
+export const inviteCall = (data: ImRtcCallInviteReqVO) => {
+  return request.post<boolean>({ url: '/im/rtc/invite', data })
+}
+
+// 加入已有群通话；用于胶囊条「加入」按钮
+export const joinCall = (room: string) => {
+  return request.post<ImRtcCallRespVO>({ url: '/im/rtc/join', params: { room } })
+}
+
+// 接听通话
+export const acceptCall = (room: string) => {
+  return request.post<ImRtcCallRespVO>({ url: '/im/rtc/accept', params: { room } })
+}
+
+// 拒绝通话
+export const rejectCall = (room: string) => {
+  return request.post<boolean>({ url: '/im/rtc/reject', params: { room } })
+}
+
+// 取消邀请；主叫接通前调用
+export const cancelCall = (room: string) => {
+  return request.post<boolean>({ url: '/im/rtc/cancel', params: { room } })
+}
+
+// 离开通话；接通后调用
+export const leaveCall = (room: string) => {
+  return request.post<boolean>({ url: '/im/rtc/leave', params: { room } })
+}
+
+// 振铃超时检查；RUNNING 端 timer 兜底，触发后端立即扫描该 room 的超时 INVITING（接口静默）
+export const noAnswerCallCheck = (room: string) => {
+  return request.post<boolean>({ url: '/im/rtc/no-answer-call-check', params: { room } })
+}
+
+// 查询当前进行中的通话；目前仅群聊场景（胶囊条），返回 null 表示无活跃通话
+export const getActiveCall = (groupId: number) => {
+  return request.get<ImRtcGroupCallRespVO | null>({
+    url: '/im/rtc/get-active-call',
+    params: { groupId }
+  })
+}

src/api/iot/alert/config/index.ts

@@ -10,6 +10,9 @@ export interface AlertConfig {
   sceneRuleIds: string // 关联的场景联动规则编号数组
   receiveUserIds: string // 接收的用户编号数组
   receiveTypes: string // 接收的类型数组
+  smsTemplateCode?: string // 短信模板编号
+  mailTemplateCode?: string // 邮件模板编号
+  notifyTemplateCode?: string // 站内信模板编号
 }
 
 // IoT 告警配置 API

src/api/iot/device/modbus/config/index.ts

@@ -0,0 +1,31 @@
+import request from '@/config/axios'
+
+/** Modbus 连接配置 VO */
+export interface DeviceModbusConfigVO {
+  id?: number // 主键
+  deviceId: number // 设备编号
+  ip: string // Modbus 服务器 IP 地址
+  port: number // Modbus 服务器端口
+  slaveId: number // 从站地址
+  timeout: number // 连接超时时间，单位：毫秒
+  retryInterval: number // 重试间隔，单位：毫秒
+  mode: number // 模式
+  frameFormat: number // 帧格式
+  status: number // 状态
+}
+
+/** Modbus 连接配置 API */
+export const DeviceModbusConfigApi = {
+  /** 获取设备的 Modbus 连接配置 */
+  getModbusConfig: async (deviceId: number) => {
+    return await request.get<DeviceModbusConfigVO>({
+      url: `/iot/device-modbus-config/get`,
+      params: { deviceId }
+    })
+  },
+
+  /** 保存 Modbus 连接配置 */
+  saveModbusConfig: async (data: DeviceModbusConfigVO) => {
+    return await request.post({ url: `/iot/device-modbus-config/save`, data })
+  }
+}

src/api/iot/device/modbus/point/index.ts

@@ -0,0 +1,48 @@
+import request from '@/config/axios'
+
+/** Modbus 点位配置 VO */
+export interface DeviceModbusPointVO {
+  id?: number // 主键
+  deviceId: number // 设备编号
+  thingModelId?: number // 物模型属性编号
+  identifier: string // 属性标识符
+  name: string // 属性名称
+  functionCode?: number // Modbus 功能码
+  registerAddress?: number // 寄存器起始地址
+  registerCount?: number // 寄存器数量
+  byteOrder?: string // 字节序
+  rawDataType?: string // 原始数据类型
+  scale: number // 缩放因子
+  pollInterval: number // 轮询间隔，单位：毫秒
+  status: number // 状态
+}
+
+/** Modbus 点位配置 API */
+export const DeviceModbusPointApi = {
+  /** 获取设备的 Modbus 点位分页 */
+  getModbusPointPage: async (params: any) => {
+    return await request.get({ url: `/iot/device-modbus-point/page`, params })
+  },
+
+  /** 获取 Modbus 点位详情 */
+  getModbusPoint: async (id: number) => {
+    return await request.get<DeviceModbusPointVO>({
+      url: `/iot/device-modbus-point/get?id=${id}`
+    })
+  },
+
+  /** 创建 Modbus 点位配置 */
+  createModbusPoint: async (data: DeviceModbusPointVO) => {
+    return await request.post({ url: `/iot/device-modbus-point/create`, data })
+  },
+
+  /** 更新 Modbus 点位配置 */
+  updateModbusPoint: async (data: DeviceModbusPointVO) => {
+    return await request.put({ url: `/iot/device-modbus-point/update`, data })
+  },
+
+  /** 删除 Modbus 点位配置 */
+  deleteModbusPoint: async (id: number) => {
+    return await request.delete({ url: `/iot/device-modbus-point/delete?id=${id}` })
+  }
+}

src/api/iot/product/product/index.ts

@@ -16,7 +16,8 @@ export interface ProductVO {
   status: number // 产品状态
   deviceType: number // 设备类型
   netType: number // 联网方式
-  codecType: string // 数据格式（编解码器类型）
+  protocolType: string // 协议类型
+  serializeType: string // 序列化类型
   deviceCount: number // 设备数量
   createTime: Date // 创建时间
 }
@@ -27,9 +28,23 @@ export enum DeviceTypeEnum {
   GATEWAY_SUB = 1, // 网关子设备
   GATEWAY = 2 // 网关设备
 }
-// IOT 数据格式（编解码器类型）枚举类
-export enum CodecTypeEnum {
-  ALINK = 'Alink' // 阿里云 Alink 协议
+// IoT 协议类型枚举
+export enum ProtocolTypeEnum {
+  TCP = 'tcp',
+  UDP = 'udp',
+  WEBSOCKET = 'websocket',
+  HTTP = 'http',
+  MQTT = 'mqtt',
+  EMQX = 'emqx',
+  COAP = 'coap',
+  MODBUS_TCP_CLIENT = 'modbus_tcp_client',
+  MODBUS_TCP_SERVER = 'modbus_tcp_server'
+}
+
+// IoT 序列化类型枚举
+export enum SerializeTypeEnum {
+  JSON = 'json',
+  BINARY = 'binary'
 }
 
 // IoT 产品 API

src/api/iot/rule/data/sink/index.ts

@@ -13,6 +13,7 @@ export interface DataSinkVO {
     | TcpConfig
     | WebSocketConfig
     | MqttConfig
+    | DatabaseConfig
     | RocketMQConfig
     | KafkaMQConfig
     | RabbitMQConfig
@@ -73,6 +74,14 @@ export interface MqttConfig extends Config {
   topic: string
 }
 
+/** Database 配置 */
+export interface DatabaseConfig extends Config {
+  jdbcUrl: string
+  username: string
+  password: string
+  tableName: string
+}
+
 /** RocketMQ 配置 */
 export interface RocketMQConfig extends Config {
   nameServer: string

src/api/iot/rule/scene/index.ts

@@ -5,6 +5,7 @@ export interface IotSceneRule {
   id?: number // 场景编号
   name: string // 场景名称
   description?: string // 场景描述
+  lastTriggerTime?: string // 最近触发时间
   status: number // 场景状态：0-开启，1-关闭
   triggers: Trigger[] // 触发器数组
   actions: Action[] // 执行器数组

src/api/iot/thingmodel/index.ts

@@ -215,8 +215,8 @@ export const ThingModelFormRules = {
   identifier: [
     { required: true, message: '标识符不能为空', trigger: 'blur' },
     {
-      pattern: /^[a-zA-Z0-9_]{1,50}$/,
-      message: '支持大小写字母、数字和下划线，不超过 50 个字符',
+      pattern: /^[a-zA-Z][a-zA-Z0-9_]{0,31}$/,
+      message: '支持大小写字母、数字和下划线，必须以字母开头，不超过 32 个字符',
       trigger: 'blur'
     },
     {

src/api/mall/statistics/member.ts

@@ -79,7 +79,7 @@ export const getMemberSummary = () => {
 export const getMemberAnalyse = (params: MemberAnalyseReqVO) => {
   return request.get<MemberAnalyseRespVO>({
     url: '/statistics/member/analyse',
-    params: { times: [formatDate(params.times[0]), formatDate(params.times[1])] }
+    params: { times: [formatDate(params.times[0] as any), formatDate(params.times[1] as any)] }
   })
 }
 
@@ -118,6 +118,6 @@ export const getMemberRegisterCountList = (
 ) => {
   return request.get<MemberRegisterCountRespVO[]>({
     url: '/statistics/member/register-count-list',
-    params: { times: [formatDate(beginTime), formatDate(endTime)] }
+    params: { times: [formatDate(beginTime as any), formatDate(endTime as any)] }
   })
 }

src/api/member/user/index.ts

@@ -9,6 +9,7 @@ export interface UserVO {
   loginIp: string
   mark: string
   mobile: string
+  email: string | undefined
   name: string | undefined
   nickname: string | undefined
   registerIp: string

src/api/mes/cal/calendar/index.ts

@@ -0,0 +1,25 @@
+import request from '@/config/axios'
+
+// 排班日历 - 班组排班项
+export interface CalCalendarTeamShiftItem {
+  teamId: number
+  teamName: string
+  shiftId: number
+  shiftName: string
+  sort: number
+}
+
+// 排班日历 - 日历天 VO
+export interface CalCalendarDayVO {
+  day: string // yyyy-MM-dd
+  shiftType: number // 轮班方式
+  teamShifts: CalCalendarTeamShiftItem[]
+}
+
+// 排班日历 API
+export const CalCalendarApi = {
+  // 查询排班日历列表
+  getCalendarList: async (params: any) => {
+    return await request.get({ url: `/mes/cal/calendar/list`, params })
+  }
+}

src/api/mes/cal/holiday/index.ts

@@ -0,0 +1,28 @@
+import request from '@/config/axios'
+
+// MES 假期设置 VO
+export interface CalHolidayVO {
+  id: number // 编号
+  day: number // 日期（时间戳）
+  type: number // 日期类型
+  remark: string // 备注
+  createTime: string // 创建时间
+}
+
+// MES 假期设置 API
+export const CalHolidayApi = {
+  // 查询假期设置列表（支持可选日期范围过滤）
+  getHolidayList: async (params?: { startDay?: string; endDay?: string }) => {
+    return await request.get({ url: `/mes/cal/holiday/list`, params })
+  },
+
+  // 根据日期查询假期设置
+  getHolidayByDay: async (day: string) => {
+    return await request.get({ url: `/mes/cal/holiday/get-by-day`, params: { day } })
+  },
+
+  // 保存假期设置（含 upsert 逻辑）
+  saveHoliday: async (data: CalHolidayVO) => {
+    return await request.post({ url: `/mes/cal/holiday/save`, data })
+  }
+}

src/api/mes/cal/plan/index.ts

@@ -0,0 +1,54 @@
+import request from '@/config/axios'
+
+// MES 排班计划 VO
+export interface CalPlanVO {
+  id: number
+  code: string // 计划编码
+  name: string // 计划名称
+  calendarType: number // 班组类型
+  startDate: number // 开始日期
+  endDate: number // 结束日期
+  shiftType: number // 轮班方式
+  shiftMethod: number // 倒班方式
+  shiftCount: number // 倒班天数
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 排班计划 API
+export const CalPlanApi = {
+  // 查询排班计划分页
+  getPlanPage: async (params: any) => {
+    return await request.get({ url: `/mes/cal/plan/page`, params })
+  },
+
+  // 查询排班计划详情
+  getPlan: async (id: number) => {
+    return await request.get({ url: `/mes/cal/plan/get?id=` + id })
+  },
+
+  // 新增排班计划
+  createPlan: async (data: CalPlanVO) => {
+    return await request.post({ url: `/mes/cal/plan/create`, data })
+  },
+
+  // 修改排班计划
+  updatePlan: async (data: CalPlanVO) => {
+    return await request.put({ url: `/mes/cal/plan/update`, data })
+  },
+
+  // 确认排班计划
+  confirmPlan: async (id: number) => {
+    return await request.put({ url: `/mes/cal/plan/confirm?id=` + id })
+  },
+
+  // 删除排班计划
+  deletePlan: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/plan/delete?id=` + id })
+  },
+
+  // 导出排班计划 Excel
+  exportPlan: async (params: any) => {
+    return await request.download({ url: `/mes/cal/plan/export-excel`, params })
+  }
+}

src/api/mes/cal/plan/shift/index.ts

@@ -0,0 +1,35 @@
+import request from '@/config/axios'
+
+// MES 计划班次 VO
+export interface CalPlanShiftVO {
+  id: number
+  planId: number // 排班计划编号
+  sort: number // 显示顺序
+  name: string // 班次名称
+  startTime: string // 开始时间
+  endTime: string // 结束时间
+  remark: string // 备注
+}
+
+// MES 计划班次 API
+export const CalPlanShiftApi = {
+  // 查询指定排班计划的班次列表
+  getPlanShiftListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/cal/plan-shift/list-by-plan?planId=` + planId })
+  },
+
+  // 新增计划班次
+  createPlanShift: async (data: CalPlanShiftVO) => {
+    return await request.post({ url: `/mes/cal/plan-shift/create`, data })
+  },
+
+  // 修改计划班次
+  updatePlanShift: async (data: CalPlanShiftVO) => {
+    return await request.put({ url: `/mes/cal/plan-shift/update`, data })
+  },
+
+  // 删除计划班次
+  deletePlanShift: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/plan-shift/delete?id=` + id })
+  }
+}

src/api/mes/cal/plan/team.ts.bak

@@ -0,0 +1,31 @@
+import request from '@/config/axios'
+
+// MES 计划班组关联 VO
+export interface CalPlanTeamVO {
+  id: number
+  planId: number // 排班计划编号
+  teamId: number // 班组编号
+  teamCode: string // 班组编码
+  teamName: string // 班组名称
+  remark: string // 备注
+}
+
+// TODO @AI：挪到 team/index.ts 中
+
+// MES 计划班组关联 API
+export const CalPlanTeamApi = {
+  // 查询指定排班计划的班组列表
+  getPlanTeamListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/cal/plan-team/list-by-plan?planId=` + planId })
+  },
+
+  // 新增计划班组关联
+  createPlanTeam: async (data: CalPlanTeamVO) => {
+    return await request.post({ url: `/mes/cal/plan-team/create`, data })
+  },
+
+  // 删除计划班组关联
+  deletePlanTeam: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/plan-team/delete?id=` + id })
+  }
+}

src/api/mes/cal/plan/team/index.ts

@@ -0,0 +1,29 @@
+import request from '@/config/axios'
+
+// MES 计划班组关联 VO
+export interface CalPlanTeamVO {
+  id: number
+  planId: number // 排班计划编号
+  teamId: number // 班组编号
+  teamCode: string // 班组编码
+  teamName: string // 班组名称
+  remark: string // 备注
+}
+
+// MES 计划班组关联 API
+export const CalPlanTeamApi = {
+  // 查询指定排班计划的班组列表
+  getPlanTeamListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/cal/plan-team/list-by-plan?planId=` + planId })
+  },
+
+  // 新增计划班组关联
+  createPlanTeam: async (data: CalPlanTeamVO) => {
+    return await request.post({ url: `/mes/cal/plan-team/create`, data })
+  },
+
+  // 删除计划班组关联
+  deletePlanTeam: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/plan-team/delete?id=` + id })
+  }
+}

src/api/mes/cal/shift/index.ts.bak

@@ -0,0 +1,37 @@
+import request from '@/config/axios'
+
+// TODO @AI：挪到 plan/shift 目录下
+
+// MES 计划班次 VO
+export interface CalPlanShiftVO {
+  id: number
+  planId: number // 排班计划编号
+  sort: number // 显示顺序
+  name: string // 班次名称
+  startTime: string // 开始时间
+  endTime: string // 结束时间
+  remark: string // 备注
+}
+
+// MES 计划班次 API
+export const CalPlanShiftApi = {
+  // 查询指定排班计划的班次列表
+  getPlanShiftListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/cal/plan-shift/list-by-plan?planId=` + planId })
+  },
+
+  // 新增计划班次
+  createPlanShift: async (data: CalPlanShiftVO) => {
+    return await request.post({ url: `/mes/cal/plan-shift/create`, data })
+  },
+
+  // 修改计划班次
+  updatePlanShift: async (data: CalPlanShiftVO) => {
+    return await request.put({ url: `/mes/cal/plan-shift/update`, data })
+  },
+
+  // 删除计划班次
+  deletePlanShift: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/plan-shift/delete?id=` + id })
+  }
+}

src/api/mes/cal/team/index.ts

@@ -0,0 +1,48 @@
+import request from '@/config/axios'
+
+// MES 班组 VO
+export interface CalTeamVO {
+  id: number
+  code: string // 班组编码
+  name: string // 班组名称
+  calendarType: number // 班组类型
+  remark: string // 备注
+}
+
+// MES 班组 API
+export const CalTeamApi = {
+  // 查询班组分页
+  getTeamPage: async (params: any) => {
+    return await request.get({ url: `/mes/cal/team/page`, params })
+  },
+
+  // 查询班组详情
+  getTeam: async (id: number) => {
+    return await request.get({ url: `/mes/cal/team/get?id=` + id })
+  },
+
+  // 新增班组
+  createTeam: async (data: CalTeamVO) => {
+    return await request.post({ url: `/mes/cal/team/create`, data })
+  },
+
+  // 修改班组
+  updateTeam: async (data: CalTeamVO) => {
+    return await request.put({ url: `/mes/cal/team/update`, data })
+  },
+
+  // 删除班组
+  deleteTeam: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/team/delete?id=` + id })
+  },
+
+  // 获得班组列表（全量，用于下拉选择）
+  getTeamList: async () => {
+    return await request.get({ url: `/mes/cal/team/list` })
+  },
+
+  // 导出班组 Excel
+  exportTeam: async (params: any) => {
+    return await request.download({ url: `/mes/cal/team/export-excel`, params })
+  }
+}

src/api/mes/cal/team/member/index.ts

@@ -0,0 +1,42 @@
+import request from '@/config/axios'
+
+// MES 班组成员 VO
+export interface CalTeamMemberVO {
+  id: number
+  teamId: number // 班组编号
+  userId: number // 用户编号
+  nickname: string // 用户昵称（关联查询）
+  telephone: string // 用户手机号（关联查询）
+  remark: string // 备注
+}
+
+// MES 班组成员 API
+export const CalTeamMemberApi = {
+  // 创建班组成员
+  createTeamMember: async (data: CalTeamMemberVO) => {
+    return await request.post({ url: `/mes/cal/team-member/create`, data })
+  },
+
+  // 删除班组成员
+  deleteTeamMember: async (id: number) => {
+    return await request.delete({ url: `/mes/cal/team-member/delete?id=` + id })
+  },
+
+  // 查询班组成员分页
+  getTeamMemberPage: async (params: any) => {
+    return await request.get({ url: `/mes/cal/team-member/page`, params })
+  },
+
+  // 查询指定班组的成员列表
+  getTeamMemberListByTeam: async (teamId: number) => {
+    return await request.get({ url: `/mes/cal/team-member/list-by-team`, params: { teamId } })
+  },
+
+  // 查询多个班组的成员列表
+  getTeamMemberListByTeamIds: async (teamIds: number[]) => {
+    return await request.get({
+      url: `/mes/cal/team-member/list-by-team`,
+      params: { teamIds: teamIds.join(',') }
+    })
+  }
+}

src/api/mes/cal/team/shift/index.ts

@@ -0,0 +1,22 @@
+import request from '@/config/axios'
+
+// MES 班组排班 VO
+export interface CalTeamShiftVO {
+  id: number
+  planId: number // 排班计划编号
+  teamId: number // 班组编号
+  shiftId: number // 班次编号
+  day: number // 日期
+  sort: number // 排序
+  teamName: string // 班组名称（关联查询）
+  shiftName: string // 班次名称（关联查询）
+  remark: string // 备注
+}
+
+// MES 班组排班 API
+export const CalTeamShiftApi = {
+  // 查询班组排班列表
+  getTeamShiftList: async (params: any) => {
+    return await request.get({ url: `/mes/cal/team-shift/list`, params })
+  }
+}

src/api/mes/dv/checkplan/index.ts

@@ -0,0 +1,58 @@
+import request from '@/config/axios'
+
+// MES 点检保养方案 VO
+export interface DvCheckPlanVO {
+  id: number // 编号
+  code: string // 方案编码
+  name: string // 方案名称
+  type: number // 方案类型
+  startDate: Date // 开始日期
+  endDate: Date // 结束日期
+  cycleType: number // 周期类型
+  cycleCount: number // 周期数量
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 点检保养方案 API
+export const DvCheckPlanApi = {
+  // 查询点检保养方案分页
+  getCheckPlanPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/check-plan/page`, params })
+  },
+
+  // 查询点检保养方案详情
+  getCheckPlan: async (id: number) => {
+    return await request.get({ url: `/mes/dv/check-plan/get?id=` + id })
+  },
+
+  // 新增点检保养方案
+  createCheckPlan: async (data: DvCheckPlanVO) => {
+    return await request.post({ url: `/mes/dv/check-plan/create`, data })
+  },
+
+  // 修改点检保养方案
+  updateCheckPlan: async (data: DvCheckPlanVO) => {
+    return await request.put({ url: `/mes/dv/check-plan/update`, data })
+  },
+
+  // 启用点检保养方案
+  enableCheckPlan: async (id: number) => {
+    return await request.put({ url: `/mes/dv/check-plan/enable?id=` + id })
+  },
+
+  // 停用点检保养方案
+  disableCheckPlan: async (id: number) => {
+    return await request.put({ url: `/mes/dv/check-plan/disable?id=` + id })
+  },
+
+  // 删除点检保养方案
+  deleteCheckPlan: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-plan/delete?id=` + id })
+  },
+
+  // 导出点检保养方案 Excel
+  exportCheckPlan: async (params: any) => {
+    return await request.download({ url: `/mes/dv/check-plan/export-excel`, params })
+  }
+}

src/api/mes/dv/checkplan/machinery.ts.bak

@@ -0,0 +1,32 @@
+import request from '@/config/axios'
+
+// TODO @AI：放到 machinery/index.ts
+// MES 点检保养方案设备 VO
+export interface DvCheckPlanMachineryVO {
+  id: number
+  planId: number // 方案编号
+  machineryId: number // 设备编号
+  machineryCode: string // 设备编码
+  machineryName: string // 设备名称
+  machineryBrand: string // 品牌
+  machinerySpec: string // 规格型号
+  remark: string // 备注
+}
+
+// MES 点检保养方案设备 API
+export const DvCheckPlanMachineryApi = {
+  // 查询指定方案的设备列表
+  getListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/dv/check-plan-machinery/list-by-plan?planId=` + planId })
+  },
+
+  // 新增方案设备关联
+  create: async (data: DvCheckPlanMachineryVO) => {
+    return await request.post({ url: `/mes/dv/check-plan-machinery/create`, data })
+  },
+
+  // 删除方案设备关联
+  delete: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-plan-machinery/delete?id=` + id })
+  }
+}

src/api/mes/dv/checkplan/machinery/index.ts

@@ -0,0 +1,31 @@
+import request from '@/config/axios'
+
+// MES 点检保养方案设备 VO
+export interface DvCheckPlanMachineryVO {
+  id: number
+  planId: number // 方案编号
+  machineryId: number // 设备编号
+  machineryCode: string // 设备编码
+  machineryName: string // 设备名称
+  machineryBrand: string // 品牌
+  machinerySpecification: string // 规格型号
+  remark: string // 备注
+}
+
+// MES 点检保养方案设备 API
+export const DvCheckPlanMachineryApi = {
+  // 查询指定方案的设备列表
+  getListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/dv/check-plan-machinery/list-by-plan?planId=` + planId })
+  },
+
+  // 新增方案设备关联
+  create: async (data: DvCheckPlanMachineryVO) => {
+    return await request.post({ url: `/mes/dv/check-plan-machinery/create`, data })
+  },
+
+  // 删除方案设备关联
+  delete: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-plan-machinery/delete?id=` + id })
+  }
+}

src/api/mes/dv/checkplan/subject.ts.bak

@@ -0,0 +1,33 @@
+import request from '@/config/axios'
+
+// TODO @AI：放到 subject/index.ts
+// MES 点检保养方案项目 VO
+export interface DvCheckPlanSubjectVO {
+  id: number
+  planId: number // 方案编号
+  subjectId: number // 项目编号
+  subjectCode: string // 项目编码
+  subjectName: string // 项目名称
+  subjectType: number // 项目类型
+  subjectContent: string // 项目内容
+  subjectStandard: string // 标准
+  remark: string // 备注
+}
+
+// MES 点检保养方案项目 API
+export const DvCheckPlanSubjectApi = {
+  // 查询指定方案的项目列表
+  getListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/dv/check-plan-subject/list-by-plan?planId=` + planId })
+  },
+
+  // 新增方案项目关联
+  create: async (data: DvCheckPlanSubjectVO) => {
+    return await request.post({ url: `/mes/dv/check-plan-subject/create`, data })
+  },
+
+  // 删除方案项目关联
+  delete: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-plan-subject/delete?id=` + id })
+  }
+}

src/api/mes/dv/checkplan/subject/index.ts

@@ -0,0 +1,32 @@
+import request from '@/config/axios'
+
+// MES 点检保养方案项目 VO
+export interface DvCheckPlanSubjectVO {
+  id: number
+  planId: number // 方案编号
+  subjectId: number // 项目编号
+  subjectCode: string // 项目编码
+  subjectName: string // 项目名称
+  subjectType: number // 项目类型
+  subjectContent: string // 项目内容
+  subjectStandard: string // 标准
+  remark: string // 备注
+}
+
+// MES 点检保养方案项目 API
+export const DvCheckPlanSubjectApi = {
+  // 查询指定方案的项目列表
+  getListByPlan: async (planId: number) => {
+    return await request.get({ url: `/mes/dv/check-plan-subject/list-by-plan?planId=` + planId })
+  },
+
+  // 新增方案项目关联
+  create: async (data: DvCheckPlanSubjectVO) => {
+    return await request.post({ url: `/mes/dv/check-plan-subject/create`, data })
+  },
+
+  // 删除方案项目关联
+  delete: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-plan-subject/delete?id=` + id })
+  }
+}

src/api/mes/dv/checkrecord/index.ts

@@ -0,0 +1,56 @@
+import request from '@/config/axios'
+
+// MES 设备点检记录 VO
+export interface DvCheckRecordVO {
+  id: number // 编号
+  planId: number // 点检计划编号
+  planName?: string // 计划名称
+  machineryId: number // 设备编号
+  machineryCode?: string // 设备编码
+  machineryName?: string // 设备名称
+  machineryBrand?: string // 品牌
+  machinerySpecification?: string // 规格型号
+  checkTime: Date // 点检时间
+  userId: number // 点检人编号
+  nickname?: string // 点检人名称
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 设备点检记录 API
+export const DvCheckRecordApi = {
+  // 查询设备点检记录分页
+  getCheckRecordPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/check-record/page`, params })
+  },
+
+  // 查询设备点检记录详情
+  getCheckRecord: async (id: number) => {
+    return await request.get({ url: `/mes/dv/check-record/get?id=` + id })
+  },
+
+  // 新增设备点检记录
+  createCheckRecord: async (data: DvCheckRecordVO) => {
+    return await request.post({ url: `/mes/dv/check-record/create`, data })
+  },
+
+  // 修改设备点检记录
+  updateCheckRecord: async (data: DvCheckRecordVO) => {
+    return await request.put({ url: `/mes/dv/check-record/update`, data })
+  },
+
+  // 提交设备点检记录
+  submitCheckRecord: async (id: number) => {
+    return await request.put({ url: `/mes/dv/check-record/submit?id=` + id })
+  },
+
+  // 删除设备点检记录
+  deleteCheckRecord: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-record/delete?id=` + id })
+  },
+
+  // 导出设备点检记录 Excel
+  exportCheckRecord: async (params: any) => {
+    return await request.download({ url: `/mes/dv/check-record/export-excel`, params })
+  }
+}

src/api/mes/dv/checkrecord/line/index.ts

@@ -0,0 +1,43 @@
+import request from '@/config/axios'
+
+// MES 设备点检记录明细 VO
+export interface DvCheckRecordLineVO {
+  id: number // 编号
+  recordId: number // 点检记录编号
+  subjectId: number // 点检项目编号
+  subjectCode?: string // 项目编码
+  subjectName?: string // 项目名称
+  subjectContent?: string // 检查内容
+  subjectStandard?: string // 检查标准
+  checkStatus: number // 点检结果
+  checkResult?: string // 异常描述
+  remark: string // 备注
+}
+
+// MES 设备点检记录明细 API
+export const DvCheckRecordLineApi = {
+  // 查询设备点检记录明细分页
+  getCheckRecordLinePage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/check-record-line/page`, params })
+  },
+
+  // 查询设备点检记录明细详情
+  getCheckRecordLine: async (id: number) => {
+    return await request.get({ url: `/mes/dv/check-record-line/get?id=` + id })
+  },
+
+  // 新增设备点检记录明细
+  createCheckRecordLine: async (data: DvCheckRecordLineVO) => {
+    return await request.post({ url: `/mes/dv/check-record-line/create`, data })
+  },
+
+  // 修改设备点检记录明细
+  updateCheckRecordLine: async (data: DvCheckRecordLineVO) => {
+    return await request.put({ url: `/mes/dv/check-record-line/update`, data })
+  },
+
+  // 删除设备点检记录明细
+  deleteCheckRecordLine: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/check-record-line/delete?id=` + id })
+  }
+}

src/api/mes/dv/machinery/index.ts

@@ -0,0 +1,56 @@
+import request from '@/config/axios'
+
+// MES 设备台账 VO
+export interface DvMachineryVO {
+  id: number // 编号
+  code: string // 设备编码
+  name: string // 设备名称
+  brand: string // 品牌
+  specification: string // 规格型号
+  machineryTypeId: number // 设备类型编号
+  machineryTypeName: string // 设备类型名称
+  workshopId: number // 所属车间编号
+  workshopName: string // 所属车间名称
+  status: number // 设备状态
+  lastMaintenTime: Date // 最近保养时间
+  lastCheckTime: Date // 最近点检时间
+  remark: string // 备注
+}
+
+// MES 设备台账 API
+export const DvMachineryApi = {
+  // 查询设备台账分页
+  getMachineryPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/machinery/page`, params })
+  },
+
+  // 查询设备台账详情
+  getMachinery: async (id: number) => {
+    return await request.get({ url: `/mes/dv/machinery/get?id=` + id })
+  },
+
+  // 新增设备台账
+  createMachinery: async (data: DvMachineryVO) => {
+    return await request.post({ url: `/mes/dv/machinery/create`, data })
+  },
+
+  // 修改设备台账
+  updateMachinery: async (data: DvMachineryVO) => {
+    return await request.put({ url: `/mes/dv/machinery/update`, data })
+  },
+
+  // 删除设备台账
+  deleteMachinery: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/machinery/delete?id=` + id })
+  },
+
+  // 导出设备台账 Excel
+  exportMachinery: async (params: any) => {
+    return await request.download({ url: `/mes/dv/machinery/export-excel`, params })
+  },
+
+  // 下载设备导入模板
+  importTemplate: async () => {
+    return await request.download({ url: `/mes/dv/machinery/get-import-template` })
+  }
+}

src/api/mes/dv/machinery/type/index.ts

@@ -0,0 +1,45 @@
+import request from '@/config/axios'
+
+// MES 设备类型 VO
+export interface DvMachineryTypeVO {
+  id: number // 编号
+  parentId: number // 父类型编号
+  code: string // 类型编码
+  name: string // 类型名称
+  sort: number // 显示排序
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 设备类型 API
+export const DvMachineryTypeApi = {
+  // 查询设备类型列表
+  getMachineryTypeList: async (params?: any) => {
+    return await request.get({ url: `/mes/dv/machinery-type/list`, params })
+  },
+
+  // 查询设备类型精简列表
+  getMachineryTypeSimpleList: async () => {
+    return await request.get({ url: `/mes/dv/machinery-type/simple-list` })
+  },
+
+  // 查询设备类型详情
+  getMachineryType: async (id: number) => {
+    return await request.get({ url: `/mes/dv/machinery-type/get?id=` + id })
+  },
+
+  // 新增设备类型
+  createMachineryType: async (data: DvMachineryTypeVO) => {
+    return await request.post({ url: `/mes/dv/machinery-type/create`, data })
+  },
+
+  // 修改设备类型
+  updateMachineryType: async (data: DvMachineryTypeVO) => {
+    return await request.put({ url: `/mes/dv/machinery-type/update`, data })
+  },
+
+  // 删除设备类型
+  deleteMachineryType: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/machinery-type/delete?id=` + id })
+  }
+}

src/api/mes/dv/maintenrecord/index.ts

@@ -0,0 +1,56 @@
+import request from '@/config/axios'
+
+// MES 设备保养记录 VO
+export interface DvMaintenRecordVO {
+  id: number // 编号
+  planId: number // 计划编号
+  planName?: string // 计划名称
+  machineryId: number // 设备编号
+  machineryCode?: string // 设备编码
+  machineryName?: string // 设备名称
+  machineryBrand?: string // 品牌
+  machinerySpecification?: string // 规格型号
+  maintenTime: Date // 保养时间
+  userId: number // 用户编号
+  nickname?: string // 保养人名称
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 设备保养记录 API
+export const DvMaintenRecordApi = {
+  // 查询设备保养记录分页
+  getMaintenRecordPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/mainten-record/page`, params })
+  },
+
+  // 查询设备保养记录详情
+  getMaintenRecord: async (id: number) => {
+    return await request.get({ url: `/mes/dv/mainten-record/get?id=` + id })
+  },
+
+  // 新增设备保养记录
+  createMaintenRecord: async (data: DvMaintenRecordVO) => {
+    return await request.post({ url: `/mes/dv/mainten-record/create`, data })
+  },
+
+  // 修改设备保养记录
+  updateMaintenRecord: async (data: DvMaintenRecordVO) => {
+    return await request.put({ url: `/mes/dv/mainten-record/update`, data })
+  },
+
+  // 提交设备保养记录
+  submitMaintenRecord: async (id: number) => {
+    return await request.put({ url: `/mes/dv/mainten-record/submit?id=` + id })
+  },
+
+  // 删除设备保养记录
+  deleteMaintenRecord: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/mainten-record/delete?id=` + id })
+  },
+
+  // 导出设备保养记录 Excel
+  exportMaintenRecord: async (params: any) => {
+    return await request.download({ url: `/mes/dv/mainten-record/export-excel`, params })
+  }
+}

src/api/mes/dv/maintenrecord/line/index.ts

@@ -0,0 +1,42 @@
+import request from '@/config/axios'
+
+// MES 设备保养记录明细 VO
+export interface DvMaintenRecordLineVO {
+  id: number // 编号
+  recordId: number // 保养记录编号
+  subjectId: number // 项目编号
+  subjectName?: string // 项目名称
+  subjectContent?: string // 项目内容
+  subjectStandard?: string // 项目标准
+  status: number // 保养结果
+  result: string // 异常描述
+  remark: string // 备注
+}
+
+// MES 设备保养记录明细 API
+export const DvMaintenRecordLineApi = {
+  // 查询设备保养记录明细分页
+  getMaintenRecordLinePage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/mainten-record-line/page`, params })
+  },
+
+  // 查询设备保养记录明细详情
+  getMaintenRecordLine: async (id: number) => {
+    return await request.get({ url: `/mes/dv/mainten-record-line/get?id=` + id })
+  },
+
+  // 新增设备保养记录明细
+  createMaintenRecordLine: async (data: DvMaintenRecordLineVO) => {
+    return await request.post({ url: `/mes/dv/mainten-record-line/create`, data })
+  },
+
+  // 修改设备保养记录明细
+  updateMaintenRecordLine: async (data: DvMaintenRecordLineVO) => {
+    return await request.put({ url: `/mes/dv/mainten-record-line/update`, data })
+  },
+
+  // 删除设备保养记录明细
+  deleteMaintenRecordLine: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/mainten-record-line/delete?id=` + id })
+  }
+}

src/api/mes/dv/repair/index.ts

@@ -0,0 +1,74 @@
+import request from '@/config/axios'
+
+// MES 维修工单 VO
+export interface DvRepairVO {
+  id: number // 编号
+  code: string // 维修工单编码
+  name: string // 维修工单名称
+  machineryId: number // 设备编号
+  machineryCode?: string // 设备编码
+  machineryName?: string // 设备名称
+  machineryBrand?: string // 品牌
+  machinerySpecification?: string // 规格型号
+  requireDate: Date // 报修日期
+  finishDate: Date // 维修完成日期
+  confirmDate: Date // 验收日期
+  result: number // 维修结果
+  acceptedUserId: number // 维修人用户编号
+  acceptedUserNickname?: string // 维修人名称
+  confirmUserId: number // 验收人用户编号
+  confirmUserNickname?: string // 验收人名称
+  sourceDocType: number // 来源单据类型
+  sourceDocId: number // 来源单据编号
+  sourceDocCode: string // 来源单据编码
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 维修工单 API
+export const DvRepairApi = {
+  // 查询维修工单分页
+  getRepairPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/repair/page`, params })
+  },
+
+  // 查询维修工单详情
+  getRepair: async (id: number) => {
+    return await request.get({ url: `/mes/dv/repair/get?id=` + id })
+  },
+
+  // 新增维修工单
+  createRepair: async (data: DvRepairVO) => {
+    return await request.post({ url: `/mes/dv/repair/create`, data })
+  },
+
+  // 修改维修工单
+  updateRepair: async (data: DvRepairVO) => {
+    return await request.put({ url: `/mes/dv/repair/update`, data })
+  },
+
+  // 删除维修工单
+  deleteRepair: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/repair/delete?id=` + id })
+  },
+
+  // 导出维修工单 Excel
+  exportRepair: async (params: any) => {
+    return await request.download({ url: `/mes/dv/repair/export-excel`, params })
+  },
+
+  // 提交维修工单（草稿→维修中）
+  submitRepair: async (id: number) => {
+    return await request.put({ url: `/mes/dv/repair/submit?id=` + id })
+  },
+
+  // 确认维修完成（维修中→待验收）
+  confirmRepair: async (data: any) => {
+    return await request.put({ url: `/mes/dv/repair/confirm`, data })
+  },
+
+  // 完成验收（待验收→已确认）
+  finishRepair: async (id: number, result: number) => {
+    return await request.put({ url: `/mes/dv/repair/finish?id=` + id + `&result=` + result })
+  }
+}

src/api/mes/dv/repair/line/index.ts

@@ -0,0 +1,43 @@
+import request from '@/config/axios'
+
+// MES 维修工单行 VO
+export interface DvRepairLineVO {
+  id: number // 编号
+  repairId: number // 维修工单编号
+  subjectId: number // 项目编号
+  subjectName?: string // 项目名称
+  subjectContent?: string // 项目内容
+  subjectStandard?: string // 项目标准
+  malfunction: string // 故障描述
+  malfunctionUrl: string // 故障图片 URL
+  description: string // 维修描述
+  remark: string // 备注
+}
+
+// MES 维修工单行 API
+export const DvRepairLineApi = {
+  // 查询维修工单行分页
+  getRepairLinePage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/repair-line/page`, params })
+  },
+
+  // 查询维修工单行详情
+  getRepairLine: async (id: number) => {
+    return await request.get({ url: `/mes/dv/repair-line/get?id=` + id })
+  },
+
+  // 新增维修工单行
+  createRepairLine: async (data: DvRepairLineVO) => {
+    return await request.post({ url: `/mes/dv/repair-line/create`, data })
+  },
+
+  // 修改维修工单行
+  updateRepairLine: async (data: DvRepairLineVO) => {
+    return await request.put({ url: `/mes/dv/repair-line/update`, data })
+  },
+
+  // 删除维修工单行
+  deleteRepairLine: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/repair-line/delete?id=` + id })
+  }
+}

src/api/mes/dv/subject/index.ts

@@ -0,0 +1,46 @@
+import request from '@/config/axios'
+
+// MES 点检保养项目 VO
+export interface DvSubjectVO {
+  id: number // 编号
+  code: string // 项目编码
+  name: string // 项目名称
+  type: number // 项目类型
+  content: string // 项目内容
+  standard: string // 标准
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 点检保养项目 API
+export const DvSubjectApi = {
+  // 查询点检保养项目分页
+  getSubjectPage: async (params: any) => {
+    return await request.get({ url: `/mes/dv/subject/page`, params })
+  },
+
+  // 查询点检保养项目详情
+  getSubject: async (id: number) => {
+    return await request.get({ url: `/mes/dv/subject/get?id=` + id })
+  },
+
+  // 新增点检保养项目
+  createSubject: async (data: DvSubjectVO) => {
+    return await request.post({ url: `/mes/dv/subject/create`, data })
+  },
+
+  // 修改点检保养项目
+  updateSubject: async (data: DvSubjectVO) => {
+    return await request.put({ url: `/mes/dv/subject/update`, data })
+  },
+
+  // 删除点检保养项目
+  deleteSubject: async (id: number) => {
+    return await request.delete({ url: `/mes/dv/subject/delete?id=` + id })
+  },
+
+  // 导出点检保养项目 Excel
+  exportSubject: async (params: any) => {
+    return await request.download({ url: `/mes/dv/subject/export-excel`, params })
+  }
+}

src/api/mes/home/index.ts

@@ -0,0 +1,51 @@
+import request from '@/config/axios'
+
+// MES 首页汇总统计 VO
+export interface MesHomeSummaryVO {
+  workOrderActiveCount: number
+  workOrderPrepareCount: number
+  workOrderFinishedCount: number
+  todayOutput: number
+  yesterdayOutput: number
+  todayQualifiedQuantity: number
+  todayUnqualifiedQuantity: number
+  machineryTotal: number
+  machineryProducing: number
+  machineryStop: number
+  machineryMaintenance: number
+  andonActiveCount: number
+  repairActiveCount: number
+}
+
+// MES 工单状态分布 VO
+export interface MesHomeWorkOrderStatusVO {
+  status: number
+  statusName: string
+  count: number
+}
+
+// MES 生产趋势 VO
+export interface MesHomeProductionTrendVO {
+  date: string
+  quantity: number
+  qualifiedQuantity: number
+  unqualifiedQuantity: number
+}
+
+// MES 首页统计 API
+export const MesHomeStatisticsApi = {
+  // 获得首页汇总统计
+  getHomeSummary: async (): Promise<MesHomeSummaryVO> => {
+    return await request.get({ url: `/mes/home-statistics/summary` })
+  },
+
+  // 获得工单状态分布
+  getWorkOrderStatusDistribution: async (): Promise<MesHomeWorkOrderStatusVO[]> => {
+    return await request.get({ url: `/mes/home-statistics/work-order-status` })
+  },
+
+  // 获得生产趋势
+  getProductionTrend: async (days?: number): Promise<MesHomeProductionTrendVO[]> => {
+    return await request.get({ url: `/mes/home-statistics/production-trend`, params: { days } })
+  }
+}

src/api/mes/md/autocode/part/index.ts

@@ -0,0 +1,45 @@
+import request from '@/config/axios'
+
+// MES 编码规则分段 VO
+export interface AutoCodePartVO {
+  id: number // 分段编号
+  ruleId: number // 规则编号
+  sort: number // 排序
+  type: number // 分段类型
+  length: number // 长度
+  dateFormat: string // 日期格式
+  fixCharacter: string // 固定字符
+  serialStartNo: number // 流水号起始值
+  serialStep: number // 流水号步长
+  cycleFlag: boolean // 是否循环
+  cycleMethod: number // 循环方式
+  remark: string // 备注
+}
+
+// MES 编码规则分段 API
+export const AutoCodePartApi = {
+  // 查询编码规则分段详情
+  getAutoCodePart: async (id: number) => {
+    return await request.get({ url: `/mes/md/auto-code-part/get?id=` + id })
+  },
+
+  // 查询编码规则分段列表
+  getAutoCodePartListByRuleId: async (ruleId: number) => {
+    return await request.get({ url: `/mes/md/auto-code-part/list-by-rule-id?ruleId=` + ruleId })
+  },
+
+  // 新增编码规则分段
+  createAutoCodePart: async (data: AutoCodePartVO) => {
+    return await request.post({ url: `/mes/md/auto-code-part/create`, data })
+  },
+
+  // 修改编码规则分段
+  updateAutoCodePart: async (data: AutoCodePartVO) => {
+    return await request.put({ url: `/mes/md/auto-code-part/update`, data })
+  },
+
+  // 删除编码规则分段
+  deleteAutoCodePart: async (id: number) => {
+    return await request.delete({ url: `/mes/md/auto-code-part/delete?id=` + id })
+  }
+}

src/api/mes/md/autocode/record/index.ts

@@ -0,0 +1,12 @@
+import request from '@/config/axios'
+
+// MES 编码生成 API
+export const AutoCodeRecordApi = {
+  // 生成编码
+  generateAutoCode: async (ruleCode: string, inputChar?: string) => {
+    return await request.post({
+      url: `/mes/md/auto-code-record/generate`,
+      data: { ruleCode, inputChar }
+    })
+  }
+}

src/api/mes/md/autocode/rule/index.ts

@@ -0,0 +1,48 @@
+import request from '@/config/axios'
+
+// MES 编码规则 VO
+export interface AutoCodeRuleVO {
+  id: number // 规则编号
+  code: string // 规则编码
+  name: string // 规则名称
+  description: string // 规则描述
+  maxLength: number // 最大长度
+  padded: boolean // 是否补齐
+  paddedChar: string // 补齐字符
+  paddedMethod: number // 补齐方式
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 编码规则 API
+export const AutoCodeRuleApi = {
+  // 查询编码规则分页
+  getAutoCodeRulePage: async (params: any) => {
+    return await request.get({ url: `/mes/md/auto-code-rule/page`, params })
+  },
+
+  // 查询编码规则详情
+  getAutoCodeRule: async (id: number) => {
+    return await request.get({ url: `/mes/md/auto-code-rule/get?id=` + id })
+  },
+
+  // 新增编码规则
+  createAutoCodeRule: async (data: AutoCodeRuleVO) => {
+    return await request.post({ url: `/mes/md/auto-code-rule/create`, data })
+  },
+
+  // 修改编码规则
+  updateAutoCodeRule: async (data: AutoCodeRuleVO) => {
+    return await request.put({ url: `/mes/md/auto-code-rule/update`, data })
+  },
+
+  // 删除编码规则
+  deleteAutoCodeRule: async (id: number) => {
+    return await request.delete({ url: `/mes/md/auto-code-rule/delete?id=` + id })
+  },
+
+  // 导出编码规则 Excel
+  exportAutoCodeRule: async (params: any) => {
+    return await request.download({ url: `/mes/md/auto-code-rule/export-excel`, params })
+  }
+}

src/api/mes/md/client/index.ts

@@ -0,0 +1,64 @@
+import request from '@/config/axios'
+
+// MES 客户 VO
+export interface MdClientVO {
+  id: number // 客户编号
+  code: string // 客户编码
+  name: string // 客户名称
+  nickname: string // 客户简称
+  englishName: string // 客户英文名称
+  description: string // 客户简介
+  logo: string // 客户LOGO地址
+  type: number // 客户类型
+  address: string // 客户地址
+  website: string // 客户官网地址
+  email: string // 客户邮箱地址
+  telephone: string // 客户电话
+  contact1Name: string // 联系人1
+  contact1Telephone: string // 联系人1-电话
+  contact1Email: string // 联系人1-邮箱
+  contact2Name: string // 联系人2
+  contact2Telephone: string // 联系人2-电话
+  contact2Email: string // 联系人2-邮箱
+  creditCode: string // 统一社会信用代码
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 客户 API
+export const MdClientApi = {
+  // 查询客户分页
+  getClientPage: async (params: any) => {
+    return await request.get({ url: `/mes/md-client/page`, params })
+  },
+
+  // 查询客户详情
+  getClient: async (id: number) => {
+    return await request.get({ url: `/mes/md-client/get?id=` + id })
+  },
+
+  // 新增客户
+  createClient: async (data: MdClientVO) => {
+    return await request.post({ url: `/mes/md-client/create`, data })
+  },
+
+  // 修改客户
+  updateClient: async (data: MdClientVO) => {
+    return await request.put({ url: `/mes/md-client/update`, data })
+  },
+
+  // 删除客户
+  deleteClient: async (id: number) => {
+    return await request.delete({ url: `/mes/md-client/delete?id=` + id })
+  },
+
+  // 导出客户 Excel
+  exportClient: async (params: any) => {
+    return await request.download({ url: `/mes/md-client/export-excel`, params })
+  },
+
+  // 下载客户导入模板
+  importTemplate: async () => {
+    return await request.download({ url: `/mes/md-client/get-import-template` })
+  }
+}

src/api/mes/md/item/batchConfig/index.ts

@@ -0,0 +1,34 @@
+import request from '@/config/axios'
+
+// MES 物料批次属性配置 VO
+export interface MdItemBatchConfigVO {
+  id?: number // 编号
+  itemId: number // 物料编号
+  produceDateFlag: boolean // 批次属性-生产日期
+  expireDateFlag: boolean // 批次属性-有效期
+  receiptDateFlag: boolean // 批次属性-入库日期
+  vendorFlag: boolean // 批次属性-供应商
+  clientFlag: boolean // 批次属性-客户
+  salesOrderCodeFlag: boolean // 批次属性-销售订单编号
+  purchaseOrderCodeFlag: boolean // 批次属性-采购订单编号
+  workorderFlag: boolean // 批次属性-生产工单
+  taskFlag: boolean // 批次属性-生产任务
+  workstationFlag: boolean // 批次属性-工作站
+  toolFlag: boolean // 批次属性-工具
+  moldFlag: boolean // 批次属性-模具
+  lotNumberFlag: boolean // 批次属性-生产批号
+  qualityStatusFlag: boolean // 批次属性-质量状态
+}
+
+// MES 物料批次属性配置 API
+export const MdItemBatchConfigApi = {
+  // 根据物料编号获取批次属性配置
+  getBatchConfigByItemId: async (itemId: number) => {
+    return await request.get({ url: `/mes/md/item-batch-config/get-by-item-id?itemId=` + itemId })
+  },
+
+  // 保存批次属性配置（新增或更新）
+  saveBatchConfig: async (data: MdItemBatchConfigVO) => {
+    return await request.post({ url: `/mes/md/item-batch-config/save`, data })
+  }
+}

src/api/mes/md/item/index.ts

@@ -0,0 +1,64 @@
+import request from '@/config/axios'
+
+// MES 物料产品 VO
+export interface MdItemVO {
+  id: number // 物料编号
+  code: string // 物料编码
+  name: string // 物料名称
+  specification: string // 规格型号
+  unitMeasureId: number // 计量单位编号
+  unitMeasureName?: string // 计量单位名称
+  itemTypeId: number // 物料分类编号
+  itemTypeName?: string // 物料分类名称
+  itemOrProduct?: string // 物料/产品标识
+  status: number // 状态
+  safeStockFlag: boolean // 是否启用安全库存
+  minStock: number // 最低库存量
+  maxStock: number // 最高库存量
+  highValue: boolean // 是否高值物料
+  batchFlag: boolean // 是否启用批次管理
+  remark: string // 备注
+}
+
+// MES 物料产品 API
+export const MdItemApi = {
+  // 查询物料产品分页
+  getItemPage: async (params: any) => {
+    return await request.get({ url: `/mes/md/item/page`, params })
+  },
+
+  // 查询物料产品详情
+  getItem: async (id: number) => {
+    return await request.get({ url: `/mes/md/item/get?id=` + id })
+  },
+
+  // 新增物料产品
+  createItem: async (data: MdItemVO) => {
+    return await request.post({ url: `/mes/md/item/create`, data })
+  },
+
+  // 修改物料产品
+  updateItem: async (data: MdItemVO) => {
+    return await request.put({ url: `/mes/md/item/update`, data })
+  },
+
+  // 修改物料产品状态
+  updateItemStatus: async (id: number, status: number) => {
+    return await request.put({ url: `/mes/md/item/update-status`, params: { id, status } })
+  },
+
+  // 删除物料产品
+  deleteItem: async (id: number) => {
+    return await request.delete({ url: `/mes/md/item/delete?id=` + id })
+  },
+
+  // 导出物料产品 Excel
+  exportItem: async (params: any) => {
+    return await request.download({ url: `/mes/md/item/export-excel`, params })
+  },
+
+  // 下载物料导入模板
+  importTemplate: async () => {
+    return await request.download({ url: `/mes/md/item/get-import-template` })
+  }
+}

src/api/mes/md/item/productBom/index.ts

@@ -0,0 +1,51 @@
+import request from '@/config/axios'
+
+// MES 产品BOM VO
+export interface MdProductBomVO {
+  id?: number // BOM 编号
+  itemId: number // 物料产品 ID
+  bomItemId: number // BOM 物料 ID
+  quantity: number // 物料使用比例
+  status?: number // 是否启用
+  remark?: string // 备注
+  createTime?: Date // 创建时间
+  // ========== 关联展示字段 ==========
+  bomItemCode?: string // BOM 物料编码
+  bomItemName?: string // BOM 物料名称
+  bomItemSpecification?: string // BOM 物料规格
+  unitMeasureName?: string // 计量单位名称
+  itemOrProduct?: string // 产品物料标识
+}
+
+// MES 产品BOM API
+export const MdProductBomApi = {
+  // 创建产品BOM
+  createProductBom: async (data: MdProductBomVO) => {
+    return await request.post({ url: `/mes/md/product-bom/create`, data })
+  },
+
+  // 更新产品BOM
+  updateProductBom: async (data: MdProductBomVO) => {
+    return await request.put({ url: `/mes/md/product-bom/update`, data })
+  },
+
+  // 删除产品BOM
+  deleteProductBom: async (id: number) => {
+    return await request.delete({ url: `/mes/md/product-bom/delete?id=` + id })
+  },
+
+  // 获得产品BOM
+  getProductBom: async (id: number) => {
+    return await request.get({ url: `/mes/md/product-bom/get?id=` + id })
+  },
+
+  // 获得产品BOM分页
+  getProductBomPage: async (params: any) => {
+    return await request.get({ url: `/mes/md/product-bom/page`, params })
+  },
+
+  // 根据物料产品编号获得产品BOM列表
+  getProductBomListByItemId: async (itemId: number) => {
+    return await request.get({ url: `/mes/md/product-bom/list-by-item-id?itemId=` + itemId })
+  }
+}

src/api/mes/md/item/productSip/index.ts

@@ -0,0 +1,50 @@
+import request from '@/config/axios'
+
+// MES 产品SIP VO
+export interface MdProductSipVO {
+  id?: number // SIP 编号
+  itemId: number // 物料产品 ID
+  sort: number // 排列顺序
+  processId?: number // 工序 ID
+  title: string // 标题
+  description?: string // 详细描述
+  url?: string // 图片地址
+  remark?: string // 备注
+  createTime?: Date // 创建时间
+  // ========== 关联展示字段 ==========
+  processCode?: string // 工序编号
+  processName?: string // 工序名称
+}
+
+// MES 产品SIP API
+export const MdProductSipApi = {
+  // 创建产品SIP
+  createProductSip: async (data: MdProductSipVO) => {
+    return await request.post({ url: `/mes/md/product-sip/create`, data })
+  },
+
+  // 更新产品SIP
+  updateProductSip: async (data: MdProductSipVO) => {
+    return await request.put({ url: `/mes/md/product-sip/update`, data })
+  },
+
+  // 删除产品SIP
+  deleteProductSip: async (id: number) => {
+    return await request.delete({ url: `/mes/md/product-sip/delete?id=` + id })
+  },
+
+  // 获得产品SIP
+  getProductSip: async (id: number) => {
+    return await request.get({ url: `/mes/md/product-sip/get?id=` + id })
+  },
+
+  // 获得产品SIP分页
+  getProductSipPage: async (params: any) => {
+    return await request.get({ url: `/mes/md/product-sip/page`, params })
+  },
+
+  // 根据物料产品编号获得产品SIP列表
+  getProductSipListByItemId: async (itemId: number) => {
+    return await request.get({ url: `/mes/md/product-sip/list-by-item-id?itemId=` + itemId })
+  }
+}

src/api/mes/md/item/productSop/index.ts

@@ -0,0 +1,50 @@
+import request from '@/config/axios'
+
+// MES 产品SOP VO
+export interface MdProductSopVO {
+  id?: number // SOP 编号
+  itemId: number // 物料产品 ID
+  sort: number // 排列顺序
+  processId?: number // 工序 ID
+  title: string // 标题
+  description?: string // 详细描述
+  url?: string // 图片地址
+  remark?: string // 备注
+  createTime?: Date // 创建时间
+  // ========== 关联展示字段 ==========
+  processCode?: string // 工序编号
+  processName?: string // 工序名称
+}
+
+// MES 产品SOP API
+export const MdProductSopApi = {
+  // 创建产品SOP
+  createProductSop: async (data: MdProductSopVO) => {
+    return await request.post({ url: `/mes/md/product-sop/create`, data })
+  },
+
+  // 更新产品SOP
+  updateProductSop: async (data: MdProductSopVO) => {
+    return await request.put({ url: `/mes/md/product-sop/update`, data })
+  },
+
+  // 删除产品SOP
+  deleteProductSop: async (id: number) => {
+    return await request.delete({ url: `/mes/md/product-sop/delete?id=` + id })
+  },
+
+  // 获得产品SOP
+  getProductSop: async (id: number) => {
+    return await request.get({ url: `/mes/md/product-sop/get?id=` + id })
+  },
+
+  // 获得产品SOP分页
+  getProductSopPage: async (params: any) => {
+    return await request.get({ url: `/mes/md/product-sop/page`, params })
+  },
+
+  // 根据物料产品编号获得产品SOP列表
+  getProductSopListByItemId: async (itemId: number) => {
+    return await request.get({ url: `/mes/md/product-sop/list-by-item-id?itemId=` + itemId })
+  }
+}

src/api/mes/md/item/type/index.ts

@@ -0,0 +1,46 @@
+import request from '@/config/axios'
+
+// MES 物料产品分类 VO
+export interface MdItemTypeVO {
+  id: number // 分类编号
+  parentId: number // 父分类编号
+  code: string // 分类编码
+  name: string // 分类名称
+  itemOrProduct: string // 物料/产品标识
+  sort: number // 显示排序
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 物料产品分类 API
+export const MdItemTypeApi = {
+  // 查询物料产品分类列表
+  getItemTypeList: async (params?: any) => {
+    return await request.get({ url: `/mes/md/item-type/list`, params })
+  },
+
+  // 查询物料产品分类精简列表
+  getItemTypeSimpleList: async () => {
+    return await request.get({ url: `/mes/md/item-type/simple-list` })
+  },
+
+  // 查询物料产品分类详情
+  getItemType: async (id: number) => {
+    return await request.get({ url: `/mes/md/item-type/get?id=` + id })
+  },
+
+  // 新增物料产品分类
+  createItemType: async (data: MdItemTypeVO) => {
+    return await request.post({ url: `/mes/md/item-type/create`, data })
+  },
+
+  // 修改物料产品分类
+  updateItemType: async (data: MdItemTypeVO) => {
+    return await request.put({ url: `/mes/md/item-type/update`, data })
+  },
+
+  // 删除物料产品分类
+  deleteItemType: async (id: number) => {
+    return await request.delete({ url: `/mes/md/item-type/delete?id=` + id })
+  }
+}

src/api/mes/md/unitmeasure/index.ts

@@ -0,0 +1,51 @@
+import request from '@/config/axios'
+
+// MES 计量单位 VO
+export interface MdUnitMeasureVO {
+  id: number // 单位编号
+  code: string // 单位编码
+  name: string // 单位名称
+  primaryFlag: boolean // 是否主单位
+  primaryId: number // 主单位编号
+  changeRate: number // 与主单位换算比例
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 计量单位 API
+export const MdUnitMeasureApi = {
+  // 查询计量单位分页
+  getUnitMeasurePage: async (params: any) => {
+    return await request.get({ url: `/mes/md/unit-measure/page`, params })
+  },
+
+  // 查询计量单位精简列表
+  getUnitMeasureSimpleList: async () => {
+    return await request.get({ url: `/mes/md/unit-measure/simple-list` })
+  },
+
+  // 查询计量单位详情
+  getUnitMeasure: async (id: number) => {
+    return await request.get({ url: `/mes/md/unit-measure/get?id=` + id })
+  },
+
+  // 新增计量单位
+  createUnitMeasure: async (data: MdUnitMeasureVO) => {
+    return await request.post({ url: `/mes/md/unit-measure/create`, data })
+  },
+
+  // 修改计量单位
+  updateUnitMeasure: async (data: MdUnitMeasureVO) => {
+    return await request.put({ url: `/mes/md/unit-measure/update`, data })
+  },
+
+  // 删除计量单位
+  deleteUnitMeasure: async (id: number) => {
+    return await request.delete({ url: `/mes/md/unit-measure/delete?id=` + id })
+  },
+
+  // 导出计量单位 Excel
+  exportUnitMeasure: async (params: any) => {
+    return await request.download({ url: `/mes/md/unit-measure/export-excel`, params })
+  }
+}

src/api/mes/md/vendor/index.ts

@@ -0,0 +1,65 @@
+import request from '@/config/axios'
+
+// MES 供应商 VO
+export interface MdVendorVO {
+  id: number // 供应商编号
+  code: string // 供应商编码
+  name: string // 供应商名称
+  nickname: string // 供应商简称
+  englishName: string // 供应商英文名称
+  description: string // 供应商简介
+  logo: string // 供应商LOGO地址
+  level: string // 供应商等级
+  score: number // 供应商评分
+  address: string // 供应商地址
+  website: string // 供应商官网地址
+  email: string // 供应商邮箱地址
+  telephone: string // 供应商电话
+  contact1Name: string // 联系人1
+  contact1Telephone: string // 联系人1-电话
+  contact1Email: string // 联系人1-邮箱
+  contact2Name: string // 联系人2
+  contact2Telephone: string // 联系人2-电话
+  contact2Email: string // 联系人2-邮箱
+  creditCode: string // 统一社会信用代码
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 供应商 API
+export const MdVendorApi = {
+  // 查询供应商分页
+  getVendorPage: async (params: any) => {
+    return await request.get({ url: `/mes/md-vendor/page`, params })
+  },
+
+  // 查询供应商详情
+  getVendor: async (id: number) => {
+    return await request.get({ url: `/mes/md-vendor/get?id=` + id })
+  },
+
+  // 新增供应商
+  createVendor: async (data: MdVendorVO) => {
+    return await request.post({ url: `/mes/md-vendor/create`, data })
+  },
+
+  // 修改供应商
+  updateVendor: async (data: MdVendorVO) => {
+    return await request.put({ url: `/mes/md-vendor/update`, data })
+  },
+
+  // 删除供应商
+  deleteVendor: async (id: number) => {
+    return await request.delete({ url: `/mes/md-vendor/delete?id=` + id })
+  },
+
+  // 导出供应商 Excel
+  exportVendor: async (params: any) => {
+    return await request.download({ url: `/mes/md-vendor/export-excel`, params })
+  },
+
+  // 下载供应商导入模板
+  importTemplate: async () => {
+    return await request.download({ url: `/mes/md-vendor/get-import-template` })
+  }
+}

src/api/mes/md/workstation/index.ts

@@ -0,0 +1,51 @@
+import request from '@/config/axios'
+
+// MES 工作站 VO
+export interface MdWorkstationVO {
+  id: number // 工作站编号
+  code: string // 工作站编码
+  name: string // 工作站名称
+  address: string // 工作站地点
+  workshopId: number // 所在车间 ID
+  workshopName: string // 所在车间名称
+  processId: number // 工序 ID
+  processName: string // 工序名称
+  warehouseId: number // 线边库 ID
+  locationId: number // 库区 ID
+  areaId: number // 库位 ID
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 工作站 API
+export const MdWorkstationApi = {
+  // 查询工作站分页
+  getWorkstationPage: async (params: any) => {
+    return await request.get({ url: `/mes/md-workstation/page`, params })
+  },
+
+  // 查询工作站详情
+  getWorkstation: async (id: number) => {
+    return await request.get({ url: `/mes/md-workstation/get?id=` + id })
+  },
+
+  // 新增工作站
+  createWorkstation: async (data: MdWorkstationVO) => {
+    return await request.post({ url: `/mes/md-workstation/create`, data })
+  },
+
+  // 修改工作站
+  updateWorkstation: async (data: MdWorkstationVO) => {
+    return await request.put({ url: `/mes/md-workstation/update`, data })
+  },
+
+  // 删除工作站
+  deleteWorkstation: async (id: number) => {
+    return await request.delete({ url: `/mes/md-workstation/delete?id=` + id })
+  },
+
+  // 导出工作站 Excel
+  exportWorkstation: async (params: any) => {
+    return await request.download({ url: `/mes/md-workstation/export-excel`, params })
+  }
+}

src/api/mes/md/workstation/machine/index.ts

@@ -0,0 +1,32 @@
+import request from '@/config/axios'
+
+// MES 设备资源 VO
+export interface MdWorkstationMachineVO {
+  id: number
+  workstationId: number // 工作站 ID
+  machineryId: number // 设备 ID
+  machineryName: string // 设备名称
+  machineryCode: string // 设备编码
+  quantity: number // 数量
+  remark: string // 备注
+}
+
+// MES 设备资源 API
+export const MdWorkstationMachineApi = {
+  // 查询设备资源列表
+  getWorkstationMachineList: async (workstationId: number) => {
+    return await request.get({
+      url: `/mes/md-workstation-machine/list-by-workstation?workstationId=` + workstationId
+    })
+  },
+
+  // 新增设备资源
+  createWorkstationMachine: async (data: MdWorkstationMachineVO) => {
+    return await request.post({ url: `/mes/md-workstation-machine/create`, data })
+  },
+
+  // 删除设备资源
+  deleteWorkstationMachine: async (id: number) => {
+    return await request.delete({ url: `/mes/md-workstation-machine/delete?id=` + id })
+  }
+}

src/api/mes/md/workstation/tool/index.ts

@@ -0,0 +1,36 @@
+import request from '@/config/axios'
+
+// MES 工装夹具资源 VO
+export interface MdWorkstationToolVO {
+  id: number
+  workstationId: number // 工作站 ID
+  toolTypeId: number // 工具类型 ID
+  toolTypeName: string // 工具类型名称
+  quantity: number // 数量
+  remark: string // 备注
+}
+
+// MES 工装夹具资源 API
+export const MdWorkstationToolApi = {
+  // 查询工装夹具资源列表
+  getWorkstationToolList: async (workstationId: number) => {
+    return await request.get({
+      url: `/mes/md-workstation-tool/list-by-workstation?workstationId=` + workstationId
+    })
+  },
+
+  // 新增工装夹具资源
+  createWorkstationTool: async (data: MdWorkstationToolVO) => {
+    return await request.post({ url: `/mes/md-workstation-tool/create`, data })
+  },
+
+  // 修改工装夹具资源
+  updateWorkstationTool: async (data: MdWorkstationToolVO) => {
+    return await request.put({ url: `/mes/md-workstation-tool/update`, data })
+  },
+
+  // 删除工装夹具资源
+  deleteWorkstationTool: async (id: number) => {
+    return await request.delete({ url: `/mes/md-workstation-tool/delete?id=` + id })
+  }
+}

src/api/mes/md/workstation/worker/index.ts

@@ -0,0 +1,36 @@
+import request from '@/config/axios'
+
+// MES 人力资源 VO
+export interface MdWorkstationWorkerVO {
+  id: number
+  workstationId: number // 工作站 ID
+  postId: number // 岗位 ID
+  postName: string // 岗位名称
+  quantity: number // 数量
+  remark: string // 备注
+}
+
+// MES 人力资源 API
+export const MdWorkstationWorkerApi = {
+  // 查询人力资源列表
+  getWorkstationWorkerList: async (workstationId: number) => {
+    return await request.get({
+      url: `/mes/md-workstation-worker/list-by-workstation?workstationId=` + workstationId
+    })
+  },
+
+  // 新增人力资源
+  createWorkstationWorker: async (data: MdWorkstationWorkerVO) => {
+    return await request.post({ url: `/mes/md-workstation-worker/create`, data })
+  },
+
+  // 修改人力资源
+  updateWorkstationWorker: async (data: MdWorkstationWorkerVO) => {
+    return await request.put({ url: `/mes/md-workstation-worker/update`, data })
+  },
+
+  // 删除人力资源
+  deleteWorkstationWorker: async (id: number) => {
+    return await request.delete({ url: `/mes/md-workstation-worker/delete?id=` + id })
+  }
+}

src/api/mes/md/workstation/workshop/index.ts

@@ -0,0 +1,51 @@
+import request from '@/config/axios'
+
+// MES 车间 VO
+export interface MdWorkshopVO {
+  id: number // 车间编号
+  code: string // 车间编码
+  name: string // 车间名称
+  area: number // 面积
+  chargeUserId: number // 负责人用户编号
+  chargeUserName: string // 负责人名称
+  status: number // 状态
+  remark: string // 备注
+}
+
+// MES 车间 API
+export const MdWorkshopApi = {
+  // 查询车间分页
+  getWorkshopPage: async (params: any) => {
+    return await request.get({ url: `/mes/md-workshop/page`, params })
+  },
+
+  // 查询车间精简列表
+  getWorkshopSimpleList: async () => {
+    return await request.get({ url: `/mes/md-workshop/simple-list` })
+  },
+
+  // 查询车间详情
+  getWorkshop: async (id: number) => {
+    return await request.get({ url: `/mes/md-workshop/get?id=` + id })
+  },
+
+  // 新增车间
+  createWorkshop: async (data: MdWorkshopVO) => {
+    return await request.post({ url: `/mes/md-workshop/create`, data })
+  },
+
+  // 修改车间
+  updateWorkshop: async (data: MdWorkshopVO) => {
+    return await request.put({ url: `/mes/md-workshop/update`, data })
+  },
+
+  // 删除车间
+  deleteWorkshop: async (id: number) => {
+    return await request.delete({ url: `/mes/md-workshop/delete?id=` + id })
+  },
+
+  // 导出车间 Excel
+  exportWorkshop: async (params: any) => {
+    return await request.download({ url: `/mes/md-workshop/export-excel`, params })
+  }
+}

src/api/mes/pro/andon/config/index.ts

@@ -0,0 +1,46 @@
+import request from '@/config/axios'
+
+// MES 安灯配置 VO
+export interface ProAndonConfigVO {
+  id: number // 编号
+  reason: string // 呼叫原因
+  level: number // 级别
+  handlerRoleId: number // 处置人角色编号
+  handlerRoleName: string // 处置人角色名称
+  handlerUserId: number // 处置人编号
+  handlerUserNickname: string // 处置人昵称
+  remark: string // 备注
+}
+
+// MES 安灯配置 API
+export const ProAndonConfigApi = {
+  // 查询安灯配置分页
+  getAndonConfigPage: async (params: any) => {
+    return await request.get({ url: `/mes/pro/andon-config/page`, params })
+  },
+
+  // 查询安灯配置列表
+  getAndonConfigList: async () => {
+    return await request.get({ url: `/mes/pro/andon-config/list` })
+  },
+
+  // 查询安灯配置详情
+  getAndonConfig: async (id: number) => {
+    return await request.get({ url: `/mes/pro/andon-config/get?id=` + id })
+  },
+
+  // 新增安灯配置
+  createAndonConfig: async (data: ProAndonConfigVO) => {
+    return await request.post({ url: `/mes/pro/andon-config/create`, data })
+  },
+
+  // 修改安灯配置
+  updateAndonConfig: async (data: ProAndonConfigVO) => {
+    return await request.put({ url: `/mes/pro/andon-config/update`, data })
+  },
+
+  // 删除安灯配置
+  deleteAndonConfig: async (id: number) => {
+    return await request.delete({ url: `/mes/pro/andon-config/delete?id=` + id })
+  }
+}