Publish apes-Authon-Web via gitea-publish skill

2026-08-09 11:46:38 +08:00
parent c762ddb01b
commit 10bea07624
348 changed files with 85177 additions and 0 deletions
@@ -0,0 +1,23 @@
 .DS_Store
 src/config/ezviz.local.js
 node_modules/
 dist/
 saas-web/
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 package-lock.json
 tests/**/coverage/
 # Editor directories and files
 .idea
 .vscode
 .cursor/debug-*.log
 *.suo
 *.ntvs*
 *.njsproj
 *.sln
 .idea
 /dist/
 /manager/
 manager.zip
@@ -0,0 +1,14 @@
 module.exports = {
  presets: [
    // https://github.com/vuejs/vue-cli/tree/master/packages/@vue/babel-preset-app
    '@vue/cli-plugin-babel/preset'
  ],
  'env': {
    'development': {
      // babel-plugin-dynamic-import-node plugin only does one thing by converting all import() to require().
      // This plugin can significantly increase the speed of hot updates, when you have a large number of pages.
      // https://panjiachen.github.io/vue-element-admin-site/guide/advanced/lazy-loading.html
      'plugins': ['dynamic-import-node']
    }
  }
 }
@@ -0,0 +1,9 @@
 {
  "compilerOptions": {
    "baseUrl": "./",
    "paths": {
        "@/*": ["src/*"]
    }
  },
  "exclude": ["node_modules", "dist"]
 }
@@ -0,0 +1,69 @@
 {
  "name": "saas-web",
  "version": "1.0.0",
  "description": "",
  "author": "zhangqu group",
  "scripts": {
    "dev": "vue-cli-service serve ",
    "build:prod": "vue-cli-service build",
    "build:stage": "vue-cli-service build --mode staging",
    "preview": "node build/index.js --preview"
  },
  "dependencies": {
    "@amap/amap-jsapi-loader": "^1.0.1",
    "@wangeditor/editor": "^5.1.23",
    "@wangeditor/editor-for-vue": "^1.0.2",
    "animate.css": "^4.1.1",
    "axios": "0.18.1",
    "core-js": "3.6.5",
    "echarts": "^5.4.1",
    "element-ui": "^2.15.13",
    "fix": "0.0.6",
    "highlight.js": "^11.11.1",
    "html2canvas": "^1.4.1",
    "jspdf": "^2.5.1",
    "marked": "^4.3.0",
    "monaco-editor": "^0.30.1",
    "monaco-editor-webpack-plugin": "^6.0.0",
    "normalize.css": "7.0.0",
    "nprogress": "0.2.0",
    "path-to-regexp": "2.4.0",
    "qrcodejs2": "^0.0.2",
    "them": "0.0.4",
    "to": "^0.2.9",
    "vue": "^2.7.14",
    "vue-monaco": "^1.1.0",
    "vue-router": "^3.5.2",
    "vuex": "3.1.0"
  },
  "devDependencies": {
    "@vue/cli-plugin-babel": "4.4.4",
    "@vue/cli-service": "4.4.4",
    "autoprefixer": "9.5.1",
    "babel-plugin-dynamic-import-node": "2.3.3",
    "chalk": "2.4.2",
    "connect": "3.6.6",
    "html-webpack-plugin": "3.2.0",
    "runjs": "4.3.2",
    "sass": "1.26.8",
    "sass-loader": "8.0.2",
    "script-ext-html-webpack-plugin": "2.1.3",
    "script-loader": "^0.7.2",
    "serve-static": "1.13.2",
    "svg-sprite-loader": "4.1.3",
    "svgo": "1.2.2",
    "vue-template-compiler": "2.7.14"
  },
  "browserslist": [
    "> 1%",
    "last 2 versions"
  ],
  "engines": {
    "node": ">=8.9",
    "npm": ">= 3.0.0"
  },
  "license": "MIT",
  "overrides": {
    "cssnano": "^5.1.15"
  }
 }
@@ -0,0 +1,6 @@
 module.exports = {
  'plugins': {
    // to edit.vue target browsers: use "browserslist" field in package.json
    'autoprefixer': {}
  }
 }
@@ -0,0 +1,31 @@
 <!DOCTYPE html>
 <html>
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
    <link rel="icon" href="<%= BASE_URL %>favicon.ico">
    <link rel="stylesheet" href="https://unpkg.com/element-ui@2.15.14/lib/theme-chalk/index.css">
    <title><%= webpackConfig.name %></title>
  </head>
  <body>
    <noscript>
      <strong>We're sorry but <%= webpackConfig.name %> doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
    </noscript>
    <div id="app"></div>
    <script src="https://unpkg.com/vue@2.7.14/dist/vue.min.js"></script>
    <script src="https://unpkg.com/vue-router@3.5.4/dist/vue-router.min.js"></script>
    <script src="https://unpkg.com/vuex@3.1.3/dist/vuex.min.js"></script>
    <script src="https://unpkg.com/axios@0.18.1/dist/axios.min.js"></script>
    <script src="https://unpkg.com/element-ui@2.15.14/lib/index.js"></script>
    <script src="https://unpkg.com/echarts@5.4.3/dist/echarts.min.js"></script>
    <script>
      // Monaco Editor CDN (AMD loader)
      var require = { paths: { 'vs': 'https://unpkg.com/monaco-editor@0.30.1/min/vs' } };
    </script>
    <script src="https://unpkg.com/monaco-editor@0.30.1/min/vs/loader.js"></script>
    <script src="https://unpkg.com/monaco-editor@0.30.1/min/vs/editor/editor.main.nls.js"></script>
    <script src="https://unpkg.com/monaco-editor@0.30.1/min/vs/editor/editor.main.js"></script>
    <!-- built files will be auto injected -->
  </body>
 </html>
@@ -0,0 +1,56 @@
 #!/bin/bash
 set -e
 export NODE_HOME=/data/tools/node-16
 export PATH=$NODE_HOME/bin:$PATH
 cd /data/saas-web || exit
 # ========== 更新最新代码（先检查冲突，无冲突才更新） ==========
 echo "检查最新代码更新..."
 BRANCH=$(git rev-parse --abbrev-ref HEAD)
 if ! git fetch origin "$BRANCH"; then
  echo "拉取远程分支失败，终止部署"
  exit 1
 fi
 LOCAL_HEAD=$(git rev-parse HEAD)
 REMOTE_HEAD=$(git rev-parse "origin/$BRANCH")
 if [ "$LOCAL_HEAD" = "$REMOTE_HEAD" ]; then
  echo "本地代码已是最新，无需更新"
 else
  echo "本地与远程不一致，先进行冲突检测..."
  if git merge --no-commit --no-ff "origin/$BRANCH" > /tmp/git_merge_check.log 2>&1; then
    git merge --abort >/dev/null 2>&1 || true
    echo "无冲突，开始更新代码..."
    if ! git pull origin "$BRANCH"; then
      echo "代码更新失败，终止部署"
      exit 1
    fi
    echo "代码更新完成"
  else
    echo "!!! 检测到冲突（或本地未提交修改阻止更新），详情："
    cat /tmp/git_merge_check.log
    CONFLICT_FILES=$(git diff --name-only --diff-filter=U 2>/dev/null)
    if [ -n "$CONFLICT_FILES" ]; then
      echo "冲突文件列表："
      echo "$CONFLICT_FILES"
    fi
    git merge --abort >/dev/null 2>&1 || true
    echo "存在冲突，终止更新并退出部署"
    exit 1
  fi
 fi
 echo '开始安装依赖'
 /data/tools/node-16/bin/npm --registry=http://registry.npmmirror.com install
 echo '开始构建'
 /data/tools/node-16/bin/npm --registry=http://registry.npmmirror.com run build:prod
 zip -r saas-web.zip saas-web
 echo '开始传输..'
 scp -P 22 -o "ProxyCommand ssh -W %h:%p root@47.115.213.168" saas-web.zip root@192.168.1.158:/data/services/saas-web.zip
 echo "开始替换..."
 ssh -p 22 -o "ProxyCommand ssh -W %h:%p root@47.115.213.168" root@192.168.1.158 "cd /data/services; unzip -o saas-web.zip"
 echo "上线成功...."
 rm -rf saas-web
 rm -rf saas-web.zip
 echo "上线完毕...."
@@ -0,0 +1,17 @@
 <template>
  <div id="app">
    <router-view/>
  </div>
 </template>
 <script>
 export default {
  name: 'App',
  data() {
    return {}
  },
  provide() {
    return {}
  },
  methods: {}
 }
 </script>
@@ -0,0 +1,33 @@
 import request from '@/utils/request'
 /**
 * AccessToken 管理 API
 */
 const accessTokenApi = {
  create(data) {
    return request.apiPost('/api/user-service/sysAccessToken/create', data)
  },
  page(data) {
    return request.apiPost('/api/user-service/sysAccessToken/page', data)
  },
  revoke(data) {
    return request.apiPost('/api/user-service/sysAccessToken/revoke', data)
  },
  enable(data) {
    return request.apiPost('/api/user-service/sysAccessToken/enable', data)
  },
  regenerate(data) {
    return request.apiPost('/api/user-service/sysAccessToken/regenerate', data)
  },
  delete(data) {
    return request.apiPost('/api/user-service/sysAccessToken/delete', data)
  }
 }
 export default accessTokenApi
@@ -0,0 +1,26 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/aiSkill'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete`, { id })
  }
 }
@@ -0,0 +1,32 @@
 import request from '@/utils/request'
 class appApi {
  async appList() {
    return await request.apiPost('/api/user-service/app/pageApp', {pageIndex:1,pageSize:20})
  }
  async saveApp(data) {
    return await request.apiPost('/api/user-service/app/saveApp', data)
  }
  async deleteApp(data) {
    return await request.apiPost('/api/user-service/app/deleteApp', data)
  }
  async getAppDetail(appKey) {
    return await request.apiPost('/api/user-service/app/getAppDetail', { appKey })
  }
  async getSpaceList() {
    return await request.apiGet('/api/user-service/huoban2/spaceList')
  }
  async getSpaceGroups(spaceId) {
    return await request.apiGet(`/api/user-service/huoban2/getSpaceGroups?spaceId=${spaceId}`)
  }
 }
 const target = new appApi()
 export default target
@@ -0,0 +1,13 @@
 import request from '@/utils/request'
 class baseApi{
  async getImageTypes() {
    return await request.apiGet('/api/base-service/baseImageManage/getImageTypes',{})
  }
  async saveArticle(params) {
    return await request.apiPost('/api/base-service/article/saveArticle',params)
  }
 }
 const target = new baseApi()
 export default target
@@ -0,0 +1,40 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/cameraInfo/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/cameraInfo/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/cameraInfo/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/cameraInfo/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/cameraInfo/delete?id=${id}`)
  },
  // 抓图
  capture(id) {
    return request.apiPost(`${BASE_URL}/cameraInfo/capture?id=${id}`)
  },
  // 查询抓拍记录
  getCaptureLogs(cameraId, pageIndex, pageSize) {
    return request.apiGet(`/api/user-service/cameraCaptureLog/page`, { cameraId, pageIndex, pageSize })
  }
 }
@@ -0,0 +1,101 @@
 import request from '@/utils/request'
 class customerApi {
  async pageCustomer(params) {
    return await request.apiPost('/api/user-service/customer/pageCustomer', params)
  }
  async getCustomerDetail(id) {
    return await request.apiGet(`/api/user-service/customer/getCustomerDetail?id=${id}`)
  }
  async addUser(customerId, userId) {
    return await request.apiGet(`/api/user-service/customer/addUser?customerId=${customerId}&userId=${userId}`)
  }
  async delUser(customerId, userId) {
    return await request.apiGet(`/api/user-service/customer/delUser?customerId=${customerId}&userId=${userId}`)
  }
  async getCustomerUser(customerId){
    return await request.apiGet(`/api/user-service/user/getCustomerUser?customerId=${customerId}`)
  }
  async pageEmployee(params) {
    return await request.apiPost('/api/user-service/customer/employee/page', params)
  }
  async getEmployeeDetail(userId) {
    return await request.apiGet(`/api/user-service/customer/employee/detail?userId=${userId}`)
  }
  async updateEmployee(data) {
    return await request.apiPost('/api/user-service/customer/employee/update', data)
  }
  async saveCustomer(data) {
    return await request.apiPost('/api/user-service/customer/saveCustomer', data)
  }
  async deleteCustomer(data) {
    return await request.apiPost('/api/user-service/customer/deleteCustomer', data)
  }
  async getMyApps() {
    return await request.apiGet('/api/user-service/customer/getMyApps')
  }
  async getCustomerApps(customerId) {
    return await request.apiGet(`/api/user-service/customer/getCustomerApps?customerId=${customerId}`)
  }
  async addCustomerApp(data) {
    return await request.apiPost('/api/user-service/customer/addCustomerApp', data)
  }
  async removeCustomerApp(data) {
    return await request.apiPost('/api/user-service/customer/removeCustomerApp', data)
  }
  async getAllApps() {
    return await request.apiGet('/api/user-service/customer/getAllApps')
  }
  async getSSOConfig(customerId) {
    return await request.apiGet(`/api/user-service/customer/getSSOConfig?customerId=${customerId}`)
  }
  async saveSSOConfig(data) {
    return await request.apiPost('/api/user-service/customer/saveSSOConfig', data)
  }
  async searchUser(phone) {
    return await request.apiPost(`/api/user-service/huoban2/searchUser?phone=${phone}`)
  }
  async huobanWebLogin(phone) {
    return await request.apiGet(`/api/user-service/huoban2/webLogin?phone=${phone}`)
  }
  async updateCustomerStatus(data) {
    return await request.apiPost('/api/user-service/customer/updateCustomerStatus', data)
  }
  async auditCertification(data) {
    return await request.apiPost('/api/user-service/customer/auditCertification', data)
  }
  async getCustomerPackages(customerId) {
    return await request.apiGet(`/api/user-service/customerPackage/list?customerId=${customerId}`)
  }
  async getCustomerPackageQuotas(packageId) {
    return await request.apiGet(`/api/user-service/customerPackage/getQuotas?packageId=${packageId}`)
  }
  async syncTenantsToHuoban() {
    return await request.apiPost('/api/user-service/customer/syncTenantsToHuoban')
  }
 }
 const target = new customerApi()
 export default target
@@ -0,0 +1,56 @@
 import request from '@/utils/request'
 export default {
  // 获取客户套餐列表
  list(customerId) {
    return request.apiGet('/api/user-service/customerPackage/list', { customerId })
  },
  // 新增客户套餐
  add(data) {
    return request.apiPost('/api/user-service/customerPackage/add', data)
  },
  // 编辑客户套餐
  edit(data) {
    return request.apiPost('/api/user-service/customerPackage/edit', data)
  },
  // 删除客户套餐
  delete(id) {
    return request.apiPost('/api/user-service/customerPackage/delete', { id })
  },
  // 获取客户套餐配额
  getQuotas(packageId) {
    return request.apiGet('/api/user-service/customerPackage/getQuotas', { packageId })
  },
  // 保存客户套餐配额
  saveQuotas(data) {
    return request.apiPost('/api/user-service/customerPackage/saveQuotas', data)
  },
  // 获取当前客户的套餐列表（从登录上下文获取 customerId）
  myPackages() {
    return request.apiGet('/api/user-service/customerPackage/myPackages')
  },
  // 提交套餐延期申请
  submitExtendApply(data) {
    return request.apiPost('/api/user-service/customerPackage/submitExtendApply', data)
  },
  // 查询延期申请记录列表
  extendApplyList(data) {
    return request.apiPost('/api/user-service/customerPackage/extendApplyList', data)
  },
  // 审核延期申请（同意/拒绝）
  reviewExtendApply(data) {
    return request.apiPost('/api/user-service/customerPackage/reviewExtendApply', data)
  },
  // 查询配额变更日志
  quotaChangeLogs(params) {
    return request.apiGet('/api/user-service/customerPackage/quotaChangeLogs', params)
  },
  // 增加配额
  increaseQuota(data) {
    return request.apiPost('/api/user-service/customerPackage/increaseQuota', data)
  },
  // 减少配额
  decreaseQuota(data) {
    return request.apiPost('/api/user-service/customerPackage/decreaseQuota', data)
  }
 }
@@ -0,0 +1,26 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/extLink'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete?id=${id}`)
  }
 }
@@ -0,0 +1,47 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/farm-plan'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete`, null, { params: { id } })
  },
  // 查询今日生效的农事计划
  getToday(parkId) {
    return request.apiGet(`${BASE_URL}/today`, { parkId })
  },
  // 更新农事计划状态
  updateStatus(id, status) {
    return request.apiPost(`${BASE_URL}/updateStatus?id=${id}&status=${status}`)
  },
  // 按月查询农事计划（日历视图）
  getMonth(year, month, parkId) {
    const params = { year, month }
    if (parkId) params.parkId = parkId
    return request.apiGet(`${BASE_URL}/month`, params)
  }
 }
@@ -0,0 +1,39 @@
 import request from '@/utils/request'
 class cropApi {
  // 分页查询作物列表
  static page(pageIndex = 1, pageSize = 20, name, categoryId, status) {
    let url = `/api/user-service/fei/crop/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (name) url += '&name=' + name
    if (categoryId) url += '&categoryId=' + categoryId
    if (status !== null && status !== undefined) url += '&status=' + status
    return request.apiPost(url)
  }
  // 获取作物详情
  static detail(id) {
    return request.apiGet(`/api/user-service/fei/crop/detail?id=${id}`)
  }
  // 新增作物
  static add(data) {
    return request.apiPost('/api/user-service/fei/crop/add', data)
  }
  // 修改作物
  static update(data) {
    return request.apiPost('/api/user-service/fei/crop/update', data)
  }
  // 删除作物
  static delete(id) {
    return request.apiPost(`/api/user-service/fei/crop/delete?id=${id}`)
  }
  // 获取所有启用作物（下拉选择用）
  static list() {
    return request.apiGet('/api/user-service/fei/crop/list')
  }
 }
 export default cropApi
@@ -0,0 +1,33 @@
 import request from '@/utils/request'
 class cropPhenologyApi {
  static page(pageIndex = 1, pageSize = 20, cropId, phenologyName, status) {
    let url = `/api/user-service/fei/crop/phenology/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (cropId) url += `&cropId=${cropId}`
    if (phenologyName) url += `&phenologyName=${encodeURIComponent(phenologyName)}`
    if (status !== undefined && status !== null) url += `&status=${status}`
    return request.apiPost(url)
  }
  static listByCropId(cropId) {
    return request.apiGet(`/api/user-service/fei/crop/phenology/list?cropId=${cropId}`)
  }
  static detail(id) {
    return request.apiGet(`/api/user-service/fei/crop/phenology/detail?id=${id}`)
  }
  static add(data) {
    return request.apiPost('/api/user-service/fei/crop/phenology/add', data)
  }
  static update(data) {
    return request.apiPost('/api/user-service/fei/crop/phenology/update', data)
  }
  static delete(id) {
    return request.apiPost(`/api/user-service/fei/crop/phenology/delete?id=${id}`)
  }
 }
 export default cropPhenologyApi
@@ -0,0 +1,60 @@
 import request from '@/utils/request'
 export default {
  /**
   * 分页查询数据上报列表
   */
  page(pageIndex, pageSize, params) {
    const data = { pageIndex, pageSize, ...params }
    return request.apiPost('/api/user-service/fei/device/data/report/page', data)
  },
  /**
   * 查询数据上报详情
   */
  detail(id) {
    return request.apiPost('/api/user-service/fei/device/data/report/detail', { id })
  },
  /**
   * 新增数据上报记录
   */
  add(data) {
    return request.apiPost('/api/user-service/fei/device/data/report/add', data)
  },
  /**
   * 更新数据上报记录
   */
  update(data) {
    return request.apiPost('/api/user-service/fei/device/data/report/update', data)
  },
  /**
   * 删除数据上报记录
   */
  delete(id) {
    return request.apiPost('/api/user-service/fei/device/data/report/delete', { id })
  },
  /**
   * 根据设备ID查询数据列表（图表展示）
   */
  chartData(deviceId, limit) {
    return request.apiPost('/api/user-service/fei/device/data/report/chart', { deviceId, limit })
  },
  /**
   * 批量查询设备最新上报数据
   */
  getLatest(deviceIds) {
    return request.apiGet('/api/user-service/fei/device/data/report/latest', { deviceIds })
  },
  /**
   * 生成模拟数据
   */
  simulate(data) {
    return request.apiPost('/api/user-service/fei/device/data/report/simulate', data)
  }
 }
@@ -0,0 +1,45 @@
 import request from '@/utils/request'
 class fertilizationFormulaApi {
  // 分页查询
  static page(pageIndex = 1, pageSize = 20, cropId, phenologyId, formulaName, status) {
    let url = `/api/user-service/fei/fertilization/formula/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (cropId) url += `&cropId=${cropId}`
    if (phenologyId) url += `&phenologyId=${phenologyId}`
    if (formulaName) url += `&formulaName=${encodeURIComponent(formulaName)}`
    if (status !== undefined && status !== null) url += `&status=${status}`
    return request.apiPost(url)
  }
  // 查询详情（含明细）
  static detail(id) {
    return request.apiGet(`/api/user-service/fei/fertilization/formula/detail?id=${id}`)
  }
  // 根据配方ID查询明细列表
  static details(formulaId) {
    return request.apiGet(`/api/user-service/fei/fertilization/formula/details?formulaId=${formulaId}`)
  }
  // 新增（含明细）
  static add(data) {
    return request.apiPost('/api/user-service/fei/fertilization/formula/add', data)
  }
  // 编辑（含明细）
  static update(data) {
    return request.apiPost('/api/user-service/fei/fertilization/formula/update', data)
  }
  // 删除
  static delete(id) {
    return request.apiPost(`/api/user-service/fei/fertilization/formula/delete?id=${id}`)
  }
  // 根据作物和物候期查询配方列表
  static listByCropAndPhenology(cropId, phenologyId) {
    return request.apiGet(`/api/user-service/fei/fertilization/formula/list?cropId=${cropId}&phenologyId=${phenologyId}`)
  }
 }
 export default fertilizationFormulaApi
@@ -0,0 +1,36 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service'
 class InputMaterialStockLogApi {
  // 分页查询
  static getPage(params) {
    return request.apiGet(`${BASE_URL}/input-material-stock-log/page`, params)
  }
  // 查询详情
  static getDetail(id) {
    return request.apiGet(`${BASE_URL}/input-material-stock-log/detail`, { id })
  }
  // 新增
  static add(data) {
    return request.apiPost(`${BASE_URL}/input-material-stock-log/add`, data)
  }
  // 删除
  static delete(id) {
    return request.apiPost(`${BASE_URL}/input-material-stock-log/delete`, null, { params: { id } })
  }
  // 审核
  static review(params) {
    const queryString = Object.keys(params)
      .filter(key => params[key] !== null && params[key] !== undefined && params[key] !== '')
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')
    return request.apiPost(`${BASE_URL}/input-material-stock-log/review?${queryString}`, null)
  }
 }
 export default InputMaterialStockLogApi
@@ -0,0 +1,70 @@
 import request from '@/utils/request'
 /**
 * 商情检测设备 API
 */
 export default {
  /**
   * 分页查询设备列表
   * @param {Object} params 查询参数
   * @param {number} params.pageIndex 页码
   * @param {number} params.pageSize 每页数量
   * @param {string} params.deviceName 设备名称（模糊查询）
   * @param {string} params.deviceCode 设备编号
   * @param {number} params.deviceType 设备类型 1-五层设备 2-三层设备
   * @param {string} params.installLocation 安装位置（模糊查询）
   * @param {number} params.onlineStatus 设备状态 0-离线 1-在线
   */
  page(pageIndex, pageSize, deviceName, deviceCode, deviceType, installLocation, onlineStatus) {
    const params = { pageIndex, pageSize }
    if (deviceName) params.deviceName = deviceName
    if (deviceCode) params.deviceCode = deviceCode
    if (deviceType !== null && deviceType !== undefined) params.deviceType = deviceType
    if (installLocation) params.installLocation = installLocation
    if (onlineStatus !== null && onlineStatus !== undefined) params.onlineStatus = onlineStatus
    return request.apiPost('/api/user-service/fei/market/device/page', params)
  },
  /**
   * 查询设备详情
   * @param {number} id 设备ID
   */
  detail(id) {
    return request.apiPost('/api/user-service/fei/market/device/detail', { id })
  },
  /**
   * 新增设备
   * @param {Object} data 设备数据
   * @param {string} data.deviceName 设备名称
   * @param {string} data.deviceCode 设备编号
   * @param {number} data.deviceType 设备类型 1-五层设备 2-三层设备
   * @param {string} data.installLocation 安装位置
   * @param {number} data.onlineStatus 设备状态 0-离线 1-在线
   */
  add(data) {
    return request.apiPost('/api/user-service/fei/market/device/add', data)
  },
  /**
   * 更新设备
   * @param {Object} data 设备数据
   * @param {number} data.id 设备ID
   * @param {string} data.deviceName 设备名称
   * @param {string} data.deviceCode 设备编号
   * @param {number} data.deviceType 设备类型 1-五层设备 2-三层设备
   * @param {string} data.installLocation 安装位置
   * @param {number} data.onlineStatus 设备状态 0-离线 1-在线
   */
  update(data) {
    return request.apiPost('/api/user-service/fei/market/device/update', data)
  },
  /**
   * 删除设备
   * @param {number} id 设备ID
   */
  delete(id) {
    return request.apiPost('/api/user-service/fei/market/device/delete', { id })
  }
 }
@@ -0,0 +1,81 @@
 import request from '@/utils/request'
 /**
 * 地块信息 API
 */
 export default {
  /**
   * 分页查询地块列表
   * @param {number} pageIndex 页码
   * @param {number} pageSize 每页数量
   * @param {Object} params 查询参数
   * @param {string} params.plotName 地块名称（模糊查询）
   * @param {string} params.plotCode 地块编号
   * @param {string} params.location 所在地方（模糊查询）
   * @param {number} params.plotType 地块类型 1-农田 2-果园 3-林地 4-建设用地 5-其他
   * @param {number} params.status 地块状态 0-废弃 1-正常 2-使用中
   * @param {string} params.owner 负责人（模糊查询）
   */
  page(pageIndex, pageSize, params = {}) {
    return request.apiPost('/api/user-service/fei/plot/page', {
      pageIndex,
      pageSize,
      ...params
    })
  },
  /**
   * 查询地块详情
   * @param {number} id 地块ID
   */
  detail(id) {
    return request.apiPost('/api/user-service/fei/plot/detail', { id })
  },
  /**
   * 新增地块
   * @param {Object} data 地块数据
   * @param {string} data.plotName 地块名称
   * @param {string} data.plotCode 地块编号
   * @param {number} data.area 面积（亩）
   * @param {string} data.location 所在地方
   * @param {string} data.coordinates 地块坐标点（JSON格式）
   * @param {number} data.plotType 地块类型
   * @param {string} data.soilType 土壤类型
   * @param {number} data.status 地块状态
   * @param {string} data.owner 负责人
   * @param {string} data.contactPhone 联系电话
   * @param {string} data.remark 备注
   */
  add(data) {
    return request.apiPost('/api/user-service/fei/plot/add', data)
  },
  /**
   * 更新地块
   * @param {Object} data 地块数据
   * @param {number} data.id 地块ID
   * @param {string} data.plotName 地块名称
   * @param {string} data.plotCode 地块编号
   * @param {number} data.area 面积
   * @param {string} data.location 所在地方
   * @param {string} data.coordinates 地块坐标点
   * @param {number} data.plotType 地块类型
   * @param {string} data.soilType 土壤类型
   * @param {number} data.status 地块状态
   * @param {string} data.owner 负责人
   * @param {string} data.contactPhone 联系电话
   * @param {string} data.remark 备注
   */
  update(data) {
    return request.apiPost('/api/user-service/fei/plot/update', data)
  },
  /**
   * 删除地块
   * @param {number} id 地块ID
   */
  delete(id) {
    return request.apiPost('/api/user-service/fei/plot/delete', { id })
  }
 }
@@ -0,0 +1,46 @@
 import request from '@/utils/request'
 /**
 * 设备维修记录 API
 */
 export default {
  /**
   * 分页查询维修记录列表
   * @param {Object} params 查询参数
   */
  page(params) {
    return request.apiPost('/api/user-service/fei/repair/record/page', params)
  },
  /**
   * 查询维修记录详情
   * @param {number} id 记录ID
   */
  detail(id) {
    return request.apiPost('/api/user-service/fei/repair/record/detail', { id })
  },
  /**
   * 新增维修记录
   * @param {Object} data 维修记录数据
   */
  add(data) {
    return request.apiPost('/api/user-service/fei/repair/record/add', data)
  },
  /**
   * 更新维修记录
   * @param {Object} data 维修记录数据
   */
  update(data) {
    return request.apiPost('/api/user-service/fei/repair/record/update', data)
  },
  /**
   * 删除维修记录
   * @param {number} id 记录ID
   */
  delete(id) {
    return request.apiPost('/api/user-service/fei/repair/record/delete', { id })
  }
 }
@@ -0,0 +1,81 @@
 import request from '@/utils/request'
 export default {
  /**
   * 分页查询电磁阀列表
   */
  page(pageIndex, pageSize, params) {
    const data = { pageIndex, pageSize, ...params }
    return request.apiPost('/api/user-service/fei/solenoid/valve/page', data)
  },
  /**
   * 查询电磁阀详情
   */
  detail(id) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/detail', { id })
  },
  /**
   * 新增电磁阀
   */
  add(data) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/add', data)
  },
  /**
   * 更新电磁阀
   */
  update(data) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/update', data)
  },
  /**
   * 删除电磁阀
   */
  delete(id) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/delete', { id })
  },
  /**
   * 开阀
   */
  openValve(id) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/open', { id })
  },
  /**
   * 关阀
   */
  closeValve(id) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/close', { id })
  },
  /**
   * 灌溉记录分页查询
   */
  logPage(params) {
    return request.apiGet('/api/user-service/fei/solenoid/valve/log/page', params)
  },
  /**
   * 删除灌溉记录
   */
  deleteLog(id) {
    return request.apiPost('/api/user-service/fei/solenoid/valve/log/delete', { id })
  },
  /**
   * 查询今日灌溉记录（大屏专用）
   */
  getTodayIrrigation(parkId) {
    return request.apiGet('/api/user-service/fei/solenoid/valve/log/today', { parkId })
  },
  /**
   * 查询最近30天灌溉趋势（大屏专用）
   */
  getIrrigationTrend(parkId) {
    return request.apiGet('/api/user-service/fei/solenoid/valve/log/trend', { parkId })
  }
 }
@@ -0,0 +1,55 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service'
 export default {
  // 分页查询设备列表
  getPage(params) {
    return request.apiGet(`${BASE_URL}/fertigation-device/page`, params)
  },
  // 查询设备详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/fertigation-device/detail`, { id })
  },
  // 新增设备
  add(data) {
    return request.apiPost(`${BASE_URL}/fertigation-device/add`, data)
  },
  // 编辑设备
  update(data) {
    return request.apiPost(`${BASE_URL}/fertigation-device/update`, data)
  },
  // 删除设备
  delete(id) {
    return request.apiPost(`${BASE_URL}/fertigation-device/delete`, { id })
  },
  // 加药操作
  dosing(data) {
    return request.apiPost(`${BASE_URL}/fertigation-device/dosing`, data)
  },
  // 查询加药日志
  getDosingLog(params) {
    return request.apiGet(`${BASE_URL}/fertigation-device/dosing-log`, params)
  },
  // 查询所有加药日志（包含设备和园区信息）
  getAllDosingLog(params) {
    return request.apiGet(`${BASE_URL}/fertigation-device/dosing-log/all`, params)
  },
  // 查询园区当天操作记录
  getTodayLogs(parkId, limit = 10) {
    return request.apiGet(`${BASE_URL}/fertigation-device/today-logs`, { parkId, limit })
  },
  // 保存设备页面布局配置（JSON）
  saveLayout(data) {
    return request.apiPost(`${BASE_URL}/fertigation-device/save-layout`, data)
  }
 }
@@ -0,0 +1,126 @@
 import request from '@/utils/request'
 class huobanTableApi {
  // Table Info CRUD
  async pageTableInfo(pageIndex, pageSize, name, tableId, spaceId) {
    let url = `/api/user-service/huoban/tableInfo/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (name) url += '&name=' + encodeURIComponent(name)
    if (tableId) url += '&tableId=' + tableId
    if (spaceId) url += '&spaceId=' + encodeURIComponent(spaceId)
    return await request.apiPost(url)
  }
  async saveTableInfo(data) {
    return await request.apiPost('/api/user-service/huoban/tableInfo/save', data)
  }
  async deleteTableInfo(tableId) {
    return await request.apiPost(`/api/user-service/huoban/tableInfo/delete?tableId=${tableId}`)
  }
  async listAllTableInfo() {
    return await request.apiGet('/api/user-service/huoban/tableInfo/listAll')
  }
  // Table Column CRUD
  async pageTableColumn(pageIndex, pageSize, tableId, name) {
    let url = `/api/user-service/huoban/tableColumn/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (tableId) url += '&tableId=' + tableId
    if (name) url += '&name=' + name
    return await request.apiPost(url)
  }
  async saveTableColumn(data) {
    return await request.apiPost('/api/user-service/huoban/tableColumn/save', data)
  }
  async deleteTableColumn(fieldId) {
    return await request.apiPost(`/api/user-service/huoban/tableColumn/delete?fieldId=${fieldId}`)
  }
  async listTableColumnByTable(tableId) {
    return await request.apiGet(`/api/user-service/huoban/tableColumn/listByTable?tableId=${tableId}`)
  }
  async spaceList() {
    return await request.apiGet('/api/user-service/huoban2/spaceList')
  }
  async syncTables(spaceId) {
    let url = '/api/user-service/huoban2/syncTables'
    if (spaceId) url += '?spaceId=' + spaceId
    return await request.apiGet(url)
  }
  async syncTableConfig(tableId) {
    return await request.apiGet('/api/user-service/huoban2/syncTableConfig?tableId=' + tableId)
  }
  // Huoban data query (POST /huoban2/data)
  async queryData(dataFilter) {
    return await request.apiPost('/api/user-service/huoban2/data', dataFilter)
  }
  // ========== Huoban Web API (带 token) ==========
  async webLogin(phone) {
    return await request.apiGet(`/api/user-service/huoban2/webLogin?phone=${encodeURIComponent(phone)}`)
  }
  async webData(dataFilter) {
    return await request.apiPost('/api/user-service/huoban2/webData', dataFilter)
  }
  async detail(itemId, tableId, tableName = '', relations = []) {
    let url = `/api/user-service/huoban2/detail?itemId=${itemId}&tableId=${tableId}`
    if (tableName) url += `&tableName=${encodeURIComponent(tableName)}`
    if (relations && relations.length) url += `&relations=${encodeURIComponent(JSON.stringify(relations))}`
    return await request.apiGet(url)
  }
  async webDetail({ itemId, tableId, tableName, relations }) {
    return await request.apiGet('/api/user-service/huoban2/webDetail', { itemId, tableId, tableName, relations })
  }
  // ========== Huoban Partner Cloud Data Operations ==========
  async create(data) {
    return await request.apiPost('/api/user-service/huoban2/create', data)
  }
  async update(data) {
    return await request.apiPost('/api/user-service/huoban2/update', data)
  }
  async upsetOne(data) {
    return await request.apiPost('/api/user-service/huoban2/upsetOne', data)
  }
  // ========== Huoban Form CRUD ==========
  async pageHuobanForm(pageIndex, pageSize, name, tableId, spaceId) {
    let url = `/api/user-service/huoban/form/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (name) url += '&name=' + name
    if (tableId) url += '&tableId=' + tableId
    if (spaceId) url += '&spaceId=' + spaceId
    return await request.apiPost(url)
  }
  async listAllHuobanForm() {
    return await request.apiGet('/api/user-service/huoban/form/listAll')
  }
  async saveHuobanForm(data) {
    return await request.apiPost('/api/user-service/huoban/form/save', data)
  }
  async deleteHuobanForm(id) {
    return await request.apiPost(`/api/user-service/huoban/form/delete?id=${id}`)
  }
  async detailHuobanForm(id) {
    return await request.apiGet(`/api/user-service/huoban/form/detail?id=${id}`)
  }
 }
 const target = new huobanTableApi()
 export default target
@@ -0,0 +1,36 @@
 import request from '@/utils/request'
 // 接口前缀：/api/user-service（通过代理已处理，前端直接添加即可）
 const BASE_URL = '/api/user-service'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/input-material/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/input-material/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/input-material/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/input-material/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/input-material/delete`, null, { params: { id } })
  },
  // 查询在用的投入品列表
  getActiveList() {
    return request.apiGet(`${BASE_URL}/input-material/active-list`)
  }
 }
@@ -0,0 +1,69 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/inspection'
 export default {
  // ========== 巡查项目配置 ==========
  // 分页查询巡查项目
  getItemPage(params) {
    return request.apiGet(`${BASE_URL}/item/page`, params)
  },
  // 查询巡查项目详情
  getItemDetail(id) {
    return request.apiGet(`${BASE_URL}/item/detail`, { id })
  },
  // 新增巡查项目
  addItem(data) {
    return request.apiPost(`${BASE_URL}/item/add`, data)
  },
  // 编辑巡查项目
  updateItem(data) {
    return request.apiPost(`${BASE_URL}/item/update`, data)
  },
  // 删除巡查项目
  deleteItem(id) {
    return request.apiPost(`${BASE_URL}/item/delete`, null, { params: { id } })
  },
  // 获取启用的巡查项目列表
  listItemEnabled() {
    return request.apiGet(`${BASE_URL}/item/listEnabled`)
  },
  // ========== 巡查记录 ==========
  // 分页查询巡查记录
  getRecordPage(params) {
    return request.apiGet(`${BASE_URL}/record/page`, params)
  },
  // 查询巡查记录详情
  getRecordDetail(id) {
    return request.apiGet(`${BASE_URL}/record/detail`, { id })
  },
  // 新增巡查记录
  addRecord(data) {
    return request.apiPost(`${BASE_URL}/record/add`, data)
  },
  // 编辑巡查记录
  updateRecord(data) {
    return request.apiPost(`${BASE_URL}/record/update`, data)
  },
  // 删除巡查记录
  deleteRecord(id) {
    return request.apiPost(`${BASE_URL}/record/delete`, null, { params: { id } })
  },
  // 确认巡查记录
  confirmRecord(id, confirmBy) {
    return request.apiPost(`${BASE_URL}/record/confirm`, { id, confirmBy })
  }
 }
@@ -0,0 +1,88 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service'
 export default {
  // ==================== 灌溉计划管理 ====================
  // 分页查询灌溉计划列表
  getPlanPage(params) {
    return request.apiGet(`${BASE_URL}/irrigation/plan/page`, params)
  },
  // 查询灌溉计划详情
  getPlanDetail(id) {
    return request.apiGet(`${BASE_URL}/irrigation/plan/detail`, { id })
  },
  // 新增灌溉计划
  addPlan(data) {
    return request.apiPost(`${BASE_URL}/irrigation/plan/add`, data)
  },
  // 修改灌溉计划
  updatePlan(data) {
    return request.apiPost(`${BASE_URL}/irrigation/plan/update`, data)
  },
  // 删除灌溉计划
  deletePlan(id) {
    return request.apiPost(`${BASE_URL}/irrigation/plan/delete?id=${id}`)
  },
  // 启用/暂停灌溉计划
  togglePlan(id, status) {
    return request.apiPost(`${BASE_URL}/irrigation/plan/toggle`, null, { params: { id, status } })
  },
  // 根据园区ID查询灌溉计划列表
  listPlanByPark(parkId) {
    return request.apiGet(`${BASE_URL}/irrigation/plan/listByPark`, { parkId })
  },
  // ==================== 执行记录管理 ====================
  // 分页查询执行记录列表
  getExecPage(params) {
    return request.apiGet(`${BASE_URL}/irrigation/exec/page`, params)
  },
  // 查询执行记录详情（含阀门明细）
  getExecDetail(id) {
    return request.apiGet(`${BASE_URL}/irrigation/exec/detail`, { id })
  },
  // 创建执行记录
  createExec(data) {
    return request.apiPost(`${BASE_URL}/irrigation/exec/create`, data)
  },
  // 更新执行状态
  updateExecStatus(id, status, failReason) {
    return request.apiPost(`${BASE_URL}/irrigation/exec/updateStatus`, null, { 
      params: { id, status, failReason } 
    })
  },
  // 完成执行记录
  completeExec(id, actualWater, actualDuration) {
    return request.apiPost(`${BASE_URL}/irrigation/exec/complete`, null, { 
      params: { id, actualWater, actualDuration } 
    })
  },
  // 取消执行记录
  cancelExec(id) {
    return request.apiPost(`${BASE_URL}/irrigation/exec/cancel`, null, { params: { id } })
  },
  // 根据计划ID查询执行记录列表
  listExecByPlan(planId) {
    return request.apiGet(`${BASE_URL}/irrigation/exec/listByPlan`, { planId })
  },
  // 查询待执行的记录列表
  listPendingExec() {
    return request.apiGet(`${BASE_URL}/irrigation/exec/pending`)
  }
 }
@@ -0,0 +1,120 @@
 import request from '@/utils/request'
 export default {
  // 获取所有 Agent 列表（用于下拉选择）
  list() {
    return request.apiGet('/api/user-service/llmAgent/list')
  },
  // 通用请求方法（用于对话接口）
  request(url, data) {
    return request.apiPost(`/api/user-service${url}`, data, {}, 10 * 60 * 1000)
  },
  // 分页查询
  pageAgent(data) {
    return request.apiPost('/api/user-service/llmAgent/page', data)
  },
  // 新增
  addAgent(data) {
    return request.apiPost('/api/user-service/llmAgent/add', data)
  },
  // 编辑
  updateAgent(data) {
    return request.apiPost('/api/user-service/llmAgent/update', data)
  },
  // 删除
  deleteAgent(data) {
    return request.apiPost('/api/user-service/llmAgent/delete', data)
  },
  // 切换状态
  toggleStatus(data) {
    return request.apiPost('/api/user-service/llmAgent/toggleStatus', data)
  },
  // 获取详情
  getDetail(id) {
    return request.apiGet(`/api/user-service/llmAgent/detail/${id}`)
  },
  /**
   * 调用大模型接口（超时时间 10 分钟）
   * @param {number|string} agentId - Agent ID
   * @param {object} data - 请求参数
   * @param {object} data.userParams - 用户参数对象
   * @param {string} data.userParams.input - 用户输入文本
   * @param {string[]} [data.userParams.imageUrls] - 图片 URL 数组
   * @param {string[]} [data.userParams.videoUrls] - 视频 URL 数组
   * @param {string} [data.userParams.userPrompt] - 用户自定义提示词
   * @param {string} [data.userParams.imageUrl] - 单张图片 URL（用于身份证识别等场景）
   * @example
   * // AI Helper 组件调用示例
   * callAgent(5, {
   *   userParams: {
   *     input: '帮我写一篇文章',
   *     imageUrls: ['https://example.com/img1.jpg'],
   *     videoUrls: [],
   *     userPrompt: '请使用正式的语言'
   *   }
   * })
   * @example
   * // 身份证识别调用示例
   * callAgent(6, {
   *   userParams: {
   *     input: '识别',
   *     imageUrl: 'https://example.com/idcard.jpg'
   *   }
   * })
   */
  callAgent(agentId, data) {
    return request.apiPost(`/api/user-service/llmAgent/call/${agentId}`, data, {}, 10 * 60 * 1000)
  },
  // 调试 Agent（已废弃，保留兼容）
  debugAgent(data) {
    return request.apiPost('/api/user-service/llmAgent/debug', data)
  },
  // ========== 多轮对话 ==========
  // 开始新对话
  startChat(data) {
    return request.apiPost('/api/user-service/llmChat/start', data, {}, 10 * 60 * 1000)
  },
  // 继续对话
  continueChat(data) {
    return request.apiPost('/api/user-service/llmChat/continue', data, {}, 10 * 60 * 1000)
  },
  // ========== 调用日志 ==========
  // 分页查询调用日志
  pageCallLog(data) {
    return request.apiPost('/api/user-service/llmCallLog/page', data)
  },
  // 获取调用日志详情
  getCallLogDetail(id) {
    return request.apiGet(`/api/user-service/llmCallLog/detail/${id}`)
  },
  // 删除调用日志
  deleteCallLog(id) {
    return request.apiPost('/api/user-service/llmCallLog/delete', { id })
  },
  // 批量删除调用日志
  batchDeleteCallLog(ids) {
    return request.apiPost('/api/user-service/llmCallLog/batchDelete', { ids })
  },
  // 统计信息
  callLogStatistics(data) {
    return request.apiPost('/api/user-service/llmCallLog/statistics', data)
  }
 }
@@ -0,0 +1,43 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/llmAgentSkill'
 export default {
  // 查询Agent关联的Skill列表
  // GET /llmAgentSkill/listByAgent?agentId=
  listByAgent(agentId) {
    return request.apiGet(`${BASE_URL}/listByAgent`, { agentId })
  },
  // 查询Skill关联的Agent列表
  // GET /llmAgentSkill/listBySkill?skillId=
  listBySkill(skillId) {
    return request.apiGet(`${BASE_URL}/listBySkill`, { skillId })
  },
  // 新增关联
  // POST /llmAgentSkill/add
  // Body: {"agentId": 1, "skillId": 1, "sortOrder": 0}
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 删除关联
  // POST /llmAgentSkill/delete?id=
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete?id=${id}`)
  },
  // 根据Agent删除所有关联
  // POST /llmAgentSkill/deleteByAgent?agentId=
  deleteByAgent(agentId) {
    return request.apiPost(`${BASE_URL}/deleteByAgent?agentId=${agentId}`)
  },
  // 批量添加关联
  // POST /llmAgentSkill/batchAdd?agentId=
  // Body: [1, 2, 3] (Skill ID数组)
  batchAdd(agentId, skillIds) {
    return request.apiPostJson(`${BASE_URL}/batchAdd?agentId=${agentId}`, skillIds)
  }
 }
@@ -0,0 +1,43 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/llmAgentTool'
 export default {
  // 查询Agent关联的工具列表
  // GET /llmAgentTool/listByAgent?agentId=
  listByAgent(agentId) {
    return request.apiGet(`${BASE_URL}/listByAgent`, { agentId })
  },
  // 查询工具关联的Agent列表
  // GET /llmAgentTool/listByTool?toolId=
  listByTool(toolId) {
    return request.apiGet(`${BASE_URL}/listByTool`, { toolId })
  },
  // 新增关联
  // POST /llmAgentTool/add
  // Body: {"agentId": 1, "toolId": 1}
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 删除关联
  // POST /llmAgentTool/delete?id=
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete?id=${id}`)
  },
  // 根据Agent删除所有关联
  // POST /llmAgentTool/deleteByAgent?agentId=
  deleteByAgent(agentId) {
    return request.apiPost(`${BASE_URL}/deleteByAgent?agentId=${agentId}`)
  },
  // 批量添加关联
  // POST /llmAgentTool/batchAdd?agentId=
  // Body: [1, 2, 3] (工具ID数组)
  batchAdd(agentId, toolIds) {
    return request.apiPostJson(`${BASE_URL}/batchAdd?agentId=${agentId}`, toolIds)
  }
 }
@@ -0,0 +1,28 @@
 import request from '@/utils/request'
 export default {
  // 获取会话列表
  listByAgent(agentId) {
    return request.apiGet(`/api/user-service/llmConversation/listByAgent?agentId=${agentId}`)
  },
  // 获取会话详情
  getDetail(id) {
    return request.apiGet(`/api/user-service/llmConversation/detail/${id}`)
  },
  // 获取会话消息列表
  listMessages(conversationId) {
    return request.apiGet(`/api/user-service/llmConversation/messages?conversationId=${conversationId}`)
  },
  // 删除会话
  delete(id) {
    return request.apiPost('/api/user-service/llmConversation/delete', { id })
  },
  // 删除消息
  deleteMessage(id) {
    return request.apiPost('/api/user-service/llmConversation/deleteMessage', { id })
  }
 }
@@ -0,0 +1,56 @@
 import request from '@/utils/request'
 export default {
  async pageProvider(data) {
    return await request.apiPost('/api/user-service/llmProvider/page', data)
  },
  async addProvider(data) {
    return await request.apiPost('/api/user-service/llmProvider/add', data)
  },
  async updateProvider(data) {
    return await request.apiPost('/api/user-service/llmProvider/update', data)
  },
  async deleteProvider(id) {
    return await request.apiPost('/api/user-service/llmProvider/delete', { id })
  },
  async getProviderDetail(id) {
    return await request.apiGet('/api/user-service/llmProvider/detail', { id })
  },
  async toggleProviderStatus(id, status) {
    return await request.apiPost('/api/user-service/llmProvider/toggleStatus', { id, status })
  },
  async listProviders() {
    return await request.apiGet('/api/user-service/llmProvider/list', {})
  },
  // Model APIs
  async pageModel(data) {
    return await request.apiPost('/api/user-service/llmModel/page', data)
  },
  async addModel(data) {
    return await request.apiPost('/api/user-service/llmModel/add', data)
  },
  async updateModel(data) {
    return await request.apiPost('/api/user-service/llmModel/update', data)
  },
  async deleteModel(id) {
    return await request.apiPost('/api/user-service/llmModel/delete', { id })
  },
  async toggleModelStatus(id, status) {
    return await request.apiPost('/api/user-service/llmModel/toggleStatus', { id, status })
  },
  async listModelsByVendor(vendorCode) {
    return await request.apiGet('/api/user-service/llmModel/list', { vendorCode })
  }
 }
@@ -0,0 +1,35 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/llmTool'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete?id=${id}`)
  },
  // 执行工具
  execute(data) {
    return request.apiPost(`${BASE_URL}/execute`, data)
  },
  // 清除缓存（toolKey可选，不传则清除全部）
  clearCache(toolKey) {
    const query = toolKey ? `?toolKey=${encodeURIComponent(toolKey)}` : ''
    return request.apiPost(`${BASE_URL}/clearCache${query}`)
  }
 }
@@ -0,0 +1,26 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/llmToolLog'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 编辑
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete?id=${id}`)
  }
 }
@@ -0,0 +1,79 @@
 import router from '@/router/index'
 import userApi from '@/api/user'
 import store from '@/store/index'
 // 构建 views 下所有 .vue 文件的映射（小写路径 -> 实际路径），解决大小写不一致问题
 const viewsRequire = require.context('@/views', true, /\.vue$/)
 const viewPathMap = {}
 viewsRequire.keys().forEach(key => {
  // key 形如 './system/llmModel/index.vue'
  const normalized = key.replace(/^\.\//, '').replace(/\.vue$/, '').toLowerCase()
  viewPathMap[normalized] = key
 })
 class menuApi {
  /**
   * 初始化路由（不再加载全局菜单，菜单由各应用切换时按需加载）
   */
  async initMenu() {
    return router
  }
  /**
   * 注册应用菜单的动态路由
   * @param {Array} menuList - 菜单树
   */
  handleMenu(menuList) {
    menuList.forEach(menu => {
      // Use a separate field for route registration so we don't mutate the original menuPath
      // which is needed for pathMap matching in main.js and sidebar navigation
      if (menu.menuType === 4) {
        menu.frameUrl = menu.menuPath
        menu.menuRoutePath = '/common/web/' + menu.id
        router.addRoute('common', {
          path: 'web/' + menu.id,
          name: 'web_' + menu.id,
          frameUrl: menu.frameUrl,
          component: () => import('@/views/web/index'),
          meta: { title: menu.menuTitle, icon: '', keepAlive: true, menu: menu }
        })
      }
      if (menu.menuType === 3) {
        menu.frameUrl = menu.menuPath
        menu.menuRoutePath = '/common/payment/' + menu.id
        router.addRoute('common', {
          path: 'payment/' + menu.id,
          name: 'payment_' + menu.id,
          component: () => import('@/views/payment/index'),
          meta: { title: menu.menuTitle, icon: '', keepAlive: true, menu: menu }
        })
      }
      if (menu.menuType === 2) {
        menu.frameUrl = menu.menuPath
        menu.menuRoutePath = '/common/huoban/' + menu.id
        router.addRoute('common', {
          path: 'huoban/' + menu.id,
          name: 'huoban_' + menu.id,
          frameUrl: menu.frameUrl,
          component: () => import('@/views/huoban/index'),
          meta: { title: menu.menuTitle, icon: '', keepAlive: true, menu: menu }
        })
      }
      if (menu.menuType === 1) {
        router.addRoute('common', {
          path: menu.menuPath,
          name: menu.vueName,
          component: (resolve) => require([`@/views/${menu.vuePath}`], resolve),
          meta: { title: menu.menuTitle, icon: '', keepAlive: true, menuId: menu.id, menuType: menu.menuType }
        })
      }
      if (menu.child) {
        this.handleMenu(menu.child)
      }
    })
  }
 }
 const target = new menuApi()
 export default target
@@ -0,0 +1,16 @@
 import request from '@/utils/request'
 class n8nApi {
  /**
   * 调用 n8n webhook：伙伴表数据同步+填充
   * @param {string} spaceId - 空间ID
   * @param {string} tableId - 表格ID
   */
  async huobanTableSyncAndFill(spaceId, tableId) {
    const url = `/n8n/webhook/4dad745d-c71d-4668-81a3-33bf350730ff?spaceId=${encodeURIComponent(spaceId)}&tableId=${encodeURIComponent(tableId)}`
    return await request.apiGet(url)
  }
 }
 const target = new n8nApi()
 export default target
@@ -0,0 +1,43 @@
 import request from '@/utils/request'
 class organizationApi {
  // 查询组织列表（树形）
  static pageOrganizations(orgName) {
    let url = '/api/user-service/organization/page'
    if (orgName) url += '?orgName=' + orgName
    return request.apiPost(url)
  }
  // 查询组织树
  static getOrganizationTree() {
    return request.apiGet('/api/user-service/organization/tree')
  }
  // 查询组织详情
  static getDetail(id) {
    return request.apiGet(`/api/user-service/organization/detail?id=${id}`)
  }
  // 新增组织
  static addOrganization(data) {
    return request.apiPost('/api/user-service/organization/add', data)
  }
  // 更新组织
  static updateOrganization(data) {
    return request.apiPost('/api/user-service/organization/update', data)
  }
  // 删除组织
  static deleteOrganization(id) {
    return request.apiPost(`/api/user-service/organization/delete?id=${id}`)
  }
  // 查询所有启用的组织
  static listAllOrganizations() {
    return request.apiGet('/api/user-service/organization/listAll')
  }
 }
 export default organizationApi
@@ -0,0 +1,55 @@
 import request from '@/utils/request'
 export default {
  async pagePackagePlan(data) {
    return await request.apiPost('/api/user-service/packagePlan/page', data)
  },
  async addPackagePlan(data) {
    return await request.apiPost('/api/user-service/packagePlan/add', data)
  },
  async updatePackagePlan(data) {
    return await request.apiPost('/api/user-service/packagePlan/update', data)
  },
  async deletePackagePlan(id) {
    return await request.apiPost('/api/user-service/packagePlan/delete', { id })
  },
  async getPackagePlanDetail(id) {
    return await request.apiGet('/api/user-service/packagePlan/detail', { id })
  },
  async toggleStatus(id, status) {
    return await request.apiPost('/api/user-service/packagePlan/toggleStatus', { id, status })
  },
  async getPlanPermissions(planId) {
    return await request.apiGet('/api/user-service/packagePlan/getPermissions', { planId })
  },
  async savePermissions(data) {
    return await request.apiPost('/api/user-service/packagePlan/savePermissions', data)
  },
  async getPlanQuotas(planId) {
    return await request.apiGet('/api/user-service/packagePlan/getQuotas', { planId })
  },
  async getAllQuotas(planId) {
    return await request.apiGet('/api/user-service/packagePlan/getAllQuotas', { planId })
  },
  async savePlanQuotas(data) {
    return await request.apiPost('/api/user-service/packagePlan/saveQuotas', data)
  },
  async getPlanApps(planId) {
    return await request.apiGet('/api/user-service/packagePlan/getPlanApps', { planId })
  },
  async getCustomerPackageOverview(data) {
    return await request.apiPost('/api/user-service/customerPackage/overview', data)
  }
 }
@@ -0,0 +1,36 @@
 import request from '@/utils/request'
 // 接口前缀：/api/user-service（通过代理已处理，前端直接添加即可）
 const BASE_URL = '/api/user-service'
 export default {
  // 分页查询园区列表
  getPage(params) {
    return request.apiGet(`${BASE_URL}/park/page`, params)
  },
  // 查询园区详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/park/detail`, { id })
  },
  // 新增园区
  add(data) {
    return request.apiPost(`${BASE_URL}/park/add`, data)
  },
  // 编辑园区
  update(data) {
    return request.apiPost(`${BASE_URL}/park/update`, data)
  },
  // 删除园区
  delete(id) {
    return request.apiPost(`${BASE_URL}/park/delete`, { id })
  },
  // 查询所有园区列表（用于下拉选择）
  getAllParks() {
    return request.apiGet(`${BASE_URL}/park/list`, {})
  }
 }
@@ -0,0 +1,105 @@
 import request from '@/utils/request'
 import { TRACING_OPEN_KEY } from '@/config/tracingOpenKey'
 class permissionApi {
  async saveMenu(params) {
    return await request.apiPost('/api/user-service/permission/saveMenu', params)
  }
  async getAllMenu(params) {
    return await request.apiGet('/api/user-service/permission/getAllMenu?appName=' + params)
  }
  async savePermission(params) {
    return await request.apiPost('/api/user-service/permission/savePermission', params)
  }
  async getAllPermission(params) {
    return await request.apiGet('/api/user-service/permission/getAllPermission?appName=' + params)
  }
  async getPlanPermissionTree(planId, appName) {
    return await request.apiGet('/api/user-service/permission/getPlanPermissionTree?planId=' + planId + '&appName=' + appName)
  }
  async getAllRole(params) {
    return await request.apiPost('/api/user-service/permission/getAllRole', params)
  }
  async saveRole(params) {
    return await request.apiPost('/api/user-service/permission/saveRole', params)
  }
  async deleteRole(params) {
    return await request.apiPost('/api/user-service/permission/deleteRole', params)
  }
  async setRolePermission(params) {
    return await request.apiPost('/api/user-service/permission/setRolePermission', params)
  }
  async getRolePermission(params) {
    return await request.apiGet('/api/user-service/permission/getRolePermission?roleId=' + params)
  }
  async setMemberRole(params) {
    return await request.apiPost('/api/user-service/permission/setMemberRole', params)
  }
  async getMemberAvailableRoles() {
    return await request.apiGet('/api/user-service/permission/getMemberAvailableRoles')
  }
  async getMemberAssignedRoles(userId) {
    return await request.apiGet('/api/user-service/permission/getMemberAssignedRoles?userId=' + userId)
  }
  async setMemberRolesByCustomer(params) {
    return await request.apiPost('/api/user-service/permission/setMemberRolesByCustomer', params)
  }
  async getHuoBanUrl(menuId) {
    return await request.apiGet('/api/user-service/permission/getHuoBanUrl?menuId=' + menuId)
  }
  async getMenu(menuId) {
    return await request.apiGet('/api/user-service/permission/getMenu?menuId=' + menuId)
  }
  async getPaymentMenu(menuId) {
    return await request.apiGet('/api/user-service/permission/getPaymentMenu?menuId=' + menuId)
  }
  async changePaymentGroup(group){
    return await request.apiGet('/api/user-service/permission/changePaymentGroup?group=' + group)
  }
  async deletePermission(params) {
    return await request.apiPost('/api/user-service/permission/deletePermission', params)
  }
  async deleteMenu(params) {
    return await request.apiPost('/api/user-service/permission/deleteMenu', params)
  }
  async getMyPermissionCodes() {
    return await request.apiGet('/api/user-service/permission/getMyPermissionCodes')
  }
  /** 按当前登录企业获取伙伴云 token（企业隔离） */
  async getHuobanToken() {
    return await request.apiGet('/api/user-service/permission/getHuobanToken')
  }
  /** 开放平台：按企业 ID 查询溯源追踪配置（无需登录，使用 open-key） */
  async getTrackingConfigByCustomerId(customerId) {
    return await request.apiGet(
      '/api/user-service/open/trackingConfig/getByCustomerId',
      { customerId },
      { 'open-key': TRACING_OPEN_KEY }
    )
  }
 }
 const target = new permissionApi()
 export default target
@@ -0,0 +1,23 @@
 import request from '@/utils/request'
 export default {
  async pageQuota(data) {
    return await request.apiPost('/api/user-service/quota/page', data)
  },
  async addQuota(data) {
    return await request.apiPost('/api/user-service/quota/add', data)
  },
  async updateQuota(data) {
    return await request.apiPost('/api/user-service/quota/update', data)
  },
  async deleteQuota(id) {
    return await request.apiPost('/api/user-service/quota/delete', { id })
  },
  async getQuotaDetail(id) {
    return await request.apiGet('/api/user-service/quota/detail', { id })
  }
 }
@@ -0,0 +1,30 @@
 import request from '@/utils/request'
 const BASE_URL = '/api/user-service/trace/floorPlan'
 export default {
  // 分页查询
  getPage(params) {
    return request.apiGet(`${BASE_URL}/page`, params)
  },
  // 查询详情
  getDetail(id) {
    return request.apiGet(`${BASE_URL}/detail`, { id })
  },
  // 新增
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 更新
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除
  delete(id) {
    return request.apiPost(`${BASE_URL}/delete`, { id })
  }
 }
@@ -0,0 +1,627 @@
 import request from '@/utils/request'
 class traceabilityApi {
  // ========== 品类管理 ==========
  static pageCategories(pageIndex = 1, pageSize = 20, categoryName) {
    let url = `/api/user-service/trace/category/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (categoryName) url += '&categoryName=' + categoryName
    return request.apiPost(url)
  }
  static getCategoryDetail(id) {
    return request.apiGet(`/api/user-service/trace/category/detail?id=${id}`)
  }
  static addCategory(data) {
    return request.apiPost('/api/user-service/trace/category/add', data)
  }
  static updateCategory(data) {
    return request.apiPost('/api/user-service/trace/category/update', data)
  }
  static deleteCategory(id) {
    return request.apiPost(`/api/user-service/trace/category/delete?id=${id}`)
  }
  static enableCategory(id) {
    return request.apiPost(`/api/user-service/trace/category/enable?id=${id}`)
  }
  static disableCategory(id) {
    return request.apiPost(`/api/user-service/trace/category/disable?id=${id}`)
  }
  static listAllCategories() {
    return request.apiGet('/api/user-service/trace/category/listAll')
  }
  // ========== 产品管理 ==========
  static pageProducts(pageIndex = 1, pageSize = 20, categoryId, productName) {
    let url = `/api/user-service/trace/category/product/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (categoryId) url += '&categoryId=' + categoryId
    if (productName) url += '&productName=' + productName
    return request.apiPost(url)
  }
  static getProductDetail(id) {
    return request.apiGet(`/api/user-service/trace/category/product/detail?id=${id}`)
  }
  static addProduct(data) {
    return request.apiPost('/api/user-service/trace/category/product/add', data)
  }
  static updateProduct(data) {
    return request.apiPost('/api/user-service/trace/category/product/update', data)
  }
  static deleteProduct(id) {
    return request.apiPost(`/api/user-service/trace/category/product/delete?id=${id}`)
  }
  static enableProduct(id) {
    return request.apiPost(`/api/user-service/trace/category/product/enable?id=${id}`)
  }
  static disableProduct(id) {
    return request.apiPost(`/api/user-service/trace/category/product/disable?id=${id}`)
  }
  static listProductsByCategory(categoryId) {
    let url = '/api/user-service/trace/category/product/listByCategory'
    if (categoryId) url += '?categoryId=' + categoryId
    return request.apiGet(url)
  }
  // ========== 地块管理 ==========
  static pageLands(pageIndex = 1, pageSize = 20, landName, status) {
    let url = `/api/user-service/trace/land/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (landName) url += '&landName=' + landName
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getLandDetail(id) {
    return request.apiGet(`/api/user-service/trace/land/detail?id=${id}`)
  }
  static addLand(data) {
    return request.apiPost('/api/user-service/trace/land/add', data)
  }
  static updateLand(data) {
    return request.apiPost('/api/user-service/trace/land/update', data)
  }
  static deleteLand(id) {
    return request.apiPost(`/api/user-service/trace/land/delete?id=${id}`)
  }
  static listAllLands() {
    return request.apiGet('/api/user-service/trace/land/listAll')
  }
  // ========== 采收批次 ==========
  static pageHarvests(pageIndex = 1, pageSize = 20, batchCode, landId, status) {
    let url = `/api/user-service/trace/harvest/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (batchCode) url += '&batchCode=' + batchCode
    if (landId) url += '&landId=' + landId
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getHarvestDetail(id) {
    return request.apiGet(`/api/user-service/trace/harvest/detail?id=${id}`)
  }
  static addHarvest(data) {
    return request.apiPost('/api/user-service/trace/harvest/add', data)
  }
  static updateHarvest(data) {
    return request.apiPost('/api/user-service/trace/harvest/update', data)
  }
  static deleteHarvest(id) {
    return request.apiPost(`/api/user-service/trace/harvest/delete?id=${id}`)
  }
  static updateHarvestStatus(id, status) {
    return request.apiPost(`/api/user-service/trace/harvest/updateStatus?id=${id}&status=${status}`)
  }
  // ========== 加工记录 ==========
  static pageProcesses(pageIndex = 1, pageSize = 20, processCode, status) {
    let url = `/api/user-service/trace/process/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (processCode) url += '&processCode=' + processCode
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getProcessDetail(id) {
    return request.apiGet(`/api/user-service/trace/process/detail?id=${id}`)
  }
  static addProcess(data) {
    return request.apiPost('/api/user-service/trace/process/add', data)
  }
  static updateProcess(data) {
    return request.apiPost('/api/user-service/trace/process/update', data)
  }
  static completeProcess(id) {
    return request.apiPost(`/api/user-service/trace/process/complete?id=${id}`)
  }
  static discardProcess(id) {
    return request.apiPost(`/api/user-service/trace/process/discard?id=${id}`)
  }
  static deleteProcess(id) {
    return request.apiPost(`/api/user-service/trace/process/delete?id=${id}`)
  }
  // ========== 质量检测 ==========
  static pageQualities(pageIndex = 1, pageSize = 20, testCode, batchType, status) {
    let url = `/api/user-service/trace/quality/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (testCode) url += '&testCode=' + testCode
    if (batchType != null) url += '&batchType=' + batchType
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getQualityDetail(id) {
    return request.apiGet(`/api/user-service/trace/quality/detail?id=${id}`)
  }
  static addQuality(data) {
    return request.apiPost('/api/user-service/trace/quality/add', data)
  }
  static updateQuality(data) {
    return request.apiPost('/api/user-service/trace/quality/update', data)
  }
  static deleteQuality(id) {
    return request.apiPost(`/api/user-service/trace/quality/delete?id=${id}`)
  }
  static reviewQuality(id, comprehensiveResult, reviewComment) {
    return request.apiPost(`/api/user-service/trace/quality/review?id=${id}&comprehensiveResult=${comprehensiveResult}&reviewComment=${reviewComment || ''}`)
  }
  // ========== 溯源码生成任务 ==========
  static pageCodeTasks(pageIndex = 1, pageSize = 20, batchCode, status) {
    let url = `/api/user-service/trace/code/task/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (batchCode) url += '&batchCode=' + batchCode
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getCodeTaskDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/task/detail?id=${id}`)
  }
  static addCodeTask(data) {
    return request.apiPost('/api/user-service/trace/code/task/add', data)
  }
  static generateBatchCode() {
    return request.apiPost('/api/user-service/trace/code/task/generateBatchCode')
  }
  static updateCodeTask(data) {
    return request.apiPost('/api/user-service/trace/code/task/update', data)
  }
  static deleteCodeTask(id) {
    return request.apiPost(`/api/user-service/trace/code/task/delete?id=${id}`)
  }
  static generateCodes(id) {
    return request.apiPost(`/api/user-service/trace/code/task/generate?taskId=${id}`)
  }
  // ========== 溯源码列表 ==========
  static pageCodes(pageIndex = 1, pageSize = 20, codeValue, batchCode, status) {
    let url = `/api/user-service/trace/code/list/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (codeValue) url += '&codeValue=' + codeValue
    if (batchCode) url += '&batchCode=' + batchCode
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getCodeDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/list/detail?id=${id}`)
  }
  static voidCode(id, reason) {
    return request.apiPost(`/api/user-service/trace/code/list/void?id=${id}&reason=${reason || ''}`)
  }
  // ========== 码货绑定 ==========
  static pageBinds(pageIndex = 1, pageSize = 20, codeValue, batchCode, packageNo) {
    let url = `/api/user-service/trace/code/bind/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (codeValue) url += '&codeValue=' + codeValue
    if (batchCode) url += '&batchCode=' + batchCode
    if (packageNo) url += '&packageNo=' + packageNo
    return request.apiPost(url)
  }
  static getBindDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/bind/detail?id=${id}`)
  }
  static addBind(data) {
    return request.apiPost('/api/user-service/trace/code/bind/add', data)
  }
  static listUnboundCodes(batchCode) {
    return request.apiPost(`/api/user-service/trace/code/bind/unboundList${batchCode ? '?batchCode=' + batchCode : ''}`)
  }
  static unbind(id) {
    return request.apiPost(`/api/user-service/trace/code/bind/unbind?id=${id}`)
  }
  static batchImportBind(data) {
    return request.apiPost('/api/user-service/trace/code/bind/batchImport', data)
  }
  // ========== 父子码关联 ==========
  static pageRelations(pageIndex = 1, pageSize = 20, parentCode, childCode) {
    let url = `/api/user-service/trace/code/relation/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (parentCode) url += '&parentCode=' + parentCode
    if (childCode) url += '&childCode=' + childCode
    return request.apiPost(url)
  }
  static getRelationDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/relation/detail?id=${id}`)
  }
  static addRelation(data) {
    return request.apiPost('/api/user-service/trace/code/relation/add', data)
  }
  static deleteRelation(id) {
    return request.apiPost(`/api/user-service/trace/code/relation/delete?id=${id}`)
  }
  // ========== 赋码审计 ==========
  static pageAudits(pageIndex = 1, pageSize = 20, batchCode, auditType) {
    let url = `/api/user-service/trace/code/audit/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (batchCode) url += '&batchCode=' + batchCode
    if (auditType != null) url += '&auditType=' + auditType
    return request.apiPost(url)
  }
  static getAuditDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/audit/detail?id=${id}`)
  }
  // ========== 废码异常 ==========
  static pageExceptions(pageIndex = 1, pageSize = 20, codeValue, status) {
    let url = `/api/user-service/trace/code/exception/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (codeValue) url += '&codeValue=' + codeValue
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getExceptionDetail(id) {
    return request.apiGet(`/api/user-service/trace/code/exception/detail?id=${id}`)
  }
  static addException(data) {
    return request.apiPost('/api/user-service/trace/code/exception/add', data)
  }
  static handleException(id, handleMethod, handleRemark) {
    return request.apiPost(`/api/user-service/trace/code/exception/handle?id=${id}&handleMethod=${handleMethod}&handleRemark=${handleRemark || ''}`)
  }
  static deleteException(id) {
    return request.apiPost(`/api/user-service/trace/code/exception/delete?id=${id}`)
  }
  // ========== 入库管理 ==========
  static pageInRecords(pageIndex = 1, pageSize = 20, inCode, inType, warehouse, status) {
    let url = `/api/user-service/trace/warehouse/in/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (inCode) url += '&inCode=' + inCode
    if (inType != null) url += '&inType=' + inType
    if (warehouse) url += '&warehouse=' + warehouse
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getInDetail(id) {
    return request.apiGet(`/api/user-service/trace/warehouse/in/detail?id=${id}`)
  }
  static addInRecord(data) {
    return request.apiPost('/api/user-service/trace/warehouse/in/add', data)
  }
  static updateInRecord(data) {
    return request.apiPost('/api/user-service/trace/warehouse/in/update', data)
  }
  static deleteInRecord(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/in/delete?id=${id}`)
  }
  static confirmIn(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/in/confirm?id=${id}`)
  }
  static generateInBatchCode() {
    return request.apiGet('/api/user-service/trace/warehouse/in/generateBatchCode')
  }
  static listInDetails(inId) {
    return request.apiGet(`/api/user-service/trace/warehouse/in/detail/list?inId=${inId}`)
  }
  static addInDetail(data) {
    return request.apiPost('/api/user-service/trace/warehouse/in/detail/add', data)
  }
  static updateInDetail(data) {
    return request.apiPost('/api/user-service/trace/warehouse/in/detail/update', data)
  }
  static deleteInDetail(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/in/detail/delete?id=${id}`)
  }
  // ========== 出库管理 ==========
  static pageOutRecords(pageIndex = 1, pageSize = 20, outCode, outType, destination, status) {
    let url = `/api/user-service/trace/warehouse/out/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (outCode) url += '&outCode=' + outCode
    if (outType != null) url += '&outType=' + outType
    if (destination) url += '&destination=' + destination
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getOutDetail(id) {
    return request.apiGet(`/api/user-service/trace/warehouse/out/detail?id=${id}`)
  }
  static addOutRecord(data) {
    return request.apiPost('/api/user-service/trace/warehouse/out/add', data)
  }
  static updateOutRecord(data) {
    return request.apiPost('/api/user-service/trace/warehouse/out/update', data)
  }
  static deleteOutRecord(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/out/delete?id=${id}`)
  }
  static confirmOut(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/out/confirm?id=${id}`)
  }
  static generateOutBatchCode() {
    return request.apiGet('/api/user-service/trace/warehouse/out/generateBatchCode')
  }
  static listOutDetails(outId) {
    return request.apiGet(`/api/user-service/trace/warehouse/out/detail/list?outId=${outId}`)
  }
  static addOutDetail(data) {
    return request.apiPost('/api/user-service/trace/warehouse/out/detail/add', data)
  }
  static updateOutDetail(data) {
    return request.apiPost('/api/user-service/trace/warehouse/out/detail/update', data)
  }
  static deleteOutDetail(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/out/detail/delete?id=${id}`)
  }
  // ========== 库存管理 ==========
  static pageInventory(pageIndex = 1, pageSize = 20, batchCode, productName, warehouse) {
    let url = `/api/user-service/trace/warehouse/inventory/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (batchCode) url += '&batchCode=' + batchCode
    if (productName) url += '&productName=' + productName
    if (warehouse) url += '&warehouse=' + warehouse
    return request.apiPost(url)
  }
  static getInventoryDetail(id) {
    return request.apiGet(`/api/user-service/trace/warehouse/inventory/detail?id=${id}`)
  }
  static adjustInventory(id, adjustQuantity, reason) {
    return request.apiPost(`/api/user-service/trace/warehouse/inventory/adjust?id=${id}&adjustQuantity=${adjustQuantity}&reason=${reason || ''}`)
  }
  static lockInventory(id, lockQty) {
    return request.apiPost(`/api/user-service/trace/warehouse/inventory/lock?id=${id}&lockQty=${lockQty}`)
  }
  static unlockInventory(id, unlockQty) {
    return request.apiPost(`/api/user-service/trace/warehouse/inventory/unlock?id=${id}&unlockQty=${unlockQty}`)
  }
  static listAvailableBatchCodes() {
    return request.apiGet('/api/user-service/trace/warehouse/inventory/batchCodes')
  }
  // ========== 物流管理 ==========
  static pageLogistics(pageIndex = 1, pageSize = 20, waybillCode, carrier, vehiclePlate, status) {
    let url = `/api/user-service/trace/warehouse/logistics/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (waybillCode) url += '&waybillCode=' + waybillCode
    if (carrier) url += '&carrier=' + carrier
    if (vehiclePlate) url += '&vehiclePlate=' + vehiclePlate
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getLogisticsDetail(id) {
    return request.apiGet(`/api/user-service/trace/warehouse/logistics/detail?id=${id}`)
  }
  static addLogistics(data) {
    return request.apiPost('/api/user-service/trace/warehouse/logistics/add', data)
  }
  static updateLogistics(data) {
    return request.apiPost('/api/user-service/trace/warehouse/logistics/update', data)
  }
  static deleteLogistics(id) {
    return request.apiPost(`/api/user-service/trace/warehouse/logistics/delete?id=${id}`)
  }
  static updateLogisticsStatus(id, status) {
    return request.apiPost(`/api/user-service/trace/warehouse/logistics/updateStatus?id=${id}&status=${status}`)
  }
  // ========== 合格证 ==========
  static pageCertificates(pageIndex = 1, pageSize = 20, certCode, batchCode, productName, status) {
    let url = `/api/user-service/trace/common/certificate/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (certCode) url += '&certCode=' + certCode
    if (batchCode) url += '&batchCode=' + batchCode
    if (productName) url += '&productName=' + productName
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getCertificateDetail(id) {
    return request.apiGet(`/api/user-service/trace/common/certificate/detail?id=${id}`)
  }
  static addCertificate(data) {
    return request.apiPost('/api/user-service/trace/common/certificate/add', data)
  }
  static updateCertificate(data) {
    return request.apiPost('/api/user-service/trace/common/certificate/update', data)
  }
  static deleteCertificate(id) {
    return request.apiPost(`/api/user-service/trace/common/certificate/delete?id=${id}`)
  }
  static generateCertificate(data) {
    return request.apiPost('/api/user-service/trace/common/certificate/generate', data)
  }
  static printCertificate(id) {
    return request.apiPost(`/api/user-service/trace/common/certificate/print?id=${id}`)
  }
  // ========== 资质证书 ==========
  static pageQualifications(pageIndex = 1, pageSize = 20, qualName, qualType, status) {
    let url = `/api/user-service/trace/common/qualification/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (qualName) url += '&qualName=' + qualName
    if (qualType != null) url += '&qualType=' + qualType
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getQualificationDetail(id) {
    return request.apiGet(`/api/user-service/trace/common/qualification/detail?id=${id}`)
  }
  static addQualification(data) {
    return request.apiPost('/api/user-service/trace/common/qualification/add', data)
  }
  static updateQualification(data) {
    return request.apiPost('/api/user-service/trace/common/qualification/update', data)
  }
  static deleteQualification(id) {
    return request.apiPost(`/api/user-service/trace/common/qualification/delete?id=${id}`)
  }
  // ========== 消费者反馈 ==========
  static pageFeedbacks(pageIndex = 1, pageSize = 20, feedbackCode, feedbackType, status) {
    let url = `/api/user-service/trace/common/feedback/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (feedbackCode) url += '&feedbackCode=' + feedbackCode
    if (feedbackType != null) url += '&feedbackType=' + feedbackType
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getFeedbackDetail(id) {
    return request.apiGet(`/api/user-service/trace/common/feedback/detail?id=${id}`)
  }
  static addFeedback(data) {
    return request.apiPost('/api/user-service/trace/common/feedback/add', data)
  }
  static handleFeedback(id, handler, handleOpinion) {
    return request.apiPost(`/api/user-service/trace/common/feedback/handle?id=${id}&handler=${handler}&handleOpinion=${handleOpinion || ''}`)
  }
  static replyFeedback(id, replyContent, replyMethod) {
    return request.apiPost(`/api/user-service/trace/common/feedback/reply?id=${id}&replyContent=${replyContent}&replyMethod=${replyMethod || 1}`)
  }
  static closeFeedback(id) {
    return request.apiPost(`/api/user-service/trace/common/feedback/close?id=${id}`)
  }
  // ========== 召回管理 ==========
  static pageRecalls(pageIndex = 1, pageSize = 20, recallCode, batchCode, status) {
    let url = `/api/user-service/trace/common/recall/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (recallCode) url += '&recallCode=' + recallCode
    if (batchCode) url += '&batchCode=' + batchCode
    if (status != null) url += '&status=' + status
    return request.apiPost(url)
  }
  static getRecallDetail(id) {
    return request.apiGet(`/api/user-service/trace/common/recall/detail?id=${id}`)
  }
  static addRecall(data) {
    return request.apiPost('/api/user-service/trace/common/recall/add', data)
  }
  static executeRecall(id) {
    return request.apiPost(`/api/user-service/trace/common/recall/execute?id=${id}`)
  }
  static completeRecall(id) {
    return request.apiPost(`/api/user-service/trace/common/recall/complete?id=${id}`)
  }
  static cancelRecall(id) {
    return request.apiPost(`/api/user-service/trace/common/recall/cancel?id=${id}`)
  }
 }
 export default traceabilityApi
@@ -0,0 +1,48 @@
 import request from '@/utils/request'
 class trackingConfigApi {
  /**
   * 分页列表
   */
  async list(params = {}) {
    const { pageNum = 1, pageSize = 20, keyword = '' } = params
    return await request.apiGet(`/api/user-service/trackingConfig/list?pageNum=${pageNum}&pageSize=${pageSize}&keyword=${keyword}`)
  }
  /**
   * 根据企业ID获取配置
   */
  async getByCustomerId(customerId) {
    return await request.apiGet(`/api/user-service/trackingConfig/getByCustomerId?customerId=${customerId}`)
  }
  /**
   * 获取当前登录企业的配置
   */
  async getCurrent() {
    return await request.apiGet('/api/user-service/trackingConfig/current')
  }
  /**
   * 新增或更新
   */
  async save(params) {
    return await request.apiPost('/api/user-service/trackingConfig/save', params)
  }
  /**
   * 删除
   */
  async delete(id) {
    return await request.apiPost('/api/user-service/trackingConfig/delete', { id })
  }
  /**
   * 获取企业下拉列表
   */
  async listCustomers(keyword = '') {
    return await request.apiGet(`/api/user-service/trackingConfig/customers?keyword=${keyword}`)
  }
 }
 export default new trackingConfigApi()
@@ -0,0 +1,100 @@
 import request from '@/utils/request'
 class userApi {
  async login(params) {
    return await request.apiPost('/api/user-service/user/smsLogin', params)
  }
  async pageUser(params) {
    return await request.apiPost('/api/user-service/user/pageUser', params)
  }
  async loginPwd(params) {
    return await request.apiPost('/api/user-service/user/loginPwd', params)
  }
  async register(params) {
    return await request.apiPost('/api/user-service/user/register', params)
  }
  async resetPwd(params) {
    return await request.apiPost('/api/user-service/user/resetPwd', params)
  }
  async getCurrentUser() {
    return await request.apiGet('/api/user-service/user/getCurrentUser')
  }
  async saveUserInfo(params) {
    return await request.apiPost('/api/user-service/user/saveUserInfo', params)
  }
  async currentMenus() {
    return await request.apiGet('/api/user-service/permission/currentMenus')
  }
  async getAppMenus(appName) {
    return await request.apiGet(`/api/user-service/permission/getAppMenus?appName=${appName}`)
  }
  async getPackageAppMenus(appName) {
    return await request.apiGet(`/api/user-service/permission/getPackageAppMenus?appName=${appName}`)
  }
  async editPwd(params) {
    return await request.apiPost('/api/user-service/user/editPwd', params)
  }
  async saveSsoConfig(params) {
    return await request.apiPost('/api/user-service/common/saveSsoConfig', params)
  }
  async getSsoConfig() {
    return await request.apiGet('/api/user-service/common/getSsoConfig')
  }
  async huobanWebLogin() {
    return await request.apiGet('/api/user-service/common/huobanWebLogin')
  }
  async getUserByPhone(phone) {
    return await request.apiGet('/api/user-service/user/getUserByPhone?phone=' + phone)
  }
  async selectCustomer(params) {
    return await request.apiPost('/api/user-service/user/selectCustomer', params)
  }
  async getMyCustomers() {
    return await request.apiGet('/api/user-service/user/getMyCustomers')
  }
  async editProfile(params) {
    return await request.apiPost('/api/user-service/user/editProfile', params)
  }
  async editCurrentCustomer(params) {
    return await request.apiPost('/api/user-service/user/customer/editCurrent', params)
  }
  async getCurrentCustomer() {
    return await request.apiGet('/api/user-service/user/customer/getCurrent')
  }
  async certifyEnterprise(params) {
    return await request.apiPost('/api/user-service/user/certifyEnterprise', params)
  }
  async getPendingCustomer(token) {
    return await request.apiGet('/api/user-service/user/getPendingCustomer', { token })
  }
  async recertifyEnterprise(params) {
    return await request.apiPost('/api/user-service/user/recertifyEnterprise', params)
  }
 }
 const target = new userApi()
 export default target
@@ -0,0 +1,31 @@
 import request from '@/utils/request'
 // 用户个性化配置接口（后端 UserPreferenceController）
 const BASE_URL = '/api/user-service/userPreference'
 export default {
  // 查询当前登录用户的个性化配置（未配置时后端返回默认值 uiSize=2）
  mine() {
    return request.apiPost(`${BASE_URL}/mine`)
  },
  // 保存当前登录用户的个性化配置（不存在则新增，已存在则更新）
  save(data) {
    return request.apiPost(`${BASE_URL}/save`, data)
  },
  // 查询指定用户的个性化配置（userId 走 URL 参数）
  get(userId) {
    return request.apiPost(`${BASE_URL}/get?userId=${userId}`)
  },
  // 新增用户个性化配置
  add(data) {
    return request.apiPost(`${BASE_URL}/add`, data)
  },
  // 更新用户个性化配置
  update(data) {
    return request.apiPost(`${BASE_URL}/update`, data)
  },
  // 删除用户个性化配置（userId 走 URL 参数）
  delete(userId) {
    return request.apiPost(`${BASE_URL}/delete?userId=${userId}`)
  }
 }
@@ -0,0 +1,282 @@
 import request from '@/utils/request'
 class weightApi {
  // ========== 车辆管理 ==========
  async pageVehicleRecords(pageIndex, pageSize, plateNumber) {
    let url = `/api/user-service/weight/vehicle/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (plateNumber) url += '&plateNumber=' + plateNumber
    return await request.apiPost(url)
  }
  async vehicleEntry(data) {
    return await request.apiPost('/api/user-service/weight/vehicle/entry', data)
  }
  async updateVehicleRecord(data) {
    return await request.apiPost('/api/user-service/weight/vehicle/update', data)
  }
  async listAllVehicles(plateNumber) {
    let url = '/api/user-service/weight/vehicle/listAll'
    if (plateNumber) url += '?plateNumber=' + plateNumber
    return await request.apiGet(url)
  }
  // ========== 磅单 ==========
  async pageTickets(pageIndex, pageSize, plateNumber, ticketNo) {
    let url = `/api/user-service/weight/ticket/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (plateNumber) url += '&plateNumber=' + plateNumber
    if (ticketNo) url += '&ticketNo=' + ticketNo
    return await request.apiPost(url)
  }
  async firstWeigh(data) {
    return await request.apiPost('/api/user-service/weight/ticket/firstWeigh', data)
  }
  async secondWeigh(data) {
    return await request.apiPost('/api/user-service/weight/ticket/secondWeigh', data)
  }
  async editTicket(data) {
    return await request.apiPost('/api/user-service/weight/ticket/edit', data)
  }
  async getTicketLogs(ticketId) {
    return await request.apiGet(`/api/user-service/weight/ticket/logs?ticketId=${ticketId}`)
  }
  async printTicket(id) {
    return await request.apiPost(`/api/user-service/weight/ticket/print?id=${id}`)
  }
  async ticketDetail(id) {
    return await request.apiGet(`/api/user-service/weight/ticket/detail?id=${id}`)
  }
  // ========== 智能称重设备 ==========
  async pageDevices(pageIndex, pageSize, deviceName, deviceNo) {
    let url = `/api/user-service/weight/device/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (deviceName) url += '&deviceName=' + deviceName
    if (deviceNo) url += '&deviceNo=' + deviceNo
    return await request.apiPost(url)
  }
  async addDevice(data) {
    return await request.apiPost('/api/user-service/weight/device/add', data)
  }
  async updateDevice(data) {
    return await request.apiPost('/api/user-service/weight/device/update', data)
  }
  async deleteDevice(id) {
    return await request.apiPost(`/api/user-service/weight/device/delete?id=${id}`)
  }
  // ========== 司机管理 ==========
  async pageDrivers(pageIndex, pageSize, driverName, phone) {
    let url = `/api/user-service/weight/driver/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (driverName) url += '&driverName=' + driverName
    if (phone) url += '&phone=' + phone
    return await request.apiPost(url)
  }
  async addDriver(data) {
    return await request.apiPost('/api/user-service/weight/driver/add', data)
  }
  async updateDriver(data) {
    return await request.apiPost('/api/user-service/weight/driver/update', data)
  }
  async deleteDriver(id) {
    return await request.apiPost(`/api/user-service/weight/driver/delete?id=${id}`)
  }
  async listAllDrivers() {
    return await request.apiGet('/api/user-service/weight/driver/listAll')
  }
  // ========== 过磅卡 ==========
  async pageCards(pageIndex, pageSize, cardNo, cardType) {
    let url = `/api/user-service/weight/card/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (cardNo) url += '&cardNo=' + cardNo
    if (cardType) url += '&cardType=' + cardType
    return await request.apiPost(url)
  }
  async getByCardNo(cardNo) {
    return await request.apiGet(`/api/user-service/weight/card/getByCardNo?cardNo=${cardNo}`)
  }
  async addCard(data) {
    return await request.apiPost('/api/user-service/weight/card/add', data)
  }
  async updateCard(data) {
    return await request.apiPost('/api/user-service/weight/card/update', data)
  }
  async deleteCard(id) {
    return await request.apiPost(`/api/user-service/weight/card/delete?id=${id}`)
  }
  // ========== 北斗卡 ==========
  async pageBeidouCards(pageIndex, pageSize, deviceNo, cardType) {
    let url = `/api/user-service/weight/beidou/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (deviceNo) url += '&deviceNo=' + deviceNo
    if (cardType) url += '&cardType=' + cardType
    return await request.apiPost(url)
  }
  async addBeidouCard(data) {
    return await request.apiPost('/api/user-service/weight/beidou/add', data)
  }
  async updateBeidouCard(data) {
    return await request.apiPost('/api/user-service/weight/beidou/update', data)
  }
  async deleteBeidouCard(id) {
    return await request.apiPost(`/api/user-service/weight/beidou/delete?id=${id}`)
  }
  async borrowBeidouCard(cardId, vehicleId, plateNumber) {
    let url = `/api/user-service/weight/beidou/borrow?cardId=${cardId}&vehicleId=${vehicleId}`
    if (plateNumber) url += '&plateNumber=' + plateNumber
    return await request.apiPost(url)
  }
  async returnBeidouCard(cardId) {
    return await request.apiPost(`/api/user-service/weight/beidou/return?cardId=${cardId}`)
  }
  async pageBorrowRecords(pageIndex, pageSize, deviceNo, plateNumber, status) {
    let url = `/api/user-service/weight/beidou/borrowRecord/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (deviceNo) url += '&deviceNo=' + deviceNo
    if (plateNumber) url += '&plateNumber=' + plateNumber
    if (status !== undefined && status !== null) url += '&status=' + status
    return await request.apiPost(url)
  }
  async getBorrowRecordDetail(id) {
    return await request.apiGet(`/api/user-service/weight/beidou/borrowRecord/detail?id=${id}`)
  }
  async listAvailableBeidouCards(limit, deviceNo) {
    let url = `/api/user-service/weight/beidou/availableList?limit=${limit || 10}`
    if (deviceNo) url += '&deviceNo=' + deviceNo
    return await request.apiGet(url)
  }
  async listBorrowedBeidouCards(limit, deviceNo) {
    let url = `/api/user-service/weight/beidou/borrowedList?limit=${limit || 10}`
    if (deviceNo) url += '&deviceNo=' + deviceNo
    return await request.apiGet(url)
  }
  async listPendingSecondWeigh(limit) {
    let url = `/api/user-service/weight/ticket/pendingSecondWeigh?limit=${limit || 20}`
    return await request.apiGet(url)
  }
  // ========== 北斗卡跟踪记录 ==========
  async pageBeidouTracking(pageIndex, pageSize, trackingNo, cardId, deviceNo) {
    let url = `/api/user-service/weight/beidou/tracking/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (trackingNo) url += '&trackingNo=' + trackingNo
    if (cardId) url += '&cardId=' + cardId
    if (deviceNo) url += '&deviceNo=' + deviceNo
    return await request.apiPost(url)
  }
  async beidouTrackingDetail(id) {
    return await request.apiGet(`/api/user-service/weight/beidou/tracking/detail?id=${id}`)
  }
  async beidouTrackingLatest(trackingNo) {
    return await request.apiGet(`/api/user-service/weight/beidou/tracking/latest?trackingNo=${trackingNo}`)
  }
  async beidouTrackingListByNo(trackingNo) {
    return await request.apiGet(`/api/user-service/weight/beidou/tracking/listByNo?trackingNo=${trackingNo}`)
  }
  async generateMockBeidouData(data) {
    let url = `/api/user-service/weight/beidou/tracking/generateMock?cardId=${data.cardId}` +
      `&tempMin=${data.tempMin}&tempMax=${data.tempMax}` +
      `&humidityMin=${data.humidityMin}&humidityMax=${data.humidityMax}` +
      `&count=${data.count}&startTime=${data.startTime}`
    return await request.apiPost(url)
  }
  // ========== 报警规则管理 ==========
  async pageAlarmRules(pageIndex, pageSize, ruleName) {
    let url = `/api/user-service/weight/alarmRule/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (ruleName) url += '&ruleName=' + ruleName
    return await request.apiPost(url)
  }
  async getAlarmRuleDetail(id) {
    return await request.apiGet(`/api/user-service/weight/alarmRule/detail?id=${id}`)
  }
  async saveAlarmRule(data) {
    return await request.apiPost('/api/user-service/weight/alarmRule/save', data)
  }
  async deleteAlarmRule(id) {
    return await request.apiPost(`/api/user-service/weight/alarmRule/delete?id=${id}`)
  }
  async listAllAlarmRules() {
    return await request.apiGet('/api/user-service/weight/alarmRule/listAll')
  }
  async bindAlarmRule(cardId, alarmRuleId) {
    let url = `/api/user-service/weight/beidou/bindAlarmRule?cardId=${cardId}`
    if (alarmRuleId !== null && alarmRuleId !== undefined) url += '&alarmRuleId=' + alarmRuleId
    return await request.apiPost(url)
  }
  // ========== 报警记录 ==========
  async pageAlarmRecords(pageIndex, pageSize, deviceNo, trackingNo, plateNumber, ruleName) {
    let url = `/api/user-service/weight/alarmRecord/page?pageIndex=${pageIndex}&pageSize=${pageSize}`
    if (deviceNo) url += '&deviceNo=' + deviceNo
    if (trackingNo) url += '&trackingNo=' + trackingNo
    if (plateNumber) url += '&plateNumber=' + plateNumber
    if (ruleName) url += '&ruleName=' + ruleName
    return await request.apiPost(url)
  }
  // ========== 企业UI个性化配置 ==========
  async getUiConfig() {
    return await request.apiGet('/api/user-service/weight/uiConfig/get')
  }
  async saveUiConfig(data) {
    return await request.apiPost('/api/user-service/weight/uiConfig/save', data)
  }
  async resetUiConfig() {
    return await request.apiPost('/api/user-service/weight/uiConfig/reset')
  }
  async getUiConfigByCustomer(customerId) {
    return await request.apiGet(`/api/user-service/common/uiConfig/getByCustomer?customerId=${customerId}`)
  }
 }
 const target = new weightApi()
 export default target
@@ -0,0 +1,35 @@
@function px2rem($px) {
    @return ($px) * 0.01rem;
 }
 // 默认字体大小
 // 我的颜色变量
 $mycolor: #00c56e;
 $defaultFontSize: px2rem(18);
 // 标题文字大小和颜色
 $headFontSize: px2rem(36);
 $headColor: #fff;
 // 默认字体颜色
 $baseColor: #fff;
 // 选中字体颜色
 $activeColor: #00E452;
 // 头部两边的文字大小
 $headerleftFontSize: px2rem(18);
 // 头部导航文字大小
 $headerNavFontSize: px2rem(20);
 // 
 // 小标题的文字大小
 $titleFontSize: px2rem(20);
 $titleleftBorder: .03rem solid #00E452;
 $titlebottomBorder: .01rem solid #fff;
--- a/Show More
+++ b/Show More