feat(order): 添加订单状态字段并更新关联查询

- 在 ShopDealerOrder 实体中新增 orderStatus 字段用于显示订单状态
- 更新 ShopDealerOrderMapper.xml 中的关联查询，加入订单状态字段映射
- 修改 application.yml 配置文件，将默认激活环境从 dev 改为 glt2
- 通过 LEFT JOIN 关联 shop_order 表获取订单状态数据

.gitignore

@@ -42,3 +42,4 @@ ehthumbs.db
 Thumbs.db
 /file/
 /websoft-modules.log
+/tmp/

CONTEXT.md

@@ -1,43 +0,0 @@
-# 汇吉采标书购买平台
-
-汇吉采标书购买平台是一站式代理平台的交易出口：企业账号在此注册、通过资质审核后购买标书，平台内完成订单与支付，并把购买记录推送回一站式平台。
-
-## 核心实体
-
-**标书项目 (Bid Project)**:
-一条采购项目，同时也是可购买下载的标书，二者是**同一实体**（甲方确认：一个项目即一本标书）。携带项目编号、名称/分类、招标人、中标公司、中标金额与中标公告信息，以及标书价格（信息服务费）、标书附件、开售/停售时间与售卖方式。
-_Avoid_: 项目(单用), 标书(单用), tender
-
-**企业账号 (Enterprise Account)**:
-买家账号，用企业名称+密码登录，须通过资质审核才能购买标书。
-_Avoid_: 用户, 会员, buyer, hjc_user
-
-**资质认证 (Qualification)**:
-企业注册后提交、由平台审核的资质材料，状态为 待审核/已通过/已驳回（含驳回原因）。未通过不可下单。
-_Avoid_: 认证
-
-**订单 (Order)**:
-企业购买标书的记录，含标书信息/数量/金额/购买企业，需支付后完成。
-_Avoid_: 交易, purchase
-
-**信息服务费 (Service Fee)**:
-购买标书支付的金额，即「标书价格」。平台对每一本标书设定。
-_Avoid_: 标书价格, 标书费
-
-## 与一站式平台的关系
-
-**一站式代理平台 (One-stop Platform)**:
-上游系统，向本平台推送中标公告数据，并接收本平台推送的购买记录/订单落盘。
-_Avoid_: 甲方, 上游
-
-**中标公告 (Award Announcement)**:
-项目流程走到「发布中标公告」时由一站式平台推送的公告数据，含招标人/中标公司/中标金额/公告正文/公告附件。
-_Avoid_: 公告, bulletin
-
-**售卖方式 (Selling Method)**:
-标书的售卖渠道标识：1 公司财务 / 2 公众号 / 3 交易中心 / 4 政采云。
-_Avoid_: 渠道
-
-**推送 (Push)**:
-本平台与一站式平台之间交换数据的动作：接收中标公告（入），并在订单支付成功后推送购买记录（出）。
-_Avoid_: 同步, 对接

com/wechat/pay/java/core/exception/ServiceException.java

@@ -0,0 +1,86 @@
+package com.wechat.pay.java.core.exception;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.wechat.pay.java.core.http.HttpRequest;
+import com.wechat.pay.java.core.util.GsonUtil;
+
+/** 发送HTTP请求成功，返回异常时抛出。例如返回状态码小于200或大于等于300、返回体参数不完整。 */
+public class ServiceException extends WechatPayException {
+
+  private static final long serialVersionUID = -7174975090366956652L;
+
+  private final HttpRequest httpRequest;
+  private final int httpStatusCode;
+  private final String responseBody;
+  private String errorCode;
+  private String errorMessage;
+
+  /**
+   * 返回状态码小于200或大于300调用
+   *
+   * @param httpRequest http请求
+   * @param httpStatusCode http状态码
+   * @param responseBody http返回体
+   */
+  public ServiceException(HttpRequest httpRequest, int httpStatusCode, String responseBody) {
+    super(
+        String.format(
+            "Wrong HttpStatusCode[%d]%nhttpResponseBody[%.1024s]\tHttpRequest[%s]",
+            httpStatusCode, responseBody, httpRequest));
+    this.httpRequest = httpRequest;
+    this.httpStatusCode = httpStatusCode;
+    this.responseBody = responseBody;
+    if (responseBody != null && !responseBody.isEmpty()) {
+      JsonObject jsonObject = GsonUtil.getGson().fromJson(responseBody, JsonObject.class);
+      JsonElement code = jsonObject.get("code");
+      JsonElement message = jsonObject.get("message");
+      this.errorCode = code == null ? null : code.getAsString();
+      this.errorMessage = message == null ? null : message.getAsString();
+    }
+  }
+
+  /**
+   * 获取序列化版本UID
+   *
+   * @return UID
+   */
+  public static long getSerialVersionUID() {
+    return serialVersionUID;
+  }
+
+  /**
+   * 获取HTTP请求
+   *
+   * @return HTTP请求
+   */
+  public HttpRequest getHttpRequest() {
+    return httpRequest;
+  }
+
+  /**
+   * 获取HTTP返回体
+   *
+   * @return HTTP返回体
+   */
+  public String getResponseBody() {
+    return responseBody;
+  }
+
+  /**
+   * 获取HTTP状态码
+   *
+   * @return HTTP状态码
+   */
+  public int getHttpStatusCode() {
+    return httpStatusCode;
+  }
+
+  public String getErrorCode() {
+    return errorCode;
+  }
+
+  public String getErrorMessage() {
+    return errorMessage;
+  }
+}

com/wechat/pay/java/core/http/AbstractHttpClient.java

@@ -0,0 +1,151 @@
+package com.wechat.pay.java.core.http;
+
+import static com.wechat.pay.java.core.http.Constant.ACCEPT;
+import static com.wechat.pay.java.core.http.Constant.AUTHORIZATION;
+import static com.wechat.pay.java.core.http.Constant.OS;
+import static com.wechat.pay.java.core.http.Constant.REQUEST_ID;
+import static com.wechat.pay.java.core.http.Constant.USER_AGENT;
+import static com.wechat.pay.java.core.http.Constant.USER_AGENT_FORMAT;
+import static com.wechat.pay.java.core.http.Constant.VERSION;
+import static com.wechat.pay.java.core.http.Constant.WECHAT_PAY_SERIAL;
+import static java.net.HttpURLConnection.HTTP_MULT_CHOICE;
+import static java.net.HttpURLConnection.HTTP_OK;
+import static java.util.Objects.requireNonNull;
+
+import com.wechat.pay.java.core.auth.Credential;
+import com.wechat.pay.java.core.auth.Validator;
+import com.wechat.pay.java.core.exception.MalformedMessageException;
+import com.wechat.pay.java.core.exception.ServiceException;
+import com.wechat.pay.java.core.exception.ValidationException;
+import com.wechat.pay.java.core.http.HttpRequest.Builder;
+import java.io.InputStream;
+
+/** 请求客户端抽象基类 */
+public abstract class AbstractHttpClient implements HttpClient {
+
+  protected final Credential credential;
+  protected final Validator validator;
+
+  public AbstractHttpClient(Credential credential, Validator validator) {
+    this.credential = requireNonNull(credential);
+    this.validator = requireNonNull(validator);
+  }
+
+  @Override
+  public <T> HttpResponse<T> execute(HttpRequest httpRequest, Class<T> responseClass) {
+    HttpRequest innerRequest =
+        new Builder()
+            .url(httpRequest.getUrl())
+            .httpMethod(httpRequest.getHttpMethod())
+            .headers(httpRequest.getHeaders())
+            .addHeader(AUTHORIZATION, getAuthorization(httpRequest))
+            .addHeader(USER_AGENT, getUserAgent())
+            .addHeader(WECHAT_PAY_SERIAL, getWechatPaySerial())
+            .body(httpRequest.getBody())
+            .build();
+    OriginalResponse originalResponse = innerExecute(innerRequest);
+    validateResponse(originalResponse);
+    return assembleHttpResponse(originalResponse, responseClass);
+  }
+
+  @Override
+  public InputStream download(String url) {
+    HttpRequest originRequest =
+        new HttpRequest.Builder().httpMethod(HttpMethod.GET).url(url).build();
+    HttpRequest httpRequest =
+        new HttpRequest.Builder()
+            .url(url)
+            .httpMethod(HttpMethod.GET)
+            .addHeader(AUTHORIZATION, getAuthorization(originRequest))
+            .addHeader(ACCEPT, "*/*")
+            .addHeader(USER_AGENT, getUserAgent())
+            .addHeader(WECHAT_PAY_SERIAL, getWechatPaySerial())
+            .build();
+    return innerDownload(httpRequest);
+  }
+
+  protected abstract InputStream innerDownload(HttpRequest httpRequest);
+
+  protected abstract OriginalResponse innerExecute(HttpRequest httpRequest);
+
+  private void validateResponse(OriginalResponse originalResponse) {
+
+    if (isInvalidHttpCode(originalResponse.getStatusCode())) {
+      throw new ServiceException(
+          originalResponse.getRequest(),
+          originalResponse.getStatusCode(),
+          originalResponse.getBody());
+    }
+
+    if (originalResponse.getBody() != null
+        && !originalResponse.getBody().isEmpty()
+        && !MediaType.APPLICATION_JSON.equalsWith(originalResponse.getContentType())) {
+      throw new MalformedMessageException(
+          String.format(
+              "Unsupported content-type[%s]%nhttpRequest[%s]",
+              originalResponse.getContentType(), originalResponse.getRequest()));
+    }
+
+    if (!validator.validate(originalResponse.getHeaders(), originalResponse.getBody())) {
+      String requestId = originalResponse.getHeaders().getHeader(REQUEST_ID);
+      throw new ValidationException(
+          String.format(
+              "Validate response failed,the WechatPay signature is incorrect.%n"
+                  + "Request-ID[%s]\tresponseHeader[%s]\tresponseBody[%.1024s]",
+              requestId, originalResponse.getHeaders(), originalResponse.getBody()));
+    }
+  }
+
+  protected boolean isInvalidHttpCode(int httpCode) {
+    return httpCode < HTTP_OK || httpCode >= HTTP_MULT_CHOICE;
+  }
+
+  private <T> HttpResponse<T> assembleHttpResponse(
+      OriginalResponse originalResponse, Class<T> responseClass) {
+    return new HttpResponse.Builder<T>()
+        .originalResponse(originalResponse)
+        .serviceResponseType(responseClass)
+        .build();
+  }
+
+  private String getSignBody(RequestBody requestBody) {
+    if (requestBody == null) {
+      return "";
+    }
+    if (requestBody instanceof JsonRequestBody) {
+      return ((JsonRequestBody) requestBody).getBody();
+    }
+    if (requestBody instanceof FileRequestBody) {
+      return ((FileRequestBody) requestBody).getMeta();
+    }
+    throw new UnsupportedOperationException(
+        String.format("Unsupported RequestBody Type[%s]", requestBody.getClass().getName()));
+  }
+
+  private String getUserAgent() {
+    return String.format(
+        USER_AGENT_FORMAT,
+        getClass().getPackage().getImplementationVersion(),
+        OS,
+        VERSION == null ? "Unknown" : VERSION,
+        credential.getClass().getSimpleName(),
+        validator.getClass().getSimpleName(),
+        getHttpClientInfo());
+  }
+
+  private String getWechatPaySerial() {
+    return this.validator.getSerialNumber();
+  }
+
+  /**
+   * 获取http客户端信息，用于User-Agent。 格式：客户端名称/版本 示例：okhttp3/4.9.3
+   *
+   * @return 客户端信息
+   */
+  protected abstract String getHttpClientInfo();
+
+  private String getAuthorization(HttpRequest request) {
+    return credential.getAuthorization(
+        request.getUri(), request.getHttpMethod().name(), getSignBody(request.getBody()));
+  }
+}

docs/SHOP_DEALER_REFEREE_BINDING.md

@@ -0,0 +1,26 @@
+# ShopDealerReferee 绑定接口规则与索引建议
+
+接口：`POST /api/shop/shop-dealer-referee`
+
+## 业务规则(后端)
+
+- 邀请人(dealerId)必须存在且有效：以 `shop_dealer_user` 记录存在且 `is_delete=0` 为准
+- 当前用户(userId)仅从 token 获取；若 body.userId 存在且与 token 不一致则拒绝
+- 禁止自己绑定自己：`dealerId == userId`
+- 仅首次绑定生效：若已存在(同一 tenant、同一 user、`level=1`)则直接返回成功(幂等，不改绑)
+- 记录溯源字段：`source`、`scene`
+
+## 并发幂等(数据库建议)
+
+建议在 `shop_dealer_referee` 增加溯源字段，并加唯一索引保证并发下不重复写入：
+
+```sql
+ALTER TABLE shop_dealer_referee
+  ADD COLUMN source VARCHAR(32) NULL COMMENT '来源(如 goods_share)',
+  ADD COLUMN scene  VARCHAR(255) NULL COMMENT '场景参数(溯源统计)';
+
+-- 约束：同一 tenant 下，一个用户每个 level 只能有一条推荐关系
+ALTER TABLE shop_dealer_referee
+  ADD UNIQUE KEY uk_shop_dealer_referee_tenant_user_level (tenant_id, user_id, level);
+```
+

docs/TICKET_PACKAGE_FEATURE_PLAN.md

@@ -0,0 +1,31 @@
+# 套票（冻结/可用、分期释放）功能开发计划
+
+## 目标
+- 为“买N送M（例如买1送4）、起售（例如20桶起售）、按月释放（例如每月释放10桶）、可用未用完叠加”的套票/权益，提供后端可配置、可发放、可释放、可消费的能力。
+
+## 核心概念
+- 套票模板：按商品(goodsId)配置买赠规则、起售/起送、释放规则（每期释放数或释放期数）、首期释放时机。
+- 用户套票账户：记录总量、可用量、冻结量、已用量、已释放量；绑定订单（用于幂等与追溯）。
+- 释放计划：每期一条，到期后把冻结转可用（可用未用完自然叠加）。
+- 变更流水：发放/释放/消费等都记录流水，便于对账与排查。
+
+## 关键默认规则（可在模板里改）
+- 仅赠送量进入套票账户（默认不包含“购买量”本身）；如需“买20送80=总100”，可在模板设置 `includeBuyQty=true`。
+- 首期释放：默认“支付成功当日/当刻”释放（`firstReleaseMode=0`）；如需“下个月同日释放”，设 `firstReleaseMode=1`。
+- 每期释放：默认按 `monthlyReleaseQty`；如配置了 `releasePeriods`，则平均分摊并处理余数。
+
+## 开发步骤（建议按顺序）
+1. 需求确认与接入点确认（订单哪个节点发放、桶票如何消费/核销、退款是否回滚、释放日期规则）。
+2. 数据表设计与SQL输出（模板/账户/释放计划/流水）。
+3. 实现套票模板后台CRUD接口。
+4. 支付成功接入：在订单支付成功后发放套票账户+生成释放计划（幂等）。
+5. 定时任务释放：扫描到期释放计划，执行“冻结->可用”转账（幂等）。
+6. 消费扣减：对用户可用量做扣减（支持跨多套票账户FIFO扣减），并落流水。
+7. 测试与验收：至少覆盖（买赠计算、分期拆分、叠加逻辑、幂等、并发扣减）。
+
+## 待确认点（不确认也可先按默认实现）
+- 套票数量=赠送量？还是（购买量+赠送量）？
+- “释放日期”是按支付时间的“日”还是固定每月某一天？（31号跨月如何处理？）
+- 退款/取消：是否回滚未使用的可用/冻结？已释放但未用如何处理？
+- 消费场景：在哪个业务点扣减（下单抵扣/提货核销/线下核销）？
+

docs/TICKET_PACKAGE_TABLES.sql

@@ -0,0 +1,121 @@
+-- 套票（冻结/可用、分期释放）相关表
+-- 说明：项目使用了 MyBatis-Plus 的 tenant 拦截；表内显式保留 tenant_id 字段并建议建立联合唯一索引。
+
+-- 1) 套票模板（按商品配置）
+CREATE TABLE IF NOT EXISTS shop_ticket_template (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  goods_id INT NOT NULL,
+  name VARCHAR(100) NOT NULL,
+
+  enabled TINYINT(1) NOT NULL DEFAULT 1,
+  unit_name VARCHAR(20) NOT NULL DEFAULT '桶',
+
+  -- 起售/起送
+  min_buy_qty INT NOT NULL DEFAULT 1,
+  start_send_qty INT NOT NULL DEFAULT 1,
+
+  -- 买赠：买1送4 => gift_multiplier=4
+  gift_multiplier INT NOT NULL DEFAULT 0,
+  -- 是否把购买量也计入套票总量（默认仅计入赠送量）
+  include_buy_qty TINYINT(1) NOT NULL DEFAULT 0,
+
+  -- 释放规则：二选一
+  -- A) 每期释放数量（默认每月释放10）
+  monthly_release_qty INT NOT NULL DEFAULT 10,
+  -- B) 总共释放多少期（若配置>0，则按期数平均分摊）
+  release_periods INT NULL,
+
+  -- 首期释放时机：0=支付成功当刻；1=下个月同日
+  first_release_mode INT NOT NULL DEFAULT 0,
+
+  comments VARCHAR(255) NULL,
+  sort_number INT NOT NULL DEFAULT 0,
+  user_id INT NULL,
+
+  deleted INT NOT NULL DEFAULT 0,
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  UNIQUE KEY uk_ticket_template_tenant_goods (tenant_id, goods_id),
+  KEY idx_ticket_template_tenant (tenant_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 2) 用户套票账户（一次购买通常生成一条）
+CREATE TABLE IF NOT EXISTS shop_user_ticket (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  template_id INT NOT NULL,
+  goods_id INT NOT NULL,
+
+  user_id INT NOT NULL,
+  order_id INT NULL,
+  order_no VARCHAR(64) NULL,
+  order_goods_id INT NULL,
+
+  total_qty INT NOT NULL DEFAULT 0,
+  available_qty INT NOT NULL DEFAULT 0,
+  frozen_qty INT NOT NULL DEFAULT 0,
+  used_qty INT NOT NULL DEFAULT 0,
+  released_qty INT NOT NULL DEFAULT 0,
+
+  status INT NOT NULL DEFAULT 0,
+
+  deleted INT NOT NULL DEFAULT 0,
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  KEY idx_user_ticket_user (tenant_id, user_id),
+  KEY idx_user_ticket_order (tenant_id, order_no),
+  UNIQUE KEY uk_user_ticket_order_goods (tenant_id, template_id, order_no, order_goods_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 3) 释放计划/释放记录（每期一条，幂等执行）
+CREATE TABLE IF NOT EXISTS shop_user_ticket_release (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  user_ticket_id BIGINT NOT NULL,
+  user_id INT NOT NULL,
+  period_no INT NOT NULL,
+
+  release_qty INT NOT NULL,
+  release_time DATETIME NOT NULL,
+
+  status INT NOT NULL DEFAULT 0, -- 0待释放 1已释放 2作废
+  released_time DATETIME NULL,
+
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  UNIQUE KEY uk_ticket_release_period (tenant_id, user_ticket_id, period_no),
+  KEY idx_ticket_release_due (status, release_time),
+  KEY idx_ticket_release_user (tenant_id, user_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 4) 套票变更流水（发放/释放/消费/回滚等）
+CREATE TABLE IF NOT EXISTS shop_user_ticket_log (
+  id BIGINT AUTO_INCREMENT PRIMARY KEY,
+  user_ticket_id BIGINT NOT NULL,
+  user_id INT NOT NULL,
+
+  change_type INT NOT NULL, -- 10发放 20释放 30消费 40回滚/退款
+  change_available INT NOT NULL DEFAULT 0,
+  change_frozen INT NOT NULL DEFAULT 0,
+  change_used INT NOT NULL DEFAULT 0,
+
+  available_after INT NOT NULL DEFAULT 0,
+  frozen_after INT NOT NULL DEFAULT 0,
+  used_after INT NOT NULL DEFAULT 0,
+
+  order_id INT NULL,
+  order_no VARCHAR(64) NULL,
+  remark VARCHAR(255) NULL,
+
+  tenant_id INT NOT NULL,
+  create_time DATETIME NULL,
+  update_time DATETIME NULL,
+
+  KEY idx_ticket_log_user (tenant_id, user_id),
+  KEY idx_ticket_log_ticket (tenant_id, user_ticket_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+

docs/adr/0001-one-stop-push-auth.md

@@ -1,3 +0,0 @@
-# 一站式推送鉴权：appKey + timestamp + sign，password 不进报文
-
-汇吉采 → 一站式平台的订单推送采用 `appKey + timestamp + sign` 请求头鉴权，`sign = MD5(appKey + password + timestamp)`（小写），`password` 只作为密钥参与签名、不放入任何报文字段；一站式侧校验 appKey 匹配、timestamp 与本地时间差 ≤ ±10 分钟（防重放）、以及重算 MD5 与 sign 不区分大小写比对。原始需求文字要求把 `password` 明文加入请求头，会泄露共享密钥，本方案保留其 appKey/password/年月日时分/MD5 全部要素，仅把 password 降级为纯签名密钥，是相对原始字面的有意偏离；若一站式平台已按原始明文方案实现，兼容退路见 `docs/一站式平台推送-接口鉴权规范.md` 附录 A。理由：这是对外契约，改动成本高，且偏离点是刻意且必须记录，否则后人会「修复」回明文方案。

docs/adr/0002-project-biddoc-onetomany.md

@@ -1,5 +0,0 @@
-# 项目与标书为同一实体：一个项目一本标书
-
-**Supersedes**: 早先「项目/标书两个实体、1 项目:N 标书」的假设——甲方已明确**项目与标书是一个东西，一个项目即一本标书**，故撤销该假设。
-
-项目（Project）与标书（BidDocument）建模为**同一个实体**（`标书项目`），单表承载。一站式推送的公告类字段（公告标题/招标人/中标公司/中标金额/公告正文/公告附件）与销售类字段（标书价格/附件/开售/停售/售卖方式/needSell）都落在这一张表上，由「推送入库 + 管理后台手工增删改查」双路填充。理由：既然甲方确认一个项目仅对应一本标书，两实体之间的 1:N 关系已不存在，拆表只会增加复杂度而无对应业务收益；等未来确实出现「一项目多标书」再演进（届时把标书款从主表抽出即可，主表结构无须预埋）。

docs/adr/0003-h5-wechat-jsapi-payment.md

@@ -1,12 +0,0 @@
-# H5 端（公众号内）支付采用微信 JSAPI 直接唤起
-
-汇吉采移动端 H5（`hjc-h5`，在微信「公众号」内打开）的支付采用**微信 JSAPI**（`PaymentType.WECHAT` + `openid`），由后端 `WechatJsapiStrategy` 用 `wechatpay-java` 的 `JsapiServiceExtension.prepayWithRequestPayment` 直接返回前端 `wx.chooseWXPay` 所需的 `appId/timeStamp/nonceStr/package/signType/paySign`；无 `openid`（非公众号环境）时**回退 Native 扫码**展示 `codeUrl`。
-
-选择理由：公众号内直接「唤起支付」免去另开微信扫二维码的操作，转化率与体验均优于 Native 扫码；后端支付组件（`PaymentRequest.openId`、`PaymentResponse.wechatJsapi`、`PaymentChannel.WECHAT_JSAPI`、`WechatPayType.JSAPI`）早已为 JSAPI 预留，只差一个策略实现，改造成本低。
-
-代价/偏离：
-- **需要用户 openid**，因此引入微信**网页授权**（静默 `snsapi_base`）：`/hjc/wechat/authorize` 生成授权地址，`/hjc/wechat/oauth/callback` 用 `code` 换 `openid` 后回跳 H5 并附带 `openid`。
-- **需要 `wx.config` 签名**：新增 `/hjc/wechat/jsapi-sign`（基于 `jsapi_ticket` 做 SHA1 签名），公众号配置（appId/appSecret）存于 Redis `cache{tenantId}:setting:wx-official`。
-- **不改 Native 扫码逻辑**：两者共用同一商户号/回调地址；`PaymentServiceImpl.getPaymentStrategy` 在 `WECHAT` 类型下按 `openid` 有无分流 JSAPI/Native，未破坏既有 Native 调用方。
-
-兼容与说明：本方案是「带 openid 走 JSAPI，否则 Native」的弹性分流，非公众号环境（如普通浏览器/开发联调）仍可扫码支付，便于无真实公众号配置时验证。

docs/ai/README.md

@@ -0,0 +1,61 @@
+# AI 模块（Ollama + RAG + 订单分析）
+
+## 1. 配置
+
+见 `src/main/resources/application.yml`：
+
+- `ai.ollama.base-url`：主地址（例如 `https://ai-api.websoft.top`）
+- `ai.ollama.fallback-url`：备用地址（例如 `http://47.119.165.234:11434`）
+- `ai.ollama.chat-model`：对话模型（`qwen3.5:cloud`）
+- `ai.ollama.embed-model`：向量模型（`qwen3-embedding:4b`）
+
+## 2. 建表（知识库）
+
+执行：`docs/ai/ai_kb_tables.sql`
+
+## 3. API
+
+说明：所有接口默认需要登录（`@PreAuthorize("isAuthenticated()")`），并且要求能够拿到 `tenantId`（header 或登录用户）。
+
+### 3.1 对话
+
+- `GET /api/ai/models`：获取 Ollama 模型列表
+- `POST /api/ai/chat`：非流式对话
+- `POST /api/ai/chat/stream`：流式对话（SSE）
+- `GET /api/ai/chat/stream?prompt=...`：流式对话（SSE，适配 EventSource）
+
+请求示例（非流式）：
+```json
+{
+  "prompt": "帮我写一个退款流程说明"
+}
+```
+
+### 3.2 知识库（RAG）
+
+- `POST /api/ai/kb/upload`：上传文档入库（建议 txt/md/html）
+- `POST /api/ai/kb/sync/cms`：同步 CMS 已发布文章到知识库（当前租户）
+- `POST /api/ai/kb/query`：仅检索 topK
+- `POST /api/ai/kb/ask`：检索 + 生成答案（答案要求引用 chunk_id）
+
+请求示例（ask）：
+```json
+{
+  "question": "怎么开具发票？",
+  "topK": 5
+}
+```
+
+### 3.3 商城订单分析（按租户/按天）
+
+- `POST /api/ai/analytics/query`：返回按天指标数据
+- `POST /api/ai/analytics/ask`：基于指标数据生成分析结论
+
+请求示例（ask）：
+```json
+{
+  "question": "最近30天支付率有没有明显下滑？请给出原因排查建议。",
+  "startDate": "2026-02-01",
+  "endDate": "2026-02-27"
+}
+```

docs/ai/ai_kb_tables.sql

@@ -0,0 +1,39 @@
+-- AI 知识库（RAG）建表脚本（MySQL）
+-- 说明：本项目使用 MyBatis-Plus 默认命名规则（AiKbDocument -> ai_kb_document）。
+
+CREATE TABLE IF NOT EXISTS `ai_kb_document` (
+  `document_id` INT NOT NULL AUTO_INCREMENT COMMENT '文档ID',
+  `title` VARCHAR(255) NULL COMMENT '标题',
+  `source_type` VARCHAR(32) NULL COMMENT '来源类型：upload/cms',
+  `source_id` INT NULL COMMENT '来源ID（如 cms.article_id）',
+  `source_ref` VARCHAR(255) NULL COMMENT '来源引用（如文件名、文章 code）',
+  `content_hash` CHAR(64) NULL COMMENT '内容hash(SHA-256)，用于增量同步',
+  `status` TINYINT NULL DEFAULT 0 COMMENT '状态',
+  `deleted` TINYINT NULL DEFAULT 0 COMMENT '逻辑删除：0否1是',
+  `tenant_id` INT NOT NULL COMMENT '租户ID',
+  `update_time` DATETIME NULL COMMENT '更新时间',
+  `create_time` DATETIME NULL COMMENT '创建时间',
+  PRIMARY KEY (`document_id`),
+  KEY `idx_ai_kb_document_tenant` (`tenant_id`),
+  KEY `idx_ai_kb_document_source` (`tenant_id`, `source_type`, `source_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='AI 知识库文档';
+
+CREATE TABLE IF NOT EXISTS `ai_kb_chunk` (
+  `id` INT NOT NULL AUTO_INCREMENT COMMENT '自增ID',
+  `document_id` INT NOT NULL COMMENT '文档ID',
+  `chunk_id` VARCHAR(64) NOT NULL COMMENT 'chunk 唯一ID（用于引用）',
+  `chunk_index` INT NULL COMMENT 'chunk 序号',
+  `title` VARCHAR(255) NULL COMMENT '标题（冗余，便于展示）',
+  `content` LONGTEXT NULL COMMENT 'chunk 文本',
+  `content_hash` CHAR(64) NULL COMMENT 'chunk 内容hash',
+  `embedding` LONGTEXT NULL COMMENT 'embedding(JSON数组)',
+  `embedding_norm` DOUBLE NULL COMMENT 'embedding L2 范数',
+  `deleted` TINYINT NULL DEFAULT 0 COMMENT '逻辑删除：0否1是',
+  `tenant_id` INT NOT NULL COMMENT '租户ID',
+  `create_time` DATETIME NULL COMMENT '创建时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_ai_kb_chunk_chunk_id` (`chunk_id`),
+  KEY `idx_ai_kb_chunk_tenant` (`tenant_id`),
+  KEY `idx_ai_kb_chunk_document` (`document_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='AI 知识库 chunk';
+

docs/sql/2026-02-06_glt_ticket_order_delivery_fields.sql

@@ -0,0 +1,14 @@
+-- 水票配送订单：配送流程字段（需在数据库执行）
+-- 表：glt_ticket_order
+
+ALTER TABLE glt_ticket_order2
+  ADD COLUMN delivery_status INT NULL DEFAULT 10 COMMENT '配送状态：10待配送、20配送中、30待客户确认、40已完成',
+  ADD COLUMN send_start_time DATETIME NULL COMMENT '开始配送时间',
+  ADD COLUMN send_end_time DATETIME NULL COMMENT '确认送达时间',
+  ADD COLUMN send_end_img VARCHAR(512) NULL COMMENT '送达拍照留档图片URL',
+  ADD COLUMN receive_confirm_time DATETIME NULL COMMENT '客户确认收货时间',
+  ADD COLUMN receive_confirm_type INT NULL COMMENT '确认方式：10手动、20照片、30超时';
+
+CREATE INDEX idx_glt_ticket_order_rider_status ON glt_ticket_order (tenant_id, rider_id, delivery_status, deleted);
+CREATE INDEX idx_glt_ticket_order_user_status ON glt_ticket_order (tenant_id, user_id, delivery_status, deleted);
+

docs/一站式平台对接-接口文档.md

@@ -1,260 +0,0 @@
-# 汇吉采 ↔ 一站式代理平台 对接接口文档
-
-> 版本：v1.0
-> 适用：汇吉采标书购买平台（下称「官方网」）与一站式代理平台（下称「一站式」）之间双向数据互通。
-> 相关：鉴权规则见 `docs/一站式平台推送-接口鉴权规范.md`；建表见 `src/main/resources/sql/hjc_init.sql`。
-
----
-
-## 0. 概述
-
-| 方向 | 触发时机 | 接口 | 位置 |
-|---|---|---|---|
-| **入向**（一站式 → 官方网） | 项目流程走到「发布中标公告」时 | `POST {官方网}/api/hjc/push/project` | 官方网接收标书/中标公告数据，按 `projectNo` upsert 落库 |
-| **出向**（官方网 → 一站式） | C 端购买标书**支付成功后** / 退款时 | `POST {一站式}/api/biz/createPurchaseDetails` | 官方网把购买记录/订单信息推送到一站式落盘 |
-
-**共享凭证**（双方约定，不通过网络传输明文密钥）：
-
-| 参数 | 值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 调用方标识，明文放请求头 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | 签名密钥（Secret），仅参与签名，**不进报文** |
-
----
-
-## 1. 鉴权规范（双向通用）
-
-请求头携带：
-
-| Header | 示例 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 双方一致 |
-| `timestamp` | `202604080103` | 格式 `yyyyMMddHHmm`（24 小时，北京时区，精确到分） |
-| `sign` | `9f7c…（32位小写hex）` | 签名值 |
-
-**签名算法**：`sign = MD5(appKey + password + timestamp)`（无分隔符，小写 32 位）。
-
-**校验顺序**（任一步不过即拒绝，建议返回 `401`/`400`）：
-1. `appKey == HJC_Official_Website`
-2. `timestamp` 与接收方服务器当前时间差 **≤ ±10 分钟**（防重放）
-3. 用约定 `password` 重算 `MD5(appKey+password+timestamp)`，与 `sign` 不区分大小写比对
-
-> 完整规则、示例（Python/Java）与「明文 password 头」兼容退路见 `docs/一站式平台推送-接口鉴权规范.md`。
-
----
-
-## 2. 入向接口：一站式 → 官方网（接收标书/中标公告）
-
-### 2.1 接口地址
-
-```
-POST {官方网BaseUrl}/api/hjc/push/project
-```
-
-> 官方网侧需在 SecurityConfig 放行该路径（已内置，`/api/hjc/push/project` 为公开接口，鉴权由本接口的 appKey/sign 自行校验）。
-
-### 2.2 请求头
-
-| Header | 值 |
-|---|---|
-| `appKey` | `HJC_Official_Website` |
-| `timestamp` | `yyyyMMddHHmm` |
-| `sign` | `MD5(appKey+password+timestamp)` |
-| `tenantId` | `10626`（官方网当前固定租户，**必传**，作为落库租户） |
-| `Content-Type` | `application/json` |
-
-### 2.3 请求体字段
-
-| 字段 | 类型 | 必填 | 说明 | 对应内部字段 |
-|---|---|---|---|---|
-| `projectNo` | string | ✔ | 项目编号 | `project_no`（upsert 主键） |
-| `projectName` | string | ✔ | 项目名称 | `project_name` |
-| `tenderPrice` | number | | 标书价格/信息服务费 | `tender_price` |
-| `files` | string(JSON/逗号分隔) | | 标书附件 | `tender_file` |
-| `tenderOnsaleTime` | string | | 开售时间 `yyyy-MM-dd HH:mm:ss` | `onsale_time` |
-| `tenderOffsaleTime` | string | | 停售时间 `yyyy-MM-dd HH:mm:ss` | `offsale_time` |
-| `bulletinName` | string | | 公告标题 | `bulletin_title` |
-| `customerName` | string | | 招标人 | `tenderer` |
-| `supplierName` | string | | 中标公司 | `winner_supplier` |
-| `bidAmount` | number | | 中标金额 | `bid_amount` |
-| `content` | string | | 公告正文 | `bulletin_content` |
-| `fileList` | string(JSON/逗号分隔) | | 公告附件 | `bulletin_file_list` |
-| `needSellTender` | number | | 是否卖标书 0/1 | `need_sell` |
-| `sellingMethod` | number | | 售卖方式 1公司财务 2公众号 3交易中心 4政采云 | `selling_method` |
-
-### 2.4 响应
-
-```json
-{
-  "code": 0,
-  "message": "接收成功",
-  "data": { "id": 12, "projectNo": "ZB-2026-0001", "projectName": "xxx", "dataSource": "PUSH", "status": 1 }
-}
-```
-- `code == 0` 成功；`code != 0` 失败（如 `message=鉴权失败` / `租户ID不能为空` / `项目编号不能为空`）。
-
-### 2.5 落库规则（官方网侧）
-
-- 按 `projectNo` **upsert**：不存在则插入（`tenantId=请求头tenantId`，`status=1` 上架，`dataSource=PUSH`，`saleCount=0`）；已存在则更新推送到字段。
-- 兼容性：`tenderOnsaleTime`/`tenderOffsaleTime` 支持 `yyyy-MM-dd HH:mm:ss`、`yyyyMMddHHmmss`、ISO 带 `T` 三种格式解析；解析失败置空。
-- 其余标书项目字段（分类、上下架、人工维护数据）仍可在管理后台手工调整。
-
----
-
-## 3. 出向接口：官方网 → 一站式（推送购买记录/订单）
-
-### 3.1 接口地址
-
-```
-POST {一站式BaseUrl}/api/biz/createPurchaseDetails
-```
-
-### 3.2 触发时机
-
-- **支付成功后**（官方网 `PUT /api/hjc/order/mark-paid` 置已付）自动推送，请求状态 `status=PAID`。
-- **退款时**（官方网 `POST /api/hjc/order/refund` 置已退款）推送，请求状态 `status=REFUNDED`，**必须**携带 `refundTime`（退款时间）与 `refundReason`（退款原因）。
-  - `refundTime`：官方网记录退款动作发生时间（服务器时间），落库 `hjc_order.refund_time`。
-  - `refundReason`：后台退款弹窗填写（≤200 字），落库 `hjc_order.refund_reason`；未填写时取默认「管理员操作退款」。
-  - 推送失败进重试队列后，重试报文的退款时间/原因按订单落库值重建，不会丢失。
-
-### 3.3 请求头
-
-| Header | 值 |
-|---|---|
-| `appKey` | `HJC_Official_Website` |
-| `timestamp` | `yyyyMMddHHmm` |
-| `sign` | `MD5(appKey+password+timestamp)` |
-| `Content-Type` | `application/json` |
-
-> `password` 不进请求头；`sign` 每次发送须按新的 `timestamp` 重新计算。
-
-### 3.4 请求体字段
-
-| 字段 | 类型 | 说明 |
-|---|---|---|
-| `idempotencyKey` | string | 幂等键，`HJC_ORD_<orderNo>` |
-| `orderNo` | string | 官方网订单号（一站式去重键） |
-| `projectNo` | string | 项目编号 |
-| `projectName` | string | 项目名称 |
-| `tenderPrice` | number | 标书单价（信息服务费） |
-| `quantity` | number | 购买数量 |
-| `totalAmount` | number | 订单总额 |
-| `buyer.enterpriseName` | string | 购买企业名称 |
-| `buyer.creditCode` | string | 企业统一社会信用代码 |
-| `buyer.contactName` | string | 经办人姓名 |
-| `buyer.contactPhone` | string | 经办人手机号 |
-| `buyer.contactEmail` | string | 经办人邮箱 |
-| `paidAt` | string | 支付时间 `yyyy-MM-dd HH:mm:ss` |
-| `payMethod` | string | `WECHAT_NATIVE` / `ALIPAY` |
-| `status` | string | `PAID`（已支付）/ `REFUNDED`（已退款） |
-| `refundTime` | string | **退款时必传**，退款时间 `yyyy-MM-dd HH:mm:ss`（`status=REFUNDED` 时推送，其余状态不出现在报文中） |
-| `refundReason` | string | **退款时必传**，退款原因（≤255 字符；后台未填写时取默认「管理员操作退款」） |
-| `invoiceStatus` | string | `NONE` / `APPLIED` / `ISSUED` |
-
-请求体示例：
-
-```json
-{
-  "idempotencyKey": "HJC_ORD_HJC2026080101ABCD",
-  "orderNo": "HJC2026080101ABCD",
-  "projectNo": "ZB-2026-0001",
-  "projectName": "xxx采购项目",
-  "tenderPrice": 500.00,
-  "quantity": 1,
-  "totalAmount": 500.00,
-  "buyer": {
-    "enterpriseName": "某某科技有限公司",
-    "creditCode": "91110XXXX",
-    "contactName": "张三",
-    "contactPhone": "13800000000",
-    "contactEmail": "a@b.com"
-  },
-  "paidAt": "2026-08-01 10:30:00",
-  "payMethod": "WECHAT_NATIVE",
-  "status": "PAID",
-  "invoiceStatus": "NONE"
-}
-```
-
-退款推送请求体示例（`status=REFUNDED`，多出 `refundTime`/`refundReason`）：
-
-```json
-{
-  "idempotencyKey": "HJC_ORD_HJC2026080101ABCD",
-  "orderNo": "HJC2026080101ABCD",
-  "projectNo": "ZB-2026-0001",
-  "projectName": "xxx采购项目",
-  "tenderPrice": 500.00,
-  "quantity": 1,
-  "totalAmount": 500.00,
-  "buyer": {
-    "enterpriseName": "某某科技有限公司",
-    "creditCode": "91110XXXX",
-    "contactName": "张三",
-    "contactPhone": "13800000000",
-    "contactEmail": "a@b.com"
-  },
-  "paidAt": "2026-08-01 10:30:00",
-  "payMethod": "WECHAT_NATIVE",
-  "status": "REFUNDED",
-  "refundTime": "2026-08-03 09:15:00",
-  "refundReason": "项目终止，客户申请退款",
-  "invoiceStatus": "NONE"
-}
-```
-
-### 3.5 响应约定
-
-- 一站式按自身 `API` 返回；官方网侧把 `HTTP 2xx` 视为成功，否则记入推送日志（`hjc_order_push_log`）待重试。
-- **幂等**：建议一站式以 `orderNo`/`idempotencyKey` 去重，同单重复提交返回成功、不重复插入。
-
-### 3.6 重试策略（官方网侧）
-
-- 失败（非 2xx / 网络异常）写入 `push_status=2`，`next_retry_time = now + 30min`，`attempt_count + 1`。
-- 由定时任务 `retryPendingPush()` 扫描待推送/失败记录重发；重发时 `timestamp/sign` 重新计算。
-
----
-
-## 4. 字段映射总表
-
-| 一站式字段 | 含义 | 官方网内部字段 |
-|---|---|---|
-| `projectNo` | 项目编号 | `hjc_bid_project.project_no` |
-| `projectName` | 项目名称 | `project_name` |
-| `tenderPrice` | 标书价格 | `tender_price` |
-| `files` | 标书附件 | `tender_file` |
-| `tenderOnsaleTime` | 开售时间 | `onsale_time` |
-| `tenderOffsaleTime` | 停售时间 | `offsale_time` |
-| `bulletinName` | 公告标题 | `bulletin_title` |
-| `customerName` | 招标人 | `tenderer` |
-| `supplierName` | 中标公司 | `winner_supplier` |
-| `bidAmount` | 中标金额 | `bid_amount` |
-| `content` | 公告正文 | `bulletin_content` |
-| `fileList` | 公告附件 | `bulletin_file_list` |
-| `needSellTender` | 是否卖标书 | `need_sell` |
-| `sellingMethod` | 售卖方式 | `selling_method` |
-| `refundTime` | 退款时间（出向） | `hjc_order.refund_time` |
-| `refundReason` | 退款原因（出向） | `hjc_order.refund_reason` |
-
----
-
-## 5. 配置清单（待双方/部署方填写）
-
-| 项 | 值 | 位置 |
-|---|---|---|
-| 官方网 base-url | `http://<官方网域名>/api` | 一站式侧调用方配置 |
-| 一站式 base-url | `http://<一站式域名>` | `mp-java/application.yml` → `hjc.one-stop.base-url` |
-| createPurchaseDetails 路径 | `/api/biz/createPurchaseDetails` | `hjc.one-stop.create-purchase-details-path` |
-| `appKey` | `HJC_Official_Website` | 双方约定 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | 双方约定 |
-| 租户 ID | `10626` | 官方网请求头 `tenantId` |
-
----
-
-## 6. 待确认事项
-
-1. 出向 `sign` 拼接顺序（`appKey+password+timestamp`）与一站式既有算法是否一致；不一致请给出一站式现网签名规范。
-2. `timestamp` 格式、时区、±10min 窗口是否认可。
-3. `createPurchaseDetails` 字段名是否需与一站式现网入参完全一致（现按本表定义）；如需调整字段名请给出一站式入参清单。
-4. 入向：一站式调用官方网 `/api/hjc/push/project` 时是否也按同一套 `appKey/timestamp/sign` 鉴权（本表默认对称鉴权）。
-5. 退款字段名 `refundTime` / `refundReason` 与一站式现网入参是否一致；格式默认 `yyyy-MM-dd HH:mm:ss`，如一站式要求其他命名或时间格式请同步调整 `CreatePurchaseDetails`。

docs/一站式平台推送-接口鉴权规范.md

@@ -1,130 +0,0 @@
-# 汇吉采 → 一站式代理平台：标书订单推送接口鉴权规范
-
-> 用途：本文档是**本平台（汇吉采标书购买平台，下称「官方网」）调用一站式代理平台接口**时的鉴权规范，用于对接一站式平台开发人员，请对方按此规则在服务端做校验。
-> 目标接口：`POST /api/biz/createPurchaseDetails`（本平台推送购买记录与订单信息到一站式平台落盘）
-
----
-
-## 1. 共享凭证（双方提前约定，不通过网络传输）
-
-| 参数 | 值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 调用方标识，明文放在请求头 |
-| `password` | `vQ8$kR3#mW6@xP2!nF` | **签名密钥（Secret）**，仅双方服务端持有，**不放在请求头、不出现于任何请求/日志/报文** |
-
-> ⚠️ 出于安全考虑，本规范**不把 `password` 明文放请求头**。原始需求中「把 password 明文字段加到请求头」的做法会泄露密钥，改为「用 password 参与签名、请求头只带签名结果」的等价且更安全的方案（见第 3 节）。如需严格沿用原始「明文 password 头」方案，见附录 A。
-
----
-
-## 2. 请求头（请求方——官方网——每次调用携带 3 个）
-
-| Header | 示例值 | 说明 |
-|---|---|---|
-| `appKey` | `HJC_Official_Website` | 明文 appKey（固定值） |
-| `timestamp` | `202604080103` | 签名时间，格式 `yyyyMMddHHmm`（24 小时制，北京时区，精确到分钟） |
-| `sign` | `9f7c…（32 位小写十六进制）` | 签名值，算法见第 3 节 |
-
-另需：`Content-Type: application/json`。
-
----
-
-## 3. 签名算法
-
-```
-sign = MD5( appKey + password + timestamp )
-```
-
-- `+` 表示**字符串直接拼接**，中间无分隔符。
-- `timestamp` 使用与请求头 `timestamp` **完全相同**的值。
-- `MD5` 输出**小写** 32 位十六进制字符串。
-
-步骤：
-
-1. 取当前北京时间的分钟表示 `timestamp = yyyyMMddHHmm`（例：`2026-04-08 01:03` → `202604080103`）。
-2. 拼串：`HJC_Official_Website` + `vQ8$kR3#mW6@xP2!nF` + `202604080103`。
-3. 对该字符串做 MD5，转小写，得到 `sign`。
-4. 将 `appKey`、`timestamp`、`sign` 放入请求头发出。
-
----
-
-## 4. 校验规则（一站式平台服务端）
-
-收请求后按以下顺序校验，任一步不通过即拒绝（建议返回 `401` / `400`，并附错误码与说明，便于排查）：
-
-1. **校验 appKey**：`appKey` 是否等于已登记的应用标识 `HJC_Official_Website`。不等 → 拒绝。
-2. **校验 timestamp 时效（防重放）**：`timestamp` 与**一站式服务器当前时间**之差是否在 **±10 分钟**以内（统一按北京时区、分钟精度）。超出窗口 → 拒绝，提示「时间戳失效」。
-   - 该窗口同时限制了重放窗口；如需更严可协商收紧到 ±3 分钟。
-3. **校验签名**：用共享的 `password` 重算 `MD5(appKey + password + timestamp)`，与请求头 `sign` **不区分大小写**比较（统一小写后比较）。不一致 → 拒绝，提示「签名校验失败」。
-4. 校验通过后，按请求体 `createPurchaseDetails` 的字段约定解析并落盘（业务字段见单独一节的「createPurchaseDetails 请求体字段表」）。
-
----
-
-## 5. 幂等与重试约定（可选但强烈建议）
-
-`createPurchaseDetails` 是「落盘」类写操作，本平台侧会做失败重试，因此建议一站式平台按业务主键幂等处理，避免重复落盘：
-
-- 请求体需带唯一业务单号（如 `purchaseId` / `orderNo`），一站式平台以此作为去重键；**同一单号重复提交时应返回成功、不重复插入**（或返回「已存在」）。
-- 本平台对失败的推送会按 `attempt` 递增重试（建议：1/2/4/8 分钟间隔），重试时 `timestamp/sign` 需要**重新计算**（每次请求都要以新时间重签）。
-
----
-
-## 6. 双端示例
-
-**官方网（请求方）**——以 Python 为例：
-
-```python
-import hashlib, time, requests
-
-app_key = "HJC_Official_Website"
-password = "vQ8$kR3#mW6@xP2!nF"
-ts = time.strftime("%Y%m%d%H%M")            # 202604080103
-sign = hashlib.md5((app_key + password + ts).encode("utf-8")).hexdigest()
-
-resp = requests.post(
-    "https://<一站式域名>/api/biz/createPurchaseDetails",
-    json={ ... 业务字段 ... },
-    headers={
-        "appKey": app_key,
-        "timestamp": ts,
-        "sign": sign,
-        "Content-Type": "application/json",
-    },
-    timeout=15,
-)
-```
-
-**一站式（校验方）**——以 Java 为例：
-
-```java
-String appKey = req.getHeader("appKey");
-String ts     = req.getHeader("timestamp");
-String sign   = req.getHeader("sign");
-
-if (!"HJC_Official_Website".equals(appKey)) return 401;                       // 1
-if (Math.abs(System.currentTimeMillis() / 60000 - parseMinute(ts)) > 10)
-    return 401;                                                               // 2
-String expect = md5("HJC_Official_Website" + SECRET + ts);                   // 3
-if (!expect.equalsIgnoreCase(sign)) return 401;
-
-// 4. 解析 body，按 createPurchaseDetails 字段落盘（按 orderNo 幂等）
-```
-
----
-
-## 附录 A：若一站式平台坚持「明文 password 头」的原始方案
-
-原始需求表述为「请求头添加 appKey、password，appKey+年月日时分、password+年月日时分，MD5 加密」。若对方已按此固定算法实现，则采用：
-
-- 请求头：`appKey=HJC_Official_Website`、`password=vQ8$kR3#mW6@xP2!nF`、`sign=MD5(password + yyyyMMddHHmm)`（小写）。
-- 校验：`password` 需与约定值一致，且 `MD5(password + timestamp) == sign`，同时 `timestamp` 在 ±10 分钟内。
-
-> 该方案会把 `password` 以明文形式暴露在报文中，安全性差；**仅作兼容退路，不作为默认推荐**。若对方无法确认固定算法，请首选第 1–6 节的方案。
-
----
-
-## 附：需要一站式平台确认/提供的信息
-
-1. 上述 `sign` 拼接顺序是否与合作方既有算法一致（`appKey+password+timestamp`）。
-2. 时间戳格式 `yyyyMMddHHmm` 与北京时区是否认可。
-3. 校验窗口 ±10 分钟是否可接受。
-4. `createPurchaseDetails` 请求体字段表（本平台另一份文档，见需求/接口清单）的具体入参名与必填项，需对方给出或双方对齐，以免字段名不一致导致落盘失败。

docs/水票配送订单-后端提示词.md

@@ -0,0 +1,98 @@
+# 水票配送订单：后端提示词（可直接发给后端）
+
+> 目标：把“水票下单后 -> 配送员接单/配送 -> 用户确认 -> 自动确认”的闭环放到后端，用明确的字段 + 状态机校验保证不越权、不乱跳状态、并发不重复接单。
+>
+> 接口前缀：当前后端控制器为 `@RequestMapping("/api/glt/glt-ticket-order")`，下文默认都带 `/api` 前缀（如需兼容旧路径，可做网关转发或保留旧路由）。
+
+## 0) 角色与权限边界（务必在后端兜底）
+- 用户端（小程序用户）：只能看/操作自己的订单（`userId` = token userId）。
+- 配送员端：只能看/操作分配给自己的订单（`riderId` = token userId / rider userId）。
+- 管理端：按后台权限控制（可查询/派单/改状态，但仍需 tenantId 隔离）。
+
+建议：对“配送员端接口”忽略前端传入的 `riderId/userId/tenantId`，统一从登录态注入，避免越权。
+
+## 1) 订单查询（配送员端）
+建议提供配送员专用分页接口：`GET /api/glt/glt-ticket-order/rider/page`（避免与后台管理分页混用）。
+请支持以下筛选，并保证权限隔离：
+- `deliveryStatus`：10待配送、20配送中、30待客户确认、40已完成（配送员端必要；不传默认=10）
+- `keywords`：支持按地址/备注等模糊搜索（可选）
+- 排序：建议默认 `sendTime asc, createTime desc`（或沿用后端默认排序，但请告知前端）
+
+权限隔离要求（配送员端）：
+- 只返回当前登录配送员的订单：后端强制 `param.riderId = loginUserId`（前端传不传都一样）。
+- `tenantId/deleted` 等同样后端兜底（只查当前租户、只查未删除）。
+
+返回字段建议（配送员端用得上）：
+- 门店/仓库/用户/配送员的展示字段：`storeName/storeAddress/storePhone`、`warehouseName/warehouseAddress`、`nickname/phone/avatar`、`riderName/riderPhone`（现有 `pageRel/listRel` 已在做关联返回）。
+- 导航相关（详见第 5 节）：收货地址 `lat/lng`、门店/仓库 `lngAndLat`（可关联返回或做快照字段）。
+
+## 2) 配送流程字段（建议后端落库并回传）
+订单表建议确保有以下字段（当前前端已按这些字段做流程判断/展示）：
+- `riderId/riderName/riderPhone`：配送员信息
+- `deliveryStatus`：10/20/30/40
+- `sendStartTime`：配送员点击“开始配送”的时间（建议 datetime）
+- `sendEndTime`：配送员点击“确认送达”的时间（建议 datetime）
+- `sendEndImg`：送达拍照留档图片 URL（可选/必填由后端策略决定；建议 varchar(512)）
+- `receiveConfirmTime`：客户确认收货时间（建议 datetime）
+- `receiveConfirmType`：10客户手动确认、20配送照片自动确认、30超时自动确认
+
+数据库变更（示例SQL见：`docs/sql/2026-02-06_glt_ticket_order_delivery_fields.sql`）。
+
+强烈建议把“配送状态”与“业务状态(status=0/1、deleted=0/1)”分开，避免混用：
+- `status/deleted`：系统通用字段（现有逻辑）
+- `deliveryStatus`：配送流程状态（本需求新增）
+
+## 3) 状态流转与校验（强烈建议在后端做）
+请在更新订单时做状态机校验，避免前端绕过流程：
+- `10 -> 20`：仅允许订单属于当前配送员，且未开始/未送达
+- `20 -> 30`：配送员确认送达（可带 `sendEndImg`）
+- `20/30 -> 40`：完成；来源可能是
+  - 客户手动确认（写 `receiveConfirmTime` + `receiveConfirmType=10`）
+  - 配送照片直接完成（写 `receiveConfirmTime` + `receiveConfirmType=20`，并要求 `sendEndImg`）
+  - 超时自动确认（写 `receiveConfirmTime` + `receiveConfirmType=30`，建议由定时任务执行）
+
+并发/幂等建议（避免重复点击/重复请求带来的脏数据）：
+- 所有“状态变更接口”用条件更新实现原子校验：`UPDATE ... SET ... WHERE id=? AND rider_id=? AND delivery_status=? AND deleted=0`
+- 对重复调用做幂等：
+  - `start`：如果已是 20 则直接返回成功；如果已到 30/40 返回“状态不允许”
+  - `delivered`：如果已是 30/40 则返回成功（或提示已送达）；避免重复写 `sendEndTime`
+  - `confirm-receive`：如果已是 40 则返回成功（或提示已完成）
+
+## 4) 建议新增/明确的接口能力
+为了避免并发抢单/越权更新，建议新增更语义化的接口（或在 update 内做等价校验）：
+- 接单（抢单/派单）：`POST /api/glt/glt-ticket-order/{id}/accept`
+  - 配送员端：后端原子校验：仅当 `rider_id IS NULL`（或为 0）时才能写入当前 rider 信息
+  - 管理端派单：允许传 `riderId`，但需校验骑手归属门店/租户（如有该约束）
+- 开始配送：`POST /api/glt/glt-ticket-order/{id}/start`
+  - 写：`sendStartTime=now`、`deliveryStatus=20`
+  - 校验：必须 `riderId=当前登录配送员` 且当前 `deliveryStatus=10`
+- 确认送达：`POST /api/glt/glt-ticket-order/{id}/delivered`
+  - 入参：`sendEndImg`（可选/必填，按策略）
+  - 写：`sendEndTime=now`、`deliveryStatus=30`、`sendEndImg`
+  - 可选策略 A（推荐可配置）：若 `sendEndImg` 必填且存在，则可直接 `deliveryStatus=40` 并写 `receiveConfirmTime/Type=20`
+- 客户确认收货：`POST /api/glt/glt-ticket-order/{id}/confirm-receive`
+  - 校验：只能本人 `userId` 操作，且必须 `deliveryStatus=30`
+  - 写：`deliveryStatus=40`、`receiveConfirmTime=now`、`receiveConfirmType=10`
+
+接口返回建议：
+- 成功统一返回 `ApiResult.success(...)`
+- 失败请返回明确 msg（例如：`无权限`、`订单不存在`、`订单状态不允许`、`订单已被其他配送员接单`）
+
+## 5) 为了“导航到收货地址/取货点”的字段补充（建议）
+当前仅有 `address` 字符串，无法在小程序内 `openLocation` 精准导航；建议补充：
+- 收货地址（推荐至少返回）：`receiverName`、`receiverPhone`、`province/city/region/address/fullAddress`、`lat/lng`
+- 取货点（门店/仓库，推荐至少返回）：`store.lngAndLat`、`warehouse.lngAndLat`
+
+实现方式二选一：
+- 方式 A（更快）：查询时关联 `shop_user_address`、`shop_store`、`shop_warehouse`，把经纬度字段透出给前端。
+- 方式 B（更稳）：下单时把收货地址的 `name/phone/lat/lng/fullAddress` 以及门店/仓库 `lngAndLat` 做快照写入订单，避免后续数据变更影响历史订单导航。
+
+## 6)（可选但很有用）超时自动确认规则
+- 建议后端提供可配置项：`autoConfirmHours`（例如 24h/48h）
+- 定时任务扫描：`deliveryStatus=30` 且 `sendEndTime < now - autoConfirmHours` 的订单
+- 原子更新：只更新仍处于 30 的订单，写入 `deliveryStatus=40`、`receiveConfirmTime=now`、`receiveConfirmType=30`
+
+## 7)（可选）字段/枚举建议（便于前后端对齐）
+- `deliveryStatus`：10待配送、20配送中、30待客户确认、40已完成
+- `receiveConfirmType`：10客户手动确认、20配送照片自动确认、30超时自动确认
+- 时间字段统一返回格式：`yyyy-MM-dd HH:mm:ss`（与项目现有 `@JsonFormat` 风格一致）

pom.xml

@@ -38,6 +38,11 @@
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <scope>test</scope>
+    </dependency>
 
     <!-- spring-boot-web -->
     <dependency>
@@ -213,8 +218,6 @@
       <artifactId>aliyun-java-sdk-core</artifactId>
       <version>4.4.3</version>
     </dependency>
-    <!-- 证件 OCR（身份证/营业执照识别）已改用百度云 REST 接口，不再依赖 aliyun-java-sdk-ocr：
-         理由见 ADR-0003《证件 OCR 改用百度云》，调用封装在 com.gxwebsoft.hjc.ocr.HjcBaiduOcrClient -->
     <!--阿里支付 老版本 SDK-->
     <dependency>
       <groupId>com.alipay.sdk</groupId>

scripts/fix-chinese-font.sh

@@ -1,125 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# 捐款证书中文乱码修复脚本
-# 用途：在运行中的Docker容器内安装中文字体
-# 适用于：无法重新构建镜像的紧急情况
-###############################################################################
-
-set -e  # 遇到错误立即退出
-
-# 颜色输出
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 容器名称（可根据实际情况修改）
-CONTAINER_NAME="websoft-api-container"
-
-echo -e "${GREEN}================================${NC}"
-echo -e "${GREEN}中文字体修复脚本${NC}"
-echo -e "${GREEN}================================${NC}"
-echo ""
-
-# 检查容器是否存在
-echo -e "${YELLOW}步骤 1/6: 检查容器状态...${NC}"
-if ! docker ps | grep -q "$CONTAINER_NAME"; then
-    echo -e "${RED}错误：容器 $CONTAINER_NAME 未运行！${NC}"
-    echo "当前运行的容器："
-    docker ps --format "table {{.Names}}\t{{.Status}}"
-    echo ""
-    read -p "请输入正确的容器名称: " CONTAINER_NAME
-    if [ -z "$CONTAINER_NAME" ]; then
-        echo -e "${RED}容器名称不能为空，退出。${NC}"
-        exit 1
-    fi
-fi
-echo -e "${GREEN}✓ 容器正在运行${NC}"
-echo ""
-
-# 检查是否已安装字体
-echo -e "${YELLOW}步骤 2/6: 检查是否已安装中文字体...${NC}"
-if docker exec "$CONTAINER_NAME" fc-list :lang=zh 2>/dev/null | grep -q "WenQuanYi"; then
-    echo -e "${GREEN}✓ 中文字体已安装${NC}"
-    docker exec "$CONTAINER_NAME" fc-list :lang=zh
-    echo ""
-    read -p "是否重新安装？(y/N): " REINSTALL
-    if [[ ! "$REINSTALL" =~ ^[Yy]$ ]]; then
-        echo "跳过安装，退出。"
-        exit 0
-    fi
-else
-    echo -e "${YELLOW}未检测到中文字体，开始安装...${NC}"
-fi
-echo ""
-
-# 安装字体工具
-echo -e "${YELLOW}步骤 3/6: 安装字体工具...${NC}"
-docker exec -u root "$CONTAINER_NAME" sh -c "apk add --no-cache fontconfig ttf-dejavu wget" || {
-    echo -e "${RED}✗ 字体工具安装失败${NC}"
-    exit 1
-}
-echo -e "${GREEN}✓ 字体工具安装成功${NC}"
-echo ""
-
-# 下载中文字体
-echo -e "${YELLOW}步骤 4/6: 下载文泉驿微米黑字体...${NC}"
-echo "正在从GitHub下载（约10MB），请稍候..."
-docker exec -u root "$CONTAINER_NAME" sh -c "
-    wget -O /tmp/wqy-microhei.ttc https://github.com/anthonyfok/fonts-wqy-microhei/raw/master/wqy-microhei.ttc 2>&1 | grep -E 'Connecting|Length|saved' || true
-" || {
-    echo -e "${YELLOW}GitHub下载失败，尝试使用代理...${NC}"
-    docker exec -u root "$CONTAINER_NAME" sh -c "
-        wget -O /tmp/wqy-microhei.ttc https://ghproxy.com/https://github.com/anthonyfok/fonts-wqy-microhei/raw/master/wqy-microhei.ttc
-    " || {
-        echo -e "${RED}✗ 字体下载失败${NC}"
-        echo "请检查网络连接或手动下载字体文件。"
-        exit 1
-    }
-}
-echo -e "${GREEN}✓ 字体下载成功${NC}"
-echo ""
-
-# 安装字体
-echo -e "${YELLOW}步骤 5/6: 安装字体文件...${NC}"
-docker exec -u root "$CONTAINER_NAME" sh -c "
-    mkdir -p /usr/share/fonts/truetype/wqy && \
-    mv /tmp/wqy-microhei.ttc /usr/share/fonts/truetype/wqy/ && \
-    fc-cache -fv
-" || {
-    echo -e "${RED}✗ 字体安装失败${NC}"
-    exit 1
-}
-echo -e "${GREEN}✓ 字体安装成功${NC}"
-echo ""
-
-# 验证安装
-echo -e "${YELLOW}步骤 6/6: 验证字体安装...${NC}"
-FONT_COUNT=$(docker exec "$CONTAINER_NAME" fc-list :lang=zh | wc -l)
-if [ "$FONT_COUNT" -gt 0 ]; then
-    echo -e "${GREEN}✓ 中文字体验证成功！${NC}"
-    echo "已安装的中文字体："
-    docker exec "$CONTAINER_NAME" fc-list :lang=zh
-else
-    echo -e "${RED}✗ 字体验证失败${NC}"
-    exit 1
-fi
-echo ""
-
-# 完成提示
-echo -e "${GREEN}================================${NC}"
-echo -e "${GREEN}修复完成！${NC}"
-echo -e "${GREEN}================================${NC}"
-echo ""
-echo "后续步骤："
-echo "1. 不需要重启容器，字体已生效"
-echo "2. 重新生成捐款证书即可看到效果"
-echo "3. 如果仍有问题，请查看容器日志："
-echo "   docker logs -f $CONTAINER_NAME"
-echo ""
-echo -e "${YELLOW}注意：${NC}"
-echo "- 此修复方法在容器重启后会失效"
-echo "- 建议后续使用更新后的Dockerfile重新构建镜像"
-echo "- 详细文档请参考：docs/chinese-font-fix-guide.md"
-echo ""

scripts/generate-nanning-knowledge-seed.js

@@ -1,546 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const projectRoot = path.resolve(__dirname, '..');
-const sqlDirectory = path.join(projectRoot, 'src', 'main', 'resources', 'sql');
-const dataPath = path.join(sqlDirectory, '南宁房产知识库结构化表格.json');
-const seedPath = path.join(sqlDirectory, 'house_knowledge_seed.sql');
-const startMarker = '-- NANNING_STRUCTURED_DATA_START';
-const endMarker = '-- NANNING_STRUCTURED_DATA_END';
-const sourceNote = '本地业务资料《南宁房产知识库结构化表格.json》导入，待后台复核';
-
-const data = JSON.parse(fs.readFileSync(dataPath, 'utf8'));
-const offices = data['南宁写字楼信息表'] || [];
-const communities = data['南宁住宅小区信息表'] || [];
-const businessDistrictOverrides = {
-  '五象航洋城': '五象航洋城商圈'
-};
-const officialLocationEntries = [
-  {
-    region: '青秀区', businessDistrict: '青秀万达',
-    title: '滨湖路站连接青秀万达与南湖公共配套',
-    content: '南宁轨道交通3号线滨湖路站位于滨湖路与长湖路交汇处，北邻青秀万达、南近南湖公园。B口周边有南湖公园和南宁市卫生健康委员会，C口周边有南宁市第二妇幼保健院、南宁市口腔医院，D口周边有南宁市第五十四中学、埌东小学。',
-    tags: ['轨道交通', '商业配套', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《滨湖路站》 http://www.nngdjt.com/html/service1c/line/0313.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '东盟商务区',
-    title: '万象城站的商业、办公与公园配套',
-    content: '南宁轨道交通1号线万象城站位于东盟商务区核心区，设置在民族大道与青秀路、景秀路交叉路口地下。运营方列示，A口连接水电大厦等办公区，C口可通向万象城购物消费中心，B口周边有石门森林公园和多个居住小区。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公园绿地'],
-    sourceNote: '南宁轨道交通集团有限责任公司《万象城站》 http://www.nngdjt.com/html/service1c/line/0119.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '东盟商务区',
-    title: '东盟商务区站周边商业、金融与社区卫生服务',
-    content: '南宁轨道交通1号线东盟商务区站位于民族大道北侧。运营方列示，A、D口靠近凤岭儿童公园，B、C口周边有三祺广场、广西金融广场、东盟财经中心、东盟盛天地等商业和办公配套；D口周边有青秀区南湖凤岭北社区卫生服务中心。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《东盟商务区站》 http://www.nngdjt.com/html/service1c/line/0120.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭北',
-    title: '凤岭儿童公园的公园绿地与休闲配套',
-    content: '凤岭儿童公园位于南宁市青秀区凤岭片区北侧核心区，北临月湾路、南面云景路，与凤岭冲沟相邻，占地834亩。政府页面记载，公园建设包括园内道路、基础绿化、园林构筑、广场铺装、公共设施和配套服务设施。',
-    tags: ['公园绿地', '文化休闲', '运动健身'],
-    sourceNote: '南宁市人民政府《凤岭儿童公园》 https://www.nanning.gov.cn/zjnn/nnly/t2566232.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭北',
-    title: '凤岭站连接凤岭居住区、教育与公园',
-    content: '南宁轨道交通1号线凤岭站位于凤岭立交以东、民族大道北侧。运营方列示，B1口周边有南宁市第一幼儿园青林分园，B2口周边有南宁市翡翠园学校，C口通向埌东公园；埌东客运站位于车站以东约900米处。',
-    tags: ['轨道交通', '公共服务', '公园绿地'],
-    sourceNote: '南宁轨道交通集团有限责任公司《凤岭站》 http://www.nngdjt.com/html/service1c/line/0121.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '埌东客运站片区',
-    title: '埌东客运站的公路客运与地铁接驳',
-    content: '埌东客运站位于民族大道东端与仙葫大道交叉处，地面上方为埌东汽车客运站。站点B、C口对应客运站一侧，E口周边为市公交总站，可作为片区公路客运、公交与地铁接驳信息使用。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《埌东客运站》 http://www.nngdjt.com/html/service1c/line/0122.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '会展中心',
-    title: '会展中心站与航洋国际城及会展配套',
-    content: '会展中心站位于民族大道与会展路交叉路口。B、B1口通往南宁国际会展中心，D口无缝连接航洋国际城；官方资料将该站周边规划概括为居住、商业及行政办公用地。',
-    tags: ['轨道交通', '商业配套', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《会展中心站》 http://www.nngdjt.com/html/service1c/line/0118.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '南湖片区',
-    title: '南湖站周边绿地、政务与金融办公配套',
-    content: '南湖站位于南湖大桥东端、南湖公园绿地内。A口周边有南宁市人民政府，B口通往南湖公园，C口周边列有自治区税务局、自治区发展和改革委员会及多家银行。',
-    tags: ['轨道交通', '公园绿地', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《南湖站》 http://www.nngdjt.com/html/service1c/line/0116.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '金湖片区',
-    title: '金湖广场站的双线换乘与民歌湖配套',
-    content: '金湖广场站位于金湖东环路与民族大道交叉口，是1号线与3号线换乘站。站点周边包括金湖广场、民歌湖、南宁书城、购物中心、金融机构、南宁市政务服务中心及南宁十四中埌东校区。',
-    tags: ['轨道交通', '商业配套', '文化休闲', '商务办公', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《金湖广场站》 http://www.nngdjt.com/html/service1c/line/0314.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '凤岭南-青秀山片区',
-    title: '青秀山站与青秀山西门、青秀湖公园',
-    content: '青秀山站设置4个出入口，B口位于青秀山风景区西门及青秀山管委会一侧；A1口周边包括青秀湖公园。A3口设置无障碍电梯，周边有多条公交线路。',
-    tags: ['轨道交通', '公园绿地', '文化休闲', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《青秀山站》 http://www.nngdjt.com/html/service1c/line/0317.html'
-  },
-  {
-    region: '良庆区', businessDistrict: '市博物馆片区',
-    title: '市博物馆站与文化艺术中心配套',
-    content: '市博物馆站位于博艺路与彩凤路交叉路口，A口周边为广西文化艺术中心，D口周边为南宁市博物馆、金龙路小学及良庆区金龙幼儿园。',
-    tags: ['轨道交通', '文化休闲', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《市博物馆》 http://www.nngdjt.com/html/service1c/line/0318.html'
-  },
-  {
-    region: '江南区', businessDistrict: '江南万达',
-    title: '亭洪路沿线的商业、文化与公园节点',
-    content: '南宁市公开报道将亭洪路描述为江南区城市商贸业和文化旅游的主轴线，并列示江南万达商圈、百益·上河城、华润江南中心、江南公园、广西海吉星、火车南站和国际铁路港等节点分布在亭洪路两侧及周边。报道同时记载，亭洪路延长线建成后将江南万达商圈与沙井商圈连接起来。',
-    tags: ['商业配套', '文化休闲', '公园绿地', '商务办公'],
-    sourceNote: '南宁市人民政府《江南区发达路网赋能产城高度融合发展》 https://www.nanning.gov.cn/ywzx/xqdt/2022xqdt/t5048033.html'
-  },
-  {
-    region: '江南区', businessDistrict: '江南公园片区',
-    title: '江南公园的生态与文化休闲节点',
-    content: '南宁市江南公园位于壮锦大道17号、紧邻江南区政府，西邻壮锦大道、东接金华路、北靠亭洪路延长线及湘桂铁路线。政府页面记载，公园总面积798亩，于2018年6月正式对外开放，以休闲、生态、文化为主旨，是市级综合性城市公园。',
-    tags: ['公园绿地', '文化休闲', '公共服务'],
-    sourceNote: '南宁市文化广电和旅游局《南宁市江南公园》 https://www.nanning.gov.cn/zjnn/nnly/t4137277.html'
-  },
-  {
-    region: '江南区', businessDistrict: '亭子码头片区',
-    title: '邕江亭子码头滨水公共空间',
-    content: '南宁市政府公开报道记载，邕江亭子码头于2019年1月正式对市民开放，码头岸线长约500米；报道将其定位为面向邕江观景的滨水码头节点。',
-    tags: ['文化休闲', '公共服务'],
-    sourceNote: '南宁市人民政府《邕江亭子码头正式开放》 https://www.nanning.gov.cn/ywzx/nnyw/2019nzwdt/t1593403.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '西乡塘大学东路',
-    title: '广西大学站的高校、社区与公共服务节点',
-    content: '南宁轨道交通1号线广西大学站位于大学东路与明秀西路交汇处下方。运营方列示，B1口周边有城市碧园、时代天骄和南宁高级技工学校，C口周边有南宁市第二小学，D口周边有西乡塘街道办事处和五里亭第一小学，F口周边有广西大学南门。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《广西大学站》 http://www.nngdjt.com/html/service1c/line/0109.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '西乡塘大学东路',
-    title: '鲁班路站的学校、医疗与公园节点',
-    content: '南宁轨道交通1号线鲁班路站位于大学东路与鲁班路交汇处下方。运营方列示，A口周边有明月湖公园、南宁市第二十中学和南宁市公安局西乡塘分局，B口周边有广西大学。',
-    tags: ['轨道交通', '公园绿地', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《鲁班路站》 http://www.nngdjt.com/html/service1c/line/0108.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '相思湖片区',
-    title: '民族大学站的高校与基层医疗节点',
-    content: '南宁轨道交通1号线民族大学站位于大学东路与新村大道交叉路口，沿大学东路设置。运营方列示，车站西北侧有西乡塘卫生院，东北侧有广西民族大学和相思湖国际大酒店，西南侧有广西交通运输学校、广西外国语学校，东南侧有广西机电职业技术学院、广西社会主义学院和西乡塘派出所。',
-    tags: ['轨道交通', '公共服务'],
-    sourceNote: '南宁轨道交通集团有限责任公司《民族大学站》 http://www.nngdjt.com/html/service1c/line/0105.html'
-  },
-  {
-    region: '西乡塘区', businessDistrict: '南宁动物园片区',
-    title: '动物园站的亲子科普主题公共空间',
-    content: '南宁市2026年公开报道记载，南宁地铁1号线动物园站毗邻南宁动物园，并由南宁市动物园与南宁地铁围绕动物文化、科普教育和儿童友好理念打造主题车站；站内设置动物IP科普墙、动物主题儿童休息区和小象主题母婴室等场景。',
-    tags: ['轨道交通', '文化休闲', '公共服务'],
-    sourceNote: '南宁市人民政府《IP内容+空间资源 南宁地铁1号线动物园站化身童趣乐园》 https://www.nanning.gov.cn/ywzx/tpxw/t6647075.html'
-  },
-  {
-    region: '兴宁区', businessDistrict: '兴宁老城区',
-    title: '三街两巷历史文化街区',
-    content: '南宁市三街两巷历史街区是南宁主城区规模最大的历史文化街区，由解放路、兴宁路、民生路三条老街和金狮巷、银狮巷两条古巷组成，汇聚文物保护单位及历史建筑，是近代南宁较集中的骑楼建筑片区。',
-    tags: ['文化休闲', '商业配套'],
-    sourceNote: '南宁市人民政府《历史文化街区“三街两巷”露芳容》 https://www.nanning.gov.cn/zjnn/mswh/t1526950.html'
-  },
-  {
-    region: '邕宁区', businessDistrict: '龙岗',
-    title: '轨道交通4号线后通段接入龙岗',
-    content: '南宁市公开报道记载，2025年9月轨道交通4号线一期工程后通段（楞塘村站至龙岗站）开通运营，龙岗站成为该后通段终点站，邕宁区由此接入轨道交通网络。',
-    tags: ['轨道交通'],
-    sourceNote: '邕宁区人民政府《喜大普奔！地铁4号线后通段开通运营，邕宁迈入“地铁时代”！》 https://www.nanning.gov.cn/ywzx/xqdt/2025nxqdt/t6428425.html'
-  },
-  {
-    region: '邕宁区', businessDistrict: '园博园片区',
-    title: '南宁园博园的园林与文化展示节点',
-    content: '南宁园博园是第十二届中国国际园林博览会举办地，位于邕宁区八尺江畔顶蛳山地块，占地276公顷，2018年12月建成开放。政府页面记载，园内有新石器时代文化遗址、丘陵与原生山林、湖塘和湿地，并设中华城市展园、东盟园、丝路园、广西园、设计师园和企业园等主题展园区。',
-    tags: ['公园绿地', '文化休闲'],
-    sourceNote: '南宁市人民政府《南宁园博园》 https://www.nanning.gov.cn/zjnn/nnly/t2566279.html'
-  },
-  {
-    region: '青秀区', businessDistrict: '埌西片区',
-    title: '埌西站周边教育、人社与生活服务',
-    content: '埌西站位于金湖路与桂春路交叉路口。站点周边列有南宁市教育局、南宁市人力资源和社会保障局、南宁市民政局、广西疾病预防控制中心、埌西综合市场、人才市场及多所学校。',
-    tags: ['轨道交通', '公共服务', '商业配套'],
-    sourceNote: '南宁轨道交通集团有限责任公司《埌西站》 http://www.nngdjt.com/html/service1c/line/0315.html'
-  }
-];
-
-if (sourceNote.length > 500 || officialLocationEntries.some((item) => item.sourceNote.length > 500)) {
-  throw new Error('知识条目的来源说明超过数据库字段长度');
-}
-
-function sql(value) {
-  if (value === null || value === undefined) {
-    return 'NULL';
-  }
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-
-function known(value) {
-  return value !== undefined && value !== null && String(value).trim() !== ''
-    && String(value).trim() !== '待定';
-}
-
-function exactNumber(value) {
-  const text = String(value || '').trim();
-  return /^\d+(?:\.\d+)?$/.test(text) ? text : null;
-}
-
-function businessDistrictName(item) {
-  return businessDistrictOverrides[item['楼盘名称']] || item['所属商圈'];
-}
-
-function text(parts) {
-  return parts.filter(([_, value]) => known(value))
-    .map(([label, value]) => `${label}：${value}`)
-    .join('；');
-}
-
-function locationFilter(item) {
-  return [
-    'FROM house_knowledge_location community',
-    'JOIN house_knowledge_location business_district',
-    '  ON business_district.location_id = community.parent_location_id',
-    'WHERE community.tenant_id = @house_knowledge_tenant_id',
-    "  AND community.city = '南宁'",
-    "  AND community.location_type = 'community'",
-    `  AND community.location_name = ${sql(item['楼盘名称'])}`,
-    '  AND community.deleted = 0',
-    '  AND business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    '  AND business_district.deleted = 0'
-  ].join('\n');
-}
-
-function tagInsert(topic, item, tags) {
-  const values = [...tags].filter(Boolean).map(sql).join(', ');
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry_tag (entry_id, tag_id, tenant_id)',
-    'SELECT entry.entry_id, tag.tag_id, @house_knowledge_tenant_id',
-    'FROM house_knowledge_entry entry',
-    'JOIN house_knowledge_location community ON community.location_id = entry.location_id',
-    'JOIN house_knowledge_location business_district',
-    '  ON business_district.location_id = community.parent_location_id',
-    'JOIN house_knowledge_tag tag ON tag.tenant_id = @house_knowledge_tenant_id',
-    '  AND tag.deleted = 0',
-    'WHERE entry.tenant_id = @house_knowledge_tenant_id',
-    '  AND entry.deleted = 0',
-    '  AND entry.status = 0',
-    `  AND entry.topic = ${sql(topic)}`,
-    `  AND entry.source_note = ${sql(sourceNote)}`,
-    "  AND community.city = '南宁'",
-    "  AND community.location_type = 'community'",
-    `  AND community.location_name = ${sql(item['楼盘名称'])}`,
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    `  AND tag.tag_name IN (${values});`
-  ].join('\n');
-}
-
-function entryInsert(item, topic, title, content, fields) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry (',
-    '    location_id, topic, title, content, property_company, property_fees,',
-    '    water_billing_type, water_unit_price, electricity_billing_type, electricity_unit_price,',
-    '    parking_available, parking_fee, verified_date, source_note, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    '    community.location_id,',
-    `    ${sql(topic)},`,
-    `    ${sql(title)},`,
-    `    ${sql(content || null)},`,
-    `    ${sql(fields.propertyCompany)},`,
-    `    ${fields.propertyFees || 'NULL'},`,
-    `    ${sql(fields.waterBillingType)},`,
-    `    ${fields.waterUnitPrice || 'NULL'},`,
-    `    ${sql(fields.electricityBillingType)},`,
-    `    ${fields.electricityUnitPrice || 'NULL'},`,
-    `    ${fields.parkingAvailable === null ? 'NULL' : fields.parkingAvailable ? '1' : '0'},`,
-    `    ${sql(fields.parkingFee)},`,
-    '    CURDATE(),',
-    `    ${sql(sourceNote)},`,
-    '    0, @house_knowledge_tenant_id, 0',
-    locationFilter(item) + ';'
-  ].join('\n');
-}
-
-function parkingAvailable(item) {
-  if (item['地下停车场'] === '有') {
-    return true;
-  }
-  if (item['地下停车场'] === '无') {
-    return false;
-  }
-  return known(item['停车位数量']) ? true : null;
-}
-
-function entryBlocks(item, type) {
-  const name = item['楼盘名称'];
-  const typeTag = type === 'office' ? '写字楼' : '住宅小区';
-  const propertyContent = text([
-    ['物业类型', item['物业类型']],
-    ['物业公司', item['物业公司']],
-    ['物业费标准', item['物业费标准(元/㎡/月)']],
-    ['物业服务时间', item['物业服务时间']],
-    ['内部配套', item['内部配套']],
-    ['总层数', item['总层数']],
-    ['建成年份', item['建成年份']],
-    ['产权年限', item['产权年限']],
-    ['备注', item['备注']]
-  ]);
-  const utilitiesContent = text([
-    ['水电类型', item['水电类型']],
-    ['水费标准', item['水费标准(元/吨)']],
-    ['电费标准', item['电费标准(元/度)']],
-    ['24小时供水供电', item['24小时供水供电']]
-  ]);
-  const parkingContent = text([
-    ['停车位数量', item['停车位数量']],
-    ['车位配比', item['车位配比']],
-    ['地下停车场', item['地下停车场']],
-    ['充电桩配置', item['充电桩配置']],
-    ['临停收费标准', item['临停收费标准']],
-    ['月保收费标准', item['月保收费标准']]
-  ]);
-  const otherContent = text([
-    ['所属区域', item['所属区域']],
-    ['详细地址', item['详细地址']],
-    ['所属商圈', businessDistrictName(item)],
-    ['周边配套', item['周边配套']]
-  ]);
-  const propertyTags = new Set(['物业服务', typeTag]);
-  const utilitiesTags = new Set(['水电计费', typeTag]);
-  const parkingTags = new Set(['停车信息', typeTag]);
-  const otherTags = new Set(['商业配套', typeTag]);
-  if (item['物业服务时间'] === '24小时') {
-    propertyTags.add('24小时服务');
-  }
-  if (item['充电桩配置'] === '有') {
-    parkingTags.add('充电设施');
-  }
-  if (String(item['周边配套'] || '').includes('地铁')) {
-    otherTags.add('轨道交通');
-    otherTags.add('地铁出行');
-  }
-  if (type === 'office') {
-    otherTags.add('商务办公');
-  }
-
-  return [
-    entryInsert(item, 'property', `${name}的物业服务`, propertyContent, {
-      propertyCompany: known(item['物业公司']) ? item['物业公司'] : null,
-      propertyFees: exactNumber(item['物业费标准(元/㎡/月)']),
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('property', item, propertyTags),
-    entryInsert(item, 'utilities', `${name}的水电计费`, utilitiesContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: known(item['水电类型']) ? item['水电类型'] : null,
-      waterUnitPrice: exactNumber(item['水费标准(元/吨)']),
-      electricityBillingType: known(item['水电类型']) ? item['水电类型'] : null,
-      electricityUnitPrice: exactNumber(item['电费标准(元/度)']),
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('utilities', item, utilitiesTags),
-    entryInsert(item, 'parking', `${name}的停车与充电`, parkingContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: parkingAvailable(item),
-      parkingFee: text([
-        ['临停', item['临停收费标准']],
-        ['月保', item['月保收费标准']]
-      ]) || null
-    }),
-    tagInsert('parking', item, parkingTags),
-    entryInsert(item, 'other', `${name}的地段与周边配套`, otherContent, {
-      propertyCompany: null,
-      propertyFees: null,
-      waterBillingType: null,
-      waterUnitPrice: null,
-      electricityBillingType: null,
-      electricityUnitPrice: null,
-      parkingAvailable: null,
-      parkingFee: null
-    }),
-    tagInsert('other', item, otherTags)
-  ];
-}
-
-function officialLocationInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'business_district', ${sql(item.businessDistrict)}, region.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location region',
-    'WHERE region.tenant_id = @house_knowledge_tenant_id',
-    "  AND region.city = '南宁'",
-    "  AND region.location_type = 'region'",
-    `  AND region.location_name = ${sql(item.region)}`,
-    '  AND region.deleted = 0',
-    '  AND NOT EXISTS (',
-    '      SELECT 1 FROM house_knowledge_location existing',
-    '      WHERE existing.tenant_id = @house_knowledge_tenant_id',
-    "        AND existing.city = '南宁'",
-    "        AND existing.location_type = 'business_district'",
-    `        AND existing.location_name = ${sql(item.businessDistrict)}`,
-    '        AND existing.deleted = 0',
-    '  );'
-  ].join('\n');
-}
-
-function officialEntryInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry (',
-    '    location_id, topic, title, content, verified_date, source_note,',
-    '    status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    '    business_district.location_id,',
-    "    'other',",
-    `    ${sql(item.title)},`,
-    `    ${sql(item.content)},`,
-    "    '2026-08-02',",
-    `    ${sql(item.sourceNote)},`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location business_district',
-    'WHERE business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(item.businessDistrict)}`,
-    '  AND business_district.deleted = 0;'
-  ].join('\n');
-}
-
-function officialTagInsert(item) {
-  return [
-    'INSERT IGNORE INTO house_knowledge_entry_tag (entry_id, tag_id, tenant_id)',
-    'SELECT entry.entry_id, tag.tag_id, @house_knowledge_tenant_id',
-    'FROM house_knowledge_entry entry',
-    'JOIN house_knowledge_location business_district ON business_district.location_id = entry.location_id',
-    'JOIN house_knowledge_tag tag ON tag.tenant_id = @house_knowledge_tenant_id',
-    '  AND tag.deleted = 0',
-    'WHERE entry.tenant_id = @house_knowledge_tenant_id',
-    '  AND entry.deleted = 0',
-    '  AND entry.status = 0',
-    "  AND entry.topic = 'other'",
-    `  AND entry.source_note = ${sql(item.sourceNote)}`,
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(item.businessDistrict)}`,
-    `  AND tag.tag_name IN (${item.tags.map(sql).join(', ')});`
-  ].join('\n');
-}
-
-const records = [
-  ...offices.map((item) => ({ item, type: 'office' })),
-  ...communities.map((item) => ({ item, type: 'community' }))
-];
-const regions = [...new Set(records.map(({ item }) => item['所属区域']).filter(known))];
-const districts = [...new Map(records
-  .filter(({ item }) => known(item['所属区域']) && known(businessDistrictName(item)))
-  .map(({ item }) => [`${item['所属区域']}\u0000${businessDistrictName(item)}`, item])).values()];
-
-const lines = [
-  '-- 以下数据由南宁房产知识库结构化表格.json 和官方公开资料生成。',
-  `-- 共 ${offices.length} 个写字楼、${communities.length} 个住宅小区和 ${officialLocationEntries.length} 条官方片区知识；来源说明仅后台可见。`,
-  ''
-];
-
-for (const region of regions) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ') VALUES (',
-    `    '南宁', 'region', ${sql(region)}, 0, 0, @house_knowledge_tenant_id, 0`,
-    ');',
-    ''
-  ].join('\n'));
-}
-
-for (const item of districts) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'business_district', ${sql(businessDistrictName(item))}, region.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location region',
-    'WHERE region.tenant_id = @house_knowledge_tenant_id',
-    "  AND region.city = '南宁'",
-    "  AND region.location_type = 'region'",
-    `  AND region.location_name = ${sql(item['所属区域'])}`,
-    '  AND region.deleted = 0',
-    '  AND NOT EXISTS (',
-    '      SELECT 1 FROM house_knowledge_location existing',
-    '      WHERE existing.tenant_id = @house_knowledge_tenant_id',
-    "        AND existing.city = '南宁'",
-    "        AND existing.location_type = 'business_district'",
-    `        AND existing.location_name = ${sql(businessDistrictName(item))}`,
-    '        AND existing.deleted = 0',
-    '  );',
-    ''
-  ].join('\n'));
-}
-
-for (const item of officialLocationEntries) {
-  lines.push(officialLocationInsert(item), '');
-}
-
-for (const { item } of records) {
-  lines.push([
-    'INSERT IGNORE INTO house_knowledge_location (',
-    '    city, location_type, location_name, parent_location_id, status, tenant_id, deleted',
-    ')',
-    'SELECT',
-    `    '南宁', 'community', ${sql(item['楼盘名称'])}, business_district.location_id,`,
-    '    0, @house_knowledge_tenant_id, 0',
-    'FROM house_knowledge_location business_district',
-    'WHERE business_district.tenant_id = @house_knowledge_tenant_id',
-    "  AND business_district.city = '南宁'",
-    "  AND business_district.location_type = 'business_district'",
-    `  AND business_district.location_name = ${sql(businessDistrictName(item))}`,
-    '  AND business_district.deleted = 0;',
-    ''
-  ].join('\n'));
-}
-
-for (const { item, type } of records) {
-  lines.push(...entryBlocks(item, type), '');
-}
-
-for (const item of officialLocationEntries) {
-  lines.push(officialEntryInsert(item), officialTagInsert(item), '');
-}
-
-const seed = fs.readFileSync(seedPath, 'utf8');
-const start = seed.indexOf(startMarker);
-const end = seed.indexOf(endMarker);
-if (start < 0 || end < 0 || end < start) {
-  throw new Error('未找到南宁结构化数据生成区段标记');
-}
-
-const generated = `${startMarker}\n${lines.join('\n')}${endMarker}`;
-fs.writeFileSync(seedPath, `${seed.slice(0, start)}${generated}${seed.slice(end + endMarker.length)}`, 'utf8');
-console.log(`已生成 ${records.length} 个地点的房源知识种子数据。`);

scripts/hjc_test_push.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-汇吉采 <-- 一站式：推送标书项目测试脚本（入向 POST /api/hjc/push/project）
-
-用法:
-    python hjc_test_push.py                     # 默认 http://uk.frp.one:62335
-    python hjc_test_push.py http://uk.frp.one:62335
-    python hjc_test_push.py --base http://uk.frp.one:62335 --project-no TEST-xxx
-
-无第三方依赖，仅标准库（hashlib + urllib）。时间用北京时间(UTC+8)。
-签名 sign = MD5(appKey + password + timestamp)，timestamp = yyyyMMddHHmm。
-"""
-import sys
-import json
-import hashlib
-import urllib.request
-import urllib.error
-import datetime
-
-APP_KEY = "HJC_Official_Website"
-PASSWORD = "vQ8$kR3#mW6@xP2!nF"
-DEFAULT_BASE = "http://uk.frp.one:62335"
-
-DEFAULT_PAYLOAD = {
-    "projectNo": "TEST-HJC-20260801",
-    "projectName": "测试标书项目·服务器采购",
-    "category": "货物类",
-    "tenderPrice": 500.00,
-    "files": "[{\"name\":\"招标文件.pdf\",\"url\":\"https://file.example.com/t.pdf\"}]",
-    "tenderOnsaleTime": "2026-08-01 09:00:00",
-    "tenderOffsaleTime": "2026-08-10 17:00:00",
-    "bulletinName": "中标公告-测试",
-    "customerName": "某招标单位",
-    "supplierName": "某中标公司",
-    "bidAmount": 128000.00,
-    "content": "测试公告正文。中标供应商：某中标公司，中标金额 128000 元。",
-    "fileList": "[{\"name\":\"中标通知书.pdf\",\"url\":\"https://file.example.com/n.pdf\"}]",
-    "needSellTender": 1,
-    "sellingMethod": 2
-}
-
-
-def bj_now() -> str:
-    """北京时间 yyyyMMddHHmm"""
-    return (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=8)).strftime("%Y%m%d%H%M")
-
-
-def main():
-    base = DEFAULT_BASE
-    payload = dict(DEFAULT_PAYLOAD)
-    args = sys.argv[1:]
-    i = 0
-    while i < len(args):
-        a = args[i]
-        if a in ("--base", "-b"):
-            base = args[i + 1]
-            i += 2
-        elif a in ("--project-no", "-p"):
-            payload["projectNo"] = args[i + 1]
-            i += 2
-        elif a == "--json":
-            with open(args[i + 1], encoding="utf-8") as f:
-                payload = json.load(f)
-            i += 2
-        else:
-            base = a  # 位置参数作为 baseUrl
-            i += 1
-
-    url = base.rstrip("/") + "/api/hjc/push/project"
-    ts = bj_now()
-    sign = hashlib.md5((APP_KEY + PASSWORD + ts).encode("utf-8")).hexdigest()
-    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-
-    req = urllib.request.Request(url, data=body, method="POST", headers={
-        "Content-Type": "application/json; charset=utf-8",
-        "appKey": APP_KEY,
-        "timestamp": ts,
-        "sign": sign,
-        "tenantId": "10626"
-    })
-
-    print("== 请求 ==")
-    print("URL:", url)
-    print("timestamp:", ts, "| sign:", sign)
-    print("body:", body.decode("utf-8"))
-    print()
-    print("== 响应 ==")
-    try:
-        with urllib.request.urlopen(req, timeout=20) as resp:
-            print("HTTP", resp.status)
-            print(resp.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        print("HTTP", e.code)
-        print(e.read().decode("utf-8"))
-    except Exception as e:
-        print("ERROR:", type(e).__name__, e)
-
-
-if __name__ == "__main__":
-    main()

scripts/hjc_test_push_out.py

@@ -1,657 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-汇吉采 → 一站式：**出向**推送联调探测脚本（POST {base-url}{create-purchase-details-path}）
-
-与同目录 hjc_test_push.py（入向：一站式 → 官方网 /api/hjc/push/project）互为反向。
-
-用途：一条命令回答「出向对接到底通没通、卡在哪一层」。
-脚本会自动做三件事：
-  1. 按文档约定的签名方案（sign = MD5(appKey + password + timestamp)）发起真实推送；
-  2. 额外遍历若干鉴权头变体（含 password 明文头等历史解读），用于区分「签名不对」与「根本没校验签名」；
-  3. 用对照探测把失败定位到具体一层：登录过滤器 / 路由不存在 / 验签失败 / 网络不可达。
-
-默认参数自动从仓库读取，避免与代码脱节：
-  - application.yml            → hjc.one-stop.base-url、create-purchase-details-path
-  - HjcOneStopAuthUtil.java    → APP_KEY、PASSWORD
-
-用法::
-
-    python hjc_test_push_out.py                      # 全量：约定方案 + 变体矩阵 + 对照探测
-    python hjc_test_push_out.py --quick              # 只打约定方案（日常回归用）
-    python hjc_test_push_out.py --repeat 3           # 约定方案连打 3 次（同一订单号，验幂等）
-    python hjc_test_push_out.py --base http://x:8810 --path /api/biz/createPurchaseDetails
-    python hjc_test_push_out.py --order-no HJC2026080101ABCD --json result.json
-    python hjc_test_push_out.py --dry-run            # 只打印将要发出的请求，不真的发
-
-订单号默认是固定值 ``TEST-HJC-ORDER-20260801``（不随时间变化）：它同时是一站式的幂等键，
-固定住才能重复验证幂等/状态流转，也不会每跑一次就在对方库里堆一条新订单；要换单号显式传 ``--order-no``。
-
-退款报文（status=REFUNDED，必带 refundTime + refundReason，见 docs/一站式平台对接-接口文档.md §3.4）::
-
-    python hjc_test_push_out.py --refund --dry-run   # 看退款报文长什么样
-    python hjc_test_push_out.py --refund --quick     # 打退款报文
-    python hjc_test_push_out.py --paid-then-refund   # 同一订单号先 PAID 再 REFUNDED（推荐的联调姿势）
-    python hjc_test_push_out.py --refund --order-no HJC2026080101ABCD \\
-        --refund-reason "项目终止，客户申请退款" --refund-time "2026-08-03 09:15:00"
-
-无第三方依赖，仅标准库。时间统一按北京时间（UTC+8）。
-
-退出码：0=出向推送成功（收到 2xx）；1=失败（并打印定位结论）。
-"""
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import hashlib
-import json
-import os
-import re
-import ssl
-import sys
-import time
-import urllib.error
-import urllib.parse
-import urllib.request
-
-try:  # Windows 控制台默认 GBK，强制 UTF-8 避免中文乱码
-    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
-except Exception:
-    pass
-
-# --------------------------------------------------------------------------- #
-# 默认值 / 配置读取
-# --------------------------------------------------------------------------- #
-HERE = os.path.dirname(os.path.abspath(__file__))
-MP_JAVA = os.path.dirname(HERE)
-APPLICATION_YML = os.path.join(MP_JAVA, "src", "main", "resources", "application.yml")
-AUTH_UTIL_JAVA = os.path.join(
-    MP_JAVA, "src", "main", "java", "com", "gxwebsoft", "hjc", "util", "HjcOneStopAuthUtil.java"
-)
-
-FALLBACK_BASE = "http://180.141.88.21:8810"
-FALLBACK_PATH = "/api/biz/createPurchaseDetails"
-FALLBACK_APP_KEY = "HJC_Official_Website"
-FALLBACK_PASSWORD = "vQ8$kR3#mW6@xP2!nF"
-
-TS_FMT = "%Y%m%d%H%M"
-DT_FMT = "%Y-%m-%d %H:%M:%S"
-# argparse 的 help 会对 % 做格式化，展示用的时间格式需转义
-DT_FMT_HELP = DT_FMT.replace("%", "%%")
-
-STATUS_PAID = "PAID"
-STATUS_REFUNDED = "REFUNDED"
-# 固定探测订单号：不随时间变化，重复运行始终命中一站式同一条记录。
-# 订单号同时是一站式幂等键（HJC_ORD_<orderNo>），固定值才能稳定验证幂等与状态流转，
-# 也不会每跑一次就在对方库里堆一条新订单。（与 hjc_test_push.py 固定 projectNo 同一思路）
-DEFAULT_ORDER_NO = "PROBE_202609111127"
-# 与 HjcBizServiceImpl.DEFAULT_REFUND_REASON 对齐：退款原因留空时官方网会兜底这个值
-DEFAULT_REFUND_REASON = "联调探测：客户申请退款"
-# 与 hjc_order.refund_reason 字段长度对齐（varchar(255)）
-REFUND_REASON_MAX = 255
-
-
-def _read_text(path: str) -> str:
-    try:
-        with open(path, encoding="utf-8") as f:
-            return f.read()
-    except OSError:
-        return ""
-
-
-def load_config() -> tuple[str, str]:
-    """从仓库读取 base-url / path，读不到则回退到内置值。"""
-    base, path = FALLBACK_BASE, FALLBACK_PATH
-    yml = _read_text(APPLICATION_YML)
-    if yml:
-        m = re.search(r'base-url:\s*"([^"]*)"', yml)
-        if m and m.group(1).strip():
-            base = m.group(1).strip()
-        m = re.search(r"create-purchase-details-path:\s*(\S+)", yml)
-        if m and m.group(1).strip():
-            path = m.group(1).strip().strip('"')
-    return base, path
-
-
-def load_credentials() -> tuple[str, str]:
-    """从 HjcOneStopAuthUtil.java 读取 APP_KEY / PASSWORD，读不到则回退。"""
-    app_key, password = FALLBACK_APP_KEY, FALLBACK_PASSWORD
-    java = _read_text(AUTH_UTIL_JAVA)
-    if java:
-        m = re.search(r'APP_KEY\s*=\s*"([^"]*)"', java)
-        if m:
-            app_key = m.group(1)
-        m = re.search(r'PASSWORD\s*=\s*"([^"]*)"', java)
-        if m:
-            password = m.group(1)
-    return app_key, password
-
-
-# --------------------------------------------------------------------------- #
-# 签名 / 时间
-# --------------------------------------------------------------------------- #
-def bj_now() -> dt.datetime:
-    return dt.datetime.now(dt.timezone.utc).astimezone(dt.timezone(dt.timedelta(hours=8)))
-
-
-def timestamp_str(now: dt.datetime) -> str:
-    return now.strftime(TS_FMT)
-
-
-def sign_of(app_key: str, password: str, ts: str) -> str:
-    return hashlib.md5((app_key + password + ts).encode("utf-8")).hexdigest()
-
-
-def md5(text: str) -> str:
-    return hashlib.md5(text.encode("utf-8")).hexdigest()
-
-
-# --------------------------------------------------------------------------- #
-# HTTP
-# --------------------------------------------------------------------------- #
-def post(url: str, body: bytes, headers: dict, timeout: float, insecure: bool = False):
-    """返回 (http_code, response_text, elapsed_ms, error)。http_code=0 表示网络层失败。"""
-    req = urllib.request.Request(url, data=body, method="POST", headers=headers)
-    ctx = ssl._create_unverified_context() if insecure else None
-    t0 = time.monotonic()
-    try:
-        with urllib.request.urlopen(req, timeout=timeout, context=ctx) as resp:
-            text = resp.read().decode("utf-8", errors="replace")
-            return resp.status, text, (time.monotonic() - t0) * 1000, None
-    except urllib.error.HTTPError as e:
-        text = e.read().decode("utf-8", errors="replace")
-        return e.code, text, (time.monotonic() - t0) * 1000, None
-    except Exception as e:  # noqa: BLE001 - 网络层任何异常都归为不可达
-        return 0, "", (time.monotonic() - t0) * 1000, f"{type(e).__name__}: {e}"
-
-
-# --------------------------------------------------------------------------- #
-# 响应判定
-# --------------------------------------------------------------------------- #
-LOGIN_HINTS = ("token失效", "请重新登录", "未登录", "not login", "unauthorized")
-SIGN_HINTS = ("签名", "验签", "sign校验", "invalid signature", "signature")
-TS_HINTS = ("时间戳", "timestamp失效", "timestamp expired")
-
-VERDICT_LABEL = {
-    "OK": "✅ 通过",
-    "LOGIN_FILTER": "🔒 登录过滤器拦截",
-    "SIGN_REJECT": "❌ 验签被拒",
-    "TS_REJECT": "❌ 时间戳被拒",
-    "NOT_FOUND": "🚫 路由不存在(404)",
-    "UNREACHABLE": "🌐 网络不可达",
-    "OTHER": "❓ 其他",
-}
-
-
-def classify(status: int, body: str) -> str:
-    if status == 0:
-        return "UNREACHABLE"
-    if 200 <= status < 300:
-        return "OK"
-    low = (body or "").lower()
-    if any(h in low for h in TS_HINTS):
-        return "TS_REJECT"
-    if any(h in low for h in SIGN_HINTS):
-        return "SIGN_REJECT"
-    if any(h in low for h in LOGIN_HINTS):
-        return "LOGIN_FILTER"
-    if status == 404:
-        return "NOT_FOUND"
-    return "OTHER"
-
-
-def brief(body: str, limit: int = 160) -> str:
-    one = " ".join((body or "").split())
-    return one if len(one) <= limit else one[:limit] + "…"
-
-
-def fingerprint(status: int, body: str) -> str:
-    """响应的「错误语义指纹」：忽略每次都变的 timestamp/path 字段，只保留结论性字段。
-
-    用于判断两次响应是否表达同一个错误（例如真实接口与不存在路径都被同一个过滤器拒绝）。
-    """
-    try:
-        obj = json.loads(body)
-        if isinstance(obj, dict):
-            keep = {k: obj[k] for k in ("status", "error", "message") if k in obj}
-            if keep:
-                return json.dumps(keep, ensure_ascii=False, sort_keys=True)
-    except (ValueError, TypeError):
-        pass
-    return " ".join((body or "").split())[:200] or f"HTTP {status}"
-
-
-# --------------------------------------------------------------------------- #
-# 报文
-# --------------------------------------------------------------------------- #
-def default_payload(
-    order_no: str,
-    now: dt.datetime,
-    status: str = STATUS_PAID,
-    refund_reason: str | None = None,
-    refund_time: dt.datetime | None = None,
-) -> dict:
-    """构造 createPurchaseDetails 请求体。
-
-    status=REFUNDED 时追加 refundTime / refundReason（官方网侧同样只在退款单推这两个字段，
-    见 HjcBizServiceImpl#buildCreatePurchaseDetails）。
-    """
-    payload = {
-        "idempotencyKey": "HJC_ORD_" + order_no,
-        "orderNo": order_no,
-        "projectNo": "HJC-GXZCY2-2026002",
-        "projectName": "出向推送联调探测",
-        "tenderPrice": 0.01,
-        "quantity": 1,
-        "totalAmount": 0.01,
-        "buyer": {
-            "enterpriseName": "联调探测企业",
-            "creditCode": "91450000PROBE01",
-            "contactName": "联调",
-            "contactPhone": "13800000000",
-            "contactEmail": "probe@example.com",
-        },
-        "paidAt": now.strftime(DT_FMT),
-        "payMethod": "WECHAT_NATIVE",
-        "status": status,
-        "invoiceStatus": "NONE",
-    }
-    if status == STATUS_REFUNDED:
-        reason = (refund_reason or "").strip() or DEFAULT_REFUND_REASON
-        payload["refundTime"] = (refund_time or now).strftime(DT_FMT)
-        payload["refundReason"] = reason[:REFUND_REASON_MAX]
-    return payload
-
-
-def refund_payload_issues(payload: dict) -> list[str]:
-    """退款报文的本地自检：官方网/一站式都要求这两个字段非空，先在这里拦住低级错误。"""
-    issues: list[str] = []
-    if payload.get("status") != STATUS_REFUNDED:
-        return issues
-    for field in ("refundTime", "refundReason"):
-        value = payload.get(field)
-        if not isinstance(value, str) or not value.strip():
-            issues.append(f"{field} 缺失或为空（退款推送必带）")
-    rt = payload.get("refundTime")
-    if isinstance(rt, str) and rt.strip():
-        try:
-            dt.datetime.strptime(rt.strip(), DT_FMT)
-        except ValueError:
-            issues.append(f"refundTime 格式应为 {DT_FMT}（当前: {rt}）")
-    reason = payload.get("refundReason")
-    if isinstance(reason, str) and len(reason) > REFUND_REASON_MAX:
-        issues.append(f"refundReason 超过 {REFUND_REASON_MAX} 字符（当前: {len(reason)}）")
-    return issues
-
-
-def case_matrix(app_key: str, password: str, ts: str, sign: str) -> list[tuple[str, dict, str]]:
-    """返回 [(方案名, 请求头, 说明)]，方案 1 为文档约定方案。"""
-    return [
-        (
-            "1 文档约定方案",
-            {"appKey": app_key, "timestamp": ts, "sign": sign},
-            "appKey+timestamp+sign（sign=MD5(appKey+password+timestamp)）",
-        ),
-        (
-            "2 约定 + password 明文头",
-            {"appKey": app_key, "timestamp": ts, "sign": sign, "password": password},
-            "在原需求「明文 password 头」与现规范之间的折中",
-        ),
-        (
-            "3 仅 password 明文头",
-            {"password": password},
-            "只带密钥，不带 appKey/sign",
-        ),
-        (
-            "4 appKey + password 明文",
-            {"appKey": app_key, "password": password, "timestamp": ts},
-            "按原文需求字面实现（无 sign）",
-        ),
-        (
-            "5 双 MD5 解读",
-            {"appKey": md5(app_key + ts), "password": md5(password + ts), "timestamp": ts},
-            "原文「appKey+年月日时分，password+年月日时分，MD5加密」的另一种读法",
-        ),
-        (
-            "6 Authorization 头",
-            {"appKey": app_key, "timestamp": ts, "Authorization": sign},
-            "把签名放 Authorization，适配标准网关",
-        ),
-        (
-            "7 无任何鉴权头",
-            {},
-            "基准：对比有无鉴权头的响应差异",
-        ),
-    ]
-
-
-# --------------------------------------------------------------------------- #
-# 主流程
-# --------------------------------------------------------------------------- #
-def main() -> int:
-    ap = argparse.ArgumentParser(
-        description="汇吉采 → 一站式 出向推送联调探测",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    cfg_base, cfg_path = load_config()
-    cfg_key, cfg_pwd = load_credentials()
-
-    ap.add_argument("--base", default=cfg_base, help=f"一站式 base-url（默认读配置: {cfg_base}）")
-    ap.add_argument("--path", default=cfg_path, help=f"推送路径（默认读配置: {cfg_path}）")
-    ap.add_argument("--appkey", default=cfg_key, help="appKey")
-    ap.add_argument("--password", default=cfg_pwd, help="签名密钥 password")
-    ap.add_argument("--order-no", default=DEFAULT_ORDER_NO, help=f"订单号（默认固定值 {DEFAULT_ORDER_NO}）")
-    ap.add_argument("--payload", default=None, help="自定义请求体 JSON 文件")
-    ap.add_argument(
-        "--refund",
-        action="store_true",
-        help="推退款报文（status=REFUNDED，带 refundTime/refundReason）",
-    )
-    ap.add_argument(
-        "--paid-then-refund",
-        action="store_true",
-        help="同一订单号先推 PAID 基线、再推 REFUNDED（模拟真实退款状态流转）",
-    )
-    ap.add_argument(
-        "--refund-reason",
-        default=None,
-        help=f"退款原因（默认「{DEFAULT_REFUND_REASON}」，最长 {REFUND_REASON_MAX} 字符）",
-    )
-    ap.add_argument(
-        "--refund-time",
-        default=None,
-        help=f"退款时间，格式 {DT_FMT_HELP}（默认当前北京时间）",
-    )
-    ap.add_argument("--repeat", type=int, default=1, help="约定方案重复次数，用于验幂等（默认 1）")
-    ap.add_argument("--timeout", type=float, default=15.0, help="单请求超时秒数（默认 15）")
-    ap.add_argument("--quick", action="store_true", help="只跑约定方案，跳过变体矩阵与对照探测")
-    ap.add_argument("--no-control", action="store_true", help="跳过对照探测（不额外打扰对方服务）")
-    ap.add_argument("--dry-run", action="store_true", help="只打印请求，不发送")
-    ap.add_argument("--insecure", action="store_true", help="跳过 HTTPS 证书校验")
-    ap.add_argument("--json", dest="json_out", default=None, help="把完整结果写入 JSON 文件")
-    args = ap.parse_args()
-
-    now = bj_now()
-    ts = timestamp_str(now)
-    sign = sign_of(args.appkey, args.password, ts)
-    order_no = args.order_no
-    url = args.base.rstrip("/") + args.path
-
-    refund_time = None
-    if args.refund_time:
-        try:
-            refund_time = dt.datetime.strptime(args.refund_time.strip(), DT_FMT)
-        except ValueError:
-            print(f"❌ --refund-time 格式应为 {DT_FMT}，收到：{args.refund_time}", file=sys.stderr)
-            return 2
-
-    want_refund = args.refund or args.paid_then_refund
-    status = STATUS_REFUNDED if want_refund else STATUS_PAID
-    if not want_refund and not args.payload and (args.refund_reason or args.refund_time):
-        print(
-            "⚠️  --refund-reason/--refund-time 仅在 --refund 或 --paid-then-refund 下生效"
-            "（当前为 PAID 报文）",
-            file=sys.stderr,
-        )
-
-    if args.payload:
-        if want_refund:
-            print("⚠️  --payload 已指定，忽略 --refund/--paid-then-refund/--refund-reason/--refund-time", file=sys.stderr)
-        with open(args.payload, encoding="utf-8") as f:
-            payload = json.load(f)
-    else:
-        payload = default_payload(order_no, now, status, args.refund_reason, refund_time)
-
-    # 退款报文自检：本地先拦掉「必带字段缺失/时间格式错/超长」，避免白跑一轮联调
-    issues = refund_payload_issues(payload)
-    if issues:
-        print("❌ 退款报文自检未通过：", file=sys.stderr)
-        for it in issues:
-            print(f"   · {it}", file=sys.stderr)
-        return 2
-
-    # --paid-then-refund：同一订单号先落一条 PAID，再发 REFUNDED
-    paid_body = None
-    if args.paid_then_refund and not args.payload:
-        paid_body = json.dumps(
-            default_payload(order_no, now, STATUS_PAID), ensure_ascii=False
-        ).encode("utf-8")
-
-    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-
-    print("=" * 78)
-    print("汇吉采 → 一站式 出向推送探测" + ("（退款报文）" if payload.get("status") == STATUS_REFUNDED else ""))
-    print("=" * 78)
-    print(f"目标 URL   : {url}")
-    print(f"北京时间   : {now.strftime(DT_FMT)}  → timestamp={ts}")
-    print(f"appKey     : {args.appkey}")
-    print(f"sign       : {sign}")
-    print(f"订单号     : {order_no}")
-    print(f"订单状态   : {payload.get('status')}")
-    if payload.get("status") == STATUS_REFUNDED:
-        print(f"退款时间   : {payload.get('refundTime')}")
-        print(f"退款原因   : {payload.get('refundReason')}")
-    print(f"请求体     : {body.decode('utf-8')}")
-    if paid_body is not None:
-        print()
-        print("（--paid-then-refund：先发 PAID 基线）")
-        print(f"请求体     : {paid_body.decode('utf-8')}")
-    print()
-
-    if args.dry_run:
-        print("[dry-run] 未发送任何请求。等价 curl：")
-        if paid_body is not None:
-            print(
-                f"  # 1) 同一订单号先落 PAID\n"
-                f"  curl -i -X POST '{url}' \\\n"
-                f"    -H 'Content-Type: application/json' \\\n"
-                f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-                f"    -d '{paid_body.decode('utf-8')}'\n"
-                f"  # 2) 再推 REFUNDED（带退款时间/原因）"
-            )
-        print(
-            f"  curl -i -X POST '{url}' \\\n"
-            f"    -H 'Content-Type: application/json' \\\n"
-            f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-            f"    -d '{body.decode('utf-8')}'"
-        )
-        return 0
-
-    results: list[dict] = []
-
-    def run_case(name: str, headers: dict, note: str, target_url: str = url, use_body: bytes = body):
-        h = {"Content-Type": "application/json", **headers}
-        status_code, text, ms, err = post(target_url, use_body, h, args.timeout, args.insecure)
-        verdict = classify(status_code, text)
-        results.append(
-            {
-                "name": name,
-                "note": note,
-                "url": target_url,
-                "status": status_code,
-                "verdict": verdict,
-                "fingerprint": fingerprint(status_code, text),
-                "elapsed_ms": round(ms, 1),
-                "body": text,
-                "error": err,
-            }
-        )
-        shown = f"HTTP {status_code}" if status_code else "无响应"
-        print(f"  {name:<22} {shown:<9} {VERDICT_LABEL[verdict]:<18} {brief(err or text)}")
-        return results[-1]
-
-    matrix = case_matrix(args.appkey, args.password, ts, sign)
-
-    # ---------------- 阶段 0：（可选）PAID 基线 ----------------
-    # 退款推送要针对「已在一站式存在的订单」，故先用同一订单号落一条 PAID 记录。
-    if paid_body is not None:
-        print("── 阶段 0：PAID 基线（同一订单号，先建立已支付记录）──")
-        run_case("0 PAID 基线", matrix[0][1], "退款前先落一条已支付记录", use_body=paid_body)
-        print()
-
-    # ---------------- 阶段 1：约定方案（含 repeat 幂等验证） ----------------
-    print(f"── 阶段 1：文档约定方案{'（连打 %d 次验幂等）' % args.repeat if args.repeat > 1 else ''} ──")
-    primary = run_case(matrix[0][0], matrix[0][1], matrix[0][2])
-    for i in range(2, args.repeat + 1):
-        run_case(f"1 文档约定方案 #{i}", matrix[0][1], "幂等复打")
-
-    if not args.quick:
-        # ---------------- 阶段 2：鉴权头变体 ----------------
-        print()
-        print("── 阶段 2：鉴权头变体矩阵（用于区分「签名不对」与「未校验签名」）──")
-        for name, headers, note in matrix[1:]:
-            run_case(name, headers, note)
-
-        # query 参数形式单独处理（不带请求头）
-        q = urllib.parse.urlencode(
-            {"appKey": args.appkey, "password": args.password, "timestamp": ts, "sign": sign}
-        )
-        run_case("8 query 参数", {}, "凭据放 URL query", target_url=f"{url}?{q}")
-
-    # ---------------- 阶段 3：对照探测 ----------------
-    # 仅在失败时才有诊断价值；已成功就不再给对方发多余请求。
-    controls: list[dict] = []
-    if not args.no_control and primary["verdict"] != "OK":
-        print()
-        print("── 阶段 3：对照探测（定位失败发生在哪一层）──")
-        parts = [p for p in args.path.strip("/").split("/") if p]
-        if len(parts) >= 2:
-            protected_nope = "/" + "/".join(parts[:-1] + ["__probe_nope__"])
-            reference_nope = "/" + "/".join(parts[:1] + ["auth", "__probe_nope__"])
-            ctl_headers = matrix[0][1]
-            for label, p, note in (
-                ("C1 同前缀不存在路径", protected_nope, "若与目标接口响应一致 → 拦截发生在路由解析之前"),
-                ("C2 另一前缀不存在路径", reference_nope, "未受保护的参照组，应为干净的 404"),
-            ):
-                controls.append(
-                    run_case(label, ctl_headers, note, target_url=args.base.rstrip("/") + p)
-                )
-        else:
-            print("  （路径层级不足，跳过对照探测）")
-
-    # ---------------- 结论 ----------------
-    print()
-    print("=" * 78)
-    print("结论")
-    print("=" * 78)
-
-    primary_verdict = primary["verdict"]
-    success = primary_verdict == "OK"
-
-    # 与「同前缀不存在路径」对照：错误语义一致说明根本没走到路由
-    same_as_control = bool(
-        controls
-        and controls[0]["status"] == primary["status"]
-        and controls[0]["fingerprint"] == primary["fingerprint"]
-    )
-
-    if success:
-        print("✅ 出向对接成功：目标接口返回 2xx，对方已接受并（应已）落盘。")
-        if args.repeat > 1:
-            ok_all = all(r["verdict"] == "OK" for r in results if r["name"].startswith("1 "))
-            print(
-                f"   幂等复打 {args.repeat} 次：{'全部 2xx ✅' if ok_all else '存在非 2xx，请检查幂等处理 ❌'}"
-            )
-    else:
-        print(f"❌ 出向对接失败：约定方案判定为「{VERDICT_LABEL[primary_verdict]}」。")
-        print()
-        if primary_verdict == "LOGIN_FILTER":
-            print("定位：请求被对方的**登录态过滤器**拒绝，与签名无关。依据：")
-            if same_as_control:
-                print("  · 同一套凭据打「同前缀下不存在的路径」，响应与真实接口**完全一致**")
-                print("    → 拒绝发生在路由解析之前，接口是否存在、签名是否正确都影响不到它。")
-            print("  · 响应体是登录错误而非「签名校验失败」，说明对方的验签逻辑没有被执行。")
-            print()
-            print("需对方处理：把该接口加入免登录白名单并实现约定验签，或提供获取调用 Token 的方式。")
-        elif primary_verdict == "SIGN_REJECT":
-            print("定位：对方已放行到验签逻辑，但签名不通过 → 属于**算法/密钥不一致**。")
-            print("建议：让对方用下面这组固定值离线自证，无需部署：")
-            print(f"    appKey={args.appkey}  timestamp={ts}  sign={sign}")
-            print("    若对方算不出同一 sign，核对 password 取值与拼接顺序（是否含分隔符、大小写）。")
-        elif primary_verdict == "TS_REJECT":
-            print("定位：时间戳被拒 → 核对对方服务器时间与北京时区，以及允许窗口（约定 ±10 分钟）。")
-        elif primary_verdict == "NOT_FOUND":
-            print("定位：路由不存在 → 路径或 base-url 不对，需对方确认接口实际地址与端口。")
-        elif primary_verdict == "UNREACHABLE":
-            print(f"定位：网络不可达 → {primary['error']}")
-            print("建议：确认对方服务已启动、端口开放、本机到该地址无防火墙/白名单限制。")
-        else:
-            print("未能自动归类，请把上面的响应原文提供给对方排查。")
-
-        # 变体是否出现「与基准不同」的响应——若全一致，进一步佐证签名未被校验
-        if not args.quick:
-            variants = [
-                r
-                for r in results
-                if r["name"][0].isdigit() and not r["name"].startswith(("0 ", "1 "))
-            ]
-            distinct = {r["fingerprint"] for r in variants}
-            if len(distinct) <= 1 and variants:
-                print()
-                print("补充：全部鉴权头变体（含不带任何头的基准）响应**完全相同**")
-                print("      → 对方当前没有对请求头做任何区分，签名校验尚未生效。")
-
-    # 退款模式补充结论：PAID 基线 + REFUNDED 是否都通过（退款字段是否被对方接受）
-    if payload.get("status") == STATUS_REFUNDED:
-        print()
-        paid_base = next((r for r in results if r["name"].startswith("0 ")), None)
-        if paid_base is not None:
-            print(
-                f"PAID 基线    : {VERDICT_LABEL[paid_base['verdict']]}（同一订单号 {order_no}）"
-                + ("" if paid_base["verdict"] == "OK" else " ← 基线未通过，退款结果可能不可信")
-            )
-        print(
-            f"REFUNDED 报文: {VERDICT_LABEL[primary_verdict]}，"
-            f"refundTime={payload.get('refundTime')} / refundReason={payload.get('refundReason')}"
-        )
-
-    print()
-    print(f"复现命令（可直接发给对方）：")
-    if paid_body is not None:
-        print(
-            f"  # 1) 同一订单号先落 PAID\n"
-            f"  curl -i -X POST '{url}' -H 'Content-Type: application/json' \\\n"
-            f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-            f"    -d '{paid_body.decode('utf-8')}'\n"
-            f"  # 2) 再推 REFUNDED（带退款时间/原因）"
-        )
-    print(
-        f"  curl -i -X POST '{url}' \\\n"
-        f"    -H 'Content-Type: application/json' \\\n"
-        f"    -H 'appKey: {args.appkey}' -H 'timestamp: {ts}' -H 'sign: {sign}' \\\n"
-        f"    -d '{body.decode('utf-8')}'"
-    )
-
-    if args.json_out:
-        with open(args.json_out, "w", encoding="utf-8") as f:
-            json.dump(
-                {
-                    "base": args.base,
-                    "path": args.path,
-                    "url": url,
-                    "timestamp": ts,
-                    "sign": sign,
-                    "appKey": args.appkey,
-                    "orderNo": order_no,
-                    "orderStatus": payload.get("status"),
-                    "refundTime": payload.get("refundTime"),
-                    "refundReason": payload.get("refundReason"),
-                    "paidThenRefund": args.paid_then_refund,
-                    "payload": payload,
-                    "results": results,
-                    "controls": controls,
-                    "verdict": primary_verdict,
-                    "success": success,
-                },
-                f,
-                ensure_ascii=False,
-                indent=2,
-            )
-        print(f"\n完整结果已写入：{args.json_out}")
-
-    return 0 if success else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/main/java/com/gxwebsoft/ai/client/OllamaClient.java

@@ -0,0 +1,194 @@
+package com.gxwebsoft.ai.client;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.gxwebsoft.ai.client.dto.*;
+import com.gxwebsoft.ai.config.AiOllamaProperties;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import com.gxwebsoft.common.core.utils.JSONUtil;
+import okhttp3.*;
+import okio.BufferedSource;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+/**
+ * 轻量 Ollama HTTP Client（兼容 /api/chat、/api/embeddings、/api/tags）。
+ */
+@Component
+public class OllamaClient {
+  @Resource
+  private AiOllamaProperties props;
+
+  @Resource
+  private ObjectMapper objectMapper;
+
+  private volatile OkHttpClient http;
+
+  private OkHttpClient http() {
+    OkHttpClient c = http;
+    if (c != null) {
+      return c;
+    }
+    synchronized (this) {
+      if (http == null) {
+        http = new OkHttpClient.Builder()
+          .connectTimeout(Duration.ofMillis(props.getConnectTimeoutMs()))
+          .readTimeout(Duration.ofMillis(props.getReadTimeoutMs()))
+          .writeTimeout(Duration.ofMillis(props.getWriteTimeoutMs()))
+          .build();
+      }
+      return http;
+    }
+  }
+
+  public OllamaTagsResponse tags() {
+    return getJson("/api/tags", OllamaTagsResponse.class);
+  }
+
+  public OllamaChatResponse chat(OllamaChatRequest req) {
+    if (req.getStream() == null) {
+      req.setStream(false);
+    }
+    return postJson("/api/chat", req, OllamaChatResponse.class);
+  }
+
+  /**
+   * 流式对话：Ollama 会返回按行分隔的 JSON。
+   */
+  public void chatStream(OllamaChatRequest req, Consumer<OllamaChatResponse> onEvent) {
+    Objects.requireNonNull(onEvent, "onEvent");
+    if (req.getStream() == null) {
+      req.setStream(true);
+    }
+
+    Request request = buildPost(baseUrl(), "/api/chat", JSONUtil.toJSONString(req));
+    try (Response resp = http().newCall(request).execute()) {
+      if (!resp.isSuccessful()) {
+        throw new BusinessException("Ollama chat stream failed: HTTP " + resp.code());
+      }
+      ResponseBody body = resp.body();
+      if (body == null) {
+        throw new BusinessException("Ollama chat stream failed: empty body");
+      }
+
+      BufferedSource source = body.source();
+      String line;
+      while ((line = source.readUtf8Line()) != null) {
+        line = line.trim();
+        if (line.isEmpty()) {
+          continue;
+        }
+        OllamaChatResponse event = objectMapper.readValue(line, OllamaChatResponse.class);
+        onEvent.accept(event);
+        if (Boolean.TRUE.equals(event.getDone())) {
+          break;
+        }
+      }
+    } catch (IOException e) {
+      throw new BusinessException("Ollama chat stream IO error: " + e.getMessage());
+    }
+  }
+
+  public OllamaEmbeddingResponse embedding(String prompt) {
+    OllamaEmbeddingRequest req = new OllamaEmbeddingRequest();
+    req.setModel(props.getEmbedModel());
+    req.setPrompt(prompt);
+    return postJson("/api/embeddings", req, OllamaEmbeddingResponse.class);
+  }
+
+  private String baseUrl() {
+    if (props.getBaseUrl() == null || props.getBaseUrl().trim().isEmpty()) {
+      throw new BusinessException("ai.ollama.base-url 未配置");
+    }
+    return props.getBaseUrl().trim();
+  }
+
+  private String fallbackUrl() {
+    if (props.getFallbackUrl() == null || props.getFallbackUrl().trim().isEmpty()) {
+      return null;
+    }
+    return props.getFallbackUrl().trim();
+  }
+
+  private <T> T getJson(String path, Class<T> clazz) {
+    try {
+      return getJsonOnce(baseUrl(), path, clazz);
+    } catch (Exception e) {
+      String fb = fallbackUrl();
+      if (fb == null) {
+        throw e;
+      }
+      return getJsonOnce(fb, path, clazz);
+    }
+  }
+
+  private <T> T getJsonOnce(String base, String path, Class<T> clazz) {
+    Request req = new Request.Builder()
+      .url(join(base, path))
+      .get()
+      .build();
+    try (Response resp = http().newCall(req).execute()) {
+      if (!resp.isSuccessful()) {
+        throw new BusinessException("Ollama GET failed: HTTP " + resp.code());
+      }
+      ResponseBody body = resp.body();
+      if (body == null) {
+        throw new BusinessException("Ollama GET failed: empty body");
+      }
+      return objectMapper.readValue(body.string(), clazz);
+    } catch (IOException e) {
+      throw new BusinessException("Ollama GET IO error: " + e.getMessage());
+    }
+  }
+
+  private <T> T postJson(String path, Object payload, Class<T> clazz) {
+    String json = JSONUtil.toJSONString(payload);
+    try {
+      return postJsonOnce(baseUrl(), path, json, clazz);
+    } catch (Exception e) {
+      String fb = fallbackUrl();
+      if (fb == null) {
+        throw e;
+      }
+      return postJsonOnce(fb, path, json, clazz);
+    }
+  }
+
+  private <T> T postJsonOnce(String base, String path, String json, Class<T> clazz) {
+    Request req = buildPost(base, path, json);
+    try (Response resp = http().newCall(req).execute()) {
+      if (!resp.isSuccessful()) {
+        throw new BusinessException("Ollama POST failed: HTTP " + resp.code());
+      }
+      ResponseBody body = resp.body();
+      if (body == null) {
+        throw new BusinessException("Ollama POST failed: empty body");
+      }
+      return objectMapper.readValue(body.string(), clazz);
+    } catch (IOException e) {
+      throw new BusinessException("Ollama POST IO error: " + e.getMessage());
+    }
+  }
+
+  private Request buildPost(String base, String path, String json) {
+    RequestBody body = RequestBody.create(json, MediaType.parse("application/json; charset=utf-8"));
+    return new Request.Builder()
+      .url(join(base, path))
+      .post(body)
+      .build();
+  }
+
+  private static String join(String base, String path) {
+    String b = base;
+    if (b.endsWith("/")) {
+      b = b.substring(0, b.length() - 1);
+    }
+    String p = path.startsWith("/") ? path : ("/" + path);
+    return b + p;
+  }
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaChatRequest.java

@@ -0,0 +1,19 @@
+package com.gxwebsoft.ai.client.dto;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class OllamaChatRequest {
+  private String model;
+  private List<OllamaMessage> messages;
+  private Boolean stream;
+
+  /**
+   * Ollama options，例如：temperature、top_k、top_p、num_predict...
+   */
+  private Map<String, Object> options;
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaChatResponse.java

@@ -0,0 +1,28 @@
+package com.gxwebsoft.ai.client.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class OllamaChatResponse {
+  private String model;
+
+  @JsonProperty("created_at")
+  private String createdAt;
+
+  private OllamaMessage message;
+
+  private Boolean done;
+
+  @JsonProperty("total_duration")
+  private Long totalDuration;
+
+  @JsonProperty("prompt_eval_count")
+  private Integer promptEvalCount;
+
+  @JsonProperty("eval_count")
+  private Integer evalCount;
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaEmbeddingRequest.java

@@ -0,0 +1,14 @@
+package com.gxwebsoft.ai.client.dto;
+
+import lombok.Data;
+
+@Data
+public class OllamaEmbeddingRequest {
+  private String model;
+
+  /**
+   * Ollama embeddings 目前常用字段为 prompt。
+   */
+  private String prompt;
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaEmbeddingResponse.java

@@ -0,0 +1,13 @@
+package com.gxwebsoft.ai.client.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class OllamaEmbeddingResponse {
+  private List<Double> embedding;
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaMessage.java

@@ -0,0 +1,14 @@
+package com.gxwebsoft.ai.client.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class OllamaMessage {
+  private String role;
+  private String content;
+}
+

src/main/java/com/gxwebsoft/ai/client/dto/OllamaTagsResponse.java

@@ -0,0 +1,22 @@
+package com.gxwebsoft.ai.client.dto;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class OllamaTagsResponse {
+  private List<Model> models;
+
+  @Data
+  @JsonIgnoreProperties(ignoreUnknown = true)
+  public static class Model {
+    private String name;
+    private Long size;
+    private String digest;
+    private String modified_at;
+  }
+}
+

src/main/java/com/gxwebsoft/ai/config/AiOllamaProperties.java

@@ -0,0 +1,68 @@
+package com.gxwebsoft.ai.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * Ollama API 配置。
+ *
+ * 说明：本项目通过自建 Ollama 网关提供服务，因此这里用 baseUrl + fallbackUrl。
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "ai.ollama")
+public class AiOllamaProperties {
+  /**
+   * 主地址，例如：https://ai-api.websoft.top
+   */
+  private String baseUrl;
+
+  /**
+   * 备用地址，例如：http://47.119.165.234:11434
+   */
+  private String fallbackUrl;
+
+  /**
+   * 对话模型，例如：qwen3.5:cloud
+   */
+  private String chatModel;
+
+  /**
+   * 向量模型，例如：qwen3-embedding:4b
+   */
+  private String embedModel;
+
+  /**
+   * HTTP 超时（毫秒）。
+   */
+  private long connectTimeoutMs = 10_000;
+  private long readTimeoutMs = 300_000;
+  private long writeTimeoutMs = 60_000;
+
+  /**
+   * 并发上限（用于 embedding/入库等批处理场景）。
+   */
+  private int maxConcurrency = 4;
+
+  /**
+   * RAG：检索候选 chunk 最大数量（避免一次性拉取过多数据导致内存/耗时过高）。
+   */
+  private int ragMaxCandidates = 2000;
+
+  /**
+   * RAG：检索返回 topK。
+   */
+  private int ragTopK = 5;
+
+  /**
+   * RAG：单个 chunk 最大字符数（用于入库切分）。
+   */
+  private int ragChunkSize = 800;
+
+  /**
+   * RAG：chunk 重叠字符数（用于减少语义断裂）。
+   */
+  private int ragChunkOverlap = 120;
+}
+

src/main/java/com/gxwebsoft/ai/controller/AiAnalyticsController.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.ai.controller;
+
+import com.gxwebsoft.ai.dto.*;
+import com.gxwebsoft.ai.service.AiAnalyticsService;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.BaseController;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+
+@Tag(name = "AI - 订单数据分析")
+@RestController
+@RequestMapping("/api/ai/analytics")
+public class AiAnalyticsController extends BaseController {
+  @Resource
+  private AiAnalyticsService analyticsService;
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "查询商城订单按天指标（当前租户）")
+  @PostMapping("/query")
+  public ApiResult<AiShopMetricsQueryResult> query(@RequestBody AiShopMetricsQueryRequest request) {
+    Integer tenantId = getTenantId();
+    return success(analyticsService.queryShopMetrics(tenantId, request));
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "AI 解析并输出订单分析结论（当前租户）")
+  @PostMapping("/ask")
+  public ApiResult<AiAnalyticsAskResult> ask(@RequestBody AiAnalyticsAskRequest request) {
+    Integer tenantId = getTenantId();
+    return success(analyticsService.askShopAnalytics(tenantId, request));
+  }
+}
+

src/main/java/com/gxwebsoft/ai/controller/AiChatController.java

@@ -0,0 +1,95 @@
+package com.gxwebsoft.ai.controller;
+
+import com.gxwebsoft.ai.client.OllamaClient;
+import com.gxwebsoft.ai.client.dto.OllamaChatResponse;
+import com.gxwebsoft.ai.client.dto.OllamaTagsResponse;
+import com.gxwebsoft.ai.dto.AiChatRequest;
+import com.gxwebsoft.ai.dto.AiChatResult;
+import com.gxwebsoft.ai.dto.AiMessage;
+import com.gxwebsoft.ai.service.AiChatService;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.BaseController;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import javax.annotation.Resource;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+@Tag(name = "AI - 对话")
+@RestController
+@RequestMapping("/api/ai")
+public class AiChatController extends BaseController {
+  @Resource
+  private OllamaClient ollamaClient;
+
+  @Resource
+  private AiChatService aiChatService;
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "获取 Ollama 模型列表")
+  @GetMapping("/models")
+  public ApiResult<OllamaTagsResponse> models() {
+    return success(ollamaClient.tags());
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "非流式对话")
+  @PostMapping("/chat")
+  public ApiResult<AiChatResult> chat(@RequestBody AiChatRequest request) {
+    return success(aiChatService.chat(request));
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "流式对话（SSE）")
+  @PostMapping("/chat/stream")
+  public SseEmitter chatStream(@RequestBody AiChatRequest request) {
+    // 10 分钟超时（可根据前端需要调整）
+    SseEmitter emitter = new SseEmitter(10 * 60 * 1000L);
+
+    CompletableFuture.runAsync(() -> {
+      try {
+        aiChatService.chatStream(request,
+          delta -> {
+            try {
+              emitter.send(SseEmitter.event().name("delta").data(delta));
+            } catch (Exception e) {
+              // 客户端断开会触发 send 异常，这里直接结束即可
+              emitter.complete();
+            }
+          },
+          (OllamaChatResponse done) -> {
+            try {
+              Map<String, Object> meta = new LinkedHashMap<>();
+              meta.put("model", done.getModel());
+              meta.put("prompt_eval_count", done.getPromptEvalCount());
+              meta.put("eval_count", done.getEvalCount());
+              meta.put("total_duration", done.getTotalDuration());
+              emitter.send(SseEmitter.event().name("done").data(meta));
+            } catch (Exception ignored) {
+            } finally {
+              emitter.complete();
+            }
+          });
+      } catch (Exception e) {
+        emitter.completeWithError(e);
+      }
+    });
+
+    return emitter;
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "流式对话（SSE, GET 版本，便于 EventSource）")
+  @GetMapping("/chat/stream")
+  public SseEmitter chatStreamGet(@RequestParam("prompt") String prompt) {
+    AiChatRequest req = new AiChatRequest();
+    req.setMessages(Collections.singletonList(new AiMessage("user", prompt)));
+    return chatStream(req);
+  }
+}

src/main/java/com/gxwebsoft/ai/controller/AiKbController.java

@@ -0,0 +1,54 @@
+package com.gxwebsoft.ai.controller;
+
+import com.gxwebsoft.ai.dto.*;
+import com.gxwebsoft.ai.service.AiKbRagService;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.BaseController;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+
+@Tag(name = "AI - 知识库(RAG)")
+@RestController
+@RequestMapping("/api/ai/kb")
+public class AiKbController extends BaseController {
+  @Resource
+  private AiKbRagService ragService;
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "上传文档入库（txt/md/html 优先）")
+  @PostMapping("/upload")
+  public ApiResult<AiKbIngestResult> upload(@RequestParam("file") MultipartFile file) {
+    Integer tenantId = getTenantId();
+    return success(ragService.ingestUpload(tenantId, file));
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "同步 CMS 文章到知识库（当前租户）")
+  @PostMapping("/sync/cms")
+  public ApiResult<AiKbIngestResult> syncCms() {
+    Integer tenantId = getTenantId();
+    return success(ragService.syncCms(tenantId));
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "仅检索（返回 topK 命中）")
+  @PostMapping("/query")
+  public ApiResult<AiKbQueryResult> query(@RequestBody AiKbQueryRequest request) {
+    Integer tenantId = getTenantId();
+    return success(ragService.query(tenantId, request));
+  }
+
+  @PreAuthorize("isAuthenticated()")
+  @Operation(summary = "知识库问答（RAG 生成 + 返回检索结果）")
+  @PostMapping("/ask")
+  public ApiResult<AiKbAskResult> ask(@RequestBody AiKbAskRequest request) {
+    Integer tenantId = getTenantId();
+    return success(ragService.ask(tenantId, request));
+  }
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiAnalyticsAskRequest.java

@@ -0,0 +1,13 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiAnalyticsAskRequest", description = "AI 数据分析提问")
+public class AiAnalyticsAskRequest {
+  private String question;
+  private String startDate;
+  private String endDate;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiAnalyticsAskResult.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiAnalyticsAskResult", description = "AI 数据分析结果")
+public class AiAnalyticsAskResult {
+  private String analysis;
+  private AiShopMetricsQueryResult data;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiChatRequest.java

@@ -0,0 +1,35 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@Schema(name = "AiChatRequest", description = "AI 对话请求")
+public class AiChatRequest {
+  @Schema(description = "可选：直接传一句话。若 messages 为空则使用该字段构造 user message")
+  private String prompt;
+
+  @Schema(description = "可选：OpenAI 风格 messages（role: system/user/assistant）")
+  private List<AiMessage> messages;
+
+  @Schema(description = "可选：覆盖默认模型")
+  private String model;
+
+  @Schema(description = "是否流式输出（/chat/stream 端点通常忽略此字段）")
+  private Boolean stream;
+
+  @Schema(description = "temperature")
+  private Double temperature;
+
+  @Schema(description = "top_k")
+  private Integer topK;
+
+  @Schema(description = "top_p")
+  private Double topP;
+
+  @Schema(description = "num_predict（类似 max_tokens）")
+  private Integer numPredict;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiChatResult.java

@@ -0,0 +1,15 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(name = "AiChatResult", description = "AI 对话结果")
+public class AiChatResult {
+  private String content;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbAskRequest.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiKbAskRequest", description = "知识库问答请求")
+public class AiKbAskRequest {
+  private String question;
+  private Integer topK;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbAskResult.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiKbAskResult", description = "知识库问答结果")
+public class AiKbAskResult {
+  private String answer;
+  private AiKbQueryResult retrieval;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbHit.java

@@ -0,0 +1,15 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiKbHit", description = "知识库命中")
+public class AiKbHit {
+  private String chunkId;
+  private Integer documentId;
+  private String title;
+  private Double score;
+  private String content;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbIngestResult.java

@@ -0,0 +1,15 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiKbIngestResult", description = "知识库入库结果")
+public class AiKbIngestResult {
+  private Integer documentId;
+  private String title;
+  private Integer chunks;
+  private Integer updatedDocuments;
+  private Integer skippedDocuments;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbQueryRequest.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiKbQueryRequest", description = "知识库检索请求")
+public class AiKbQueryRequest {
+  private String query;
+  private Integer topK;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiKbQueryResult.java

@@ -0,0 +1,13 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@Schema(name = "AiKbQueryResult", description = "知识库检索结果")
+public class AiKbQueryResult {
+  private List<AiKbHit> hits;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiMessage.java

@@ -0,0 +1,14 @@
+package com.gxwebsoft.ai.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class AiMessage {
+  private String role;
+  private String content;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiShopMetricsQueryRequest.java

@@ -0,0 +1,18 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(name = "AiShopMetricsQueryRequest", description = "商城订单指标查询请求")
+public class AiShopMetricsQueryRequest {
+  @Schema(description = "开始日期(YYYY-MM-DD)")
+  private String startDate;
+
+  @Schema(description = "结束日期(YYYY-MM-DD)，包含该天")
+  private String endDate;
+
+  @Schema(description = "是否按天分组，默认 true")
+  private Boolean groupByDay;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiShopMetricsQueryResult.java

@@ -0,0 +1,16 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+@Schema(name = "AiShopMetricsQueryResult", description = "商城订单指标查询结果")
+public class AiShopMetricsQueryResult {
+  private Integer tenantId;
+  private String startDate;
+  private String endDate;
+  private List<AiShopMetricsRow> rows;
+}
+

src/main/java/com/gxwebsoft/ai/dto/AiShopMetricsRow.java

@@ -0,0 +1,23 @@
+package com.gxwebsoft.ai.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+@Data
+@Schema(name = "AiShopMetricsRow", description = "商城订单指标行（按 tenant/day）")
+public class AiShopMetricsRow {
+  private Integer tenantId;
+  private String day;
+
+  private Long orderCnt;
+  private Long paidOrderCnt;
+  private BigDecimal gmv;
+  private BigDecimal refundAmt;
+  private Long payUserCnt;
+
+  private BigDecimal aov;
+  private BigDecimal payRate;
+}
+

src/main/java/com/gxwebsoft/ai/entity/AiKbChunk.java

@@ -0,0 +1,57 @@
+package com.gxwebsoft.ai.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 知识库分段（chunk）。
+ */
+@Data
+@Schema(name = "AiKbChunk", description = "AI 知识库分段")
+public class AiKbChunk implements Serializable {
+  private static final long serialVersionUID = 1L;
+
+  @TableId(value = "id", type = IdType.AUTO)
+  private Integer id;
+
+  private Integer documentId;
+
+  /**
+   * 外部引用用的唯一 ID（便于在答案里引用）。
+   */
+  private String chunkId;
+
+  private Integer chunkIndex;
+
+  private String title;
+
+  private String content;
+
+  private String contentHash;
+
+  /**
+   * embedding JSON（数组），存成文本便于快速落库。
+   */
+  private String embedding;
+
+  /**
+   * embedding 的 L2 范数，用于余弦相似度。
+   */
+  private Double embeddingNorm;
+
+  @TableLogic
+  private Integer deleted;
+
+  private Integer tenantId;
+
+  @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+  private LocalDateTime createTime;
+}
+

src/main/java/com/gxwebsoft/ai/entity/AiKbDocument.java

@@ -0,0 +1,59 @@
+package com.gxwebsoft.ai.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * 知识库文档（来源：上传、CMS 等）。
+ */
+@Data
+@Schema(name = "AiKbDocument", description = "AI 知识库文档")
+public class AiKbDocument implements Serializable {
+  private static final long serialVersionUID = 1L;
+
+  @TableId(value = "document_id", type = IdType.AUTO)
+  private Integer documentId;
+
+  private String title;
+
+  /**
+   * upload / cms
+   */
+  private String sourceType;
+
+  /**
+   * 例如 CMS article_id
+   */
+  private Integer sourceId;
+
+  /**
+   * 例如文件名、路径等
+   */
+  private String sourceRef;
+
+  /**
+   * 文档文本内容哈希（用于增量同步/去重）。
+   */
+  private String contentHash;
+
+  private Integer status;
+
+  @TableLogic
+  private Integer deleted;
+
+  private Integer tenantId;
+
+  @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+  private LocalDateTime updateTime;
+
+  @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+  private LocalDateTime createTime;
+}
+

src/main/java/com/gxwebsoft/ai/mapper/AiKbChunkMapper.java

@@ -0,0 +1,10 @@
+package com.gxwebsoft.ai.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gxwebsoft.ai.entity.AiKbChunk;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface AiKbChunkMapper extends BaseMapper<AiKbChunk> {
+}
+

src/main/java/com/gxwebsoft/ai/mapper/AiKbDocumentMapper.java

@@ -0,0 +1,10 @@
+package com.gxwebsoft.ai.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.gxwebsoft.ai.entity.AiKbDocument;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface AiKbDocumentMapper extends BaseMapper<AiKbDocument> {
+}
+

src/main/java/com/gxwebsoft/ai/mapper/AiShopAnalyticsMapper.java

@@ -0,0 +1,16 @@
+package com.gxwebsoft.ai.mapper;
+
+import com.gxwebsoft.ai.dto.AiShopMetricsRow;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Mapper
+public interface AiShopAnalyticsMapper {
+  List<AiShopMetricsRow> queryMetrics(@Param("tenantId") Integer tenantId,
+                                      @Param("start") LocalDateTime start,
+                                      @Param("end") LocalDateTime end);
+}
+

src/main/java/com/gxwebsoft/ai/mapper/xml/AiShopAnalyticsMapper.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.gxwebsoft.ai.mapper.AiShopAnalyticsMapper">
+
+  <select id="queryMetrics" resultType="com.gxwebsoft.ai.dto.AiShopMetricsRow">
+    SELECT
+      tenant_id,
+      DATE_FORMAT(create_time, '%Y-%m-%d') AS day,
+      COUNT(1) AS order_cnt,
+      SUM(CASE WHEN pay_status = 1 THEN 1 ELSE 0 END) AS paid_order_cnt,
+      SUM(CASE WHEN pay_status = 1 THEN COALESCE(pay_price, 0) ELSE 0 END) AS gmv,
+      SUM(CASE WHEN COALESCE(refund_money, 0) &gt; 0 THEN COALESCE(refund_money, 0) ELSE 0 END) AS refund_amt,
+      COUNT(DISTINCT IF(pay_status = 1, user_id, NULL)) AS pay_user_cnt
+    FROM shop_order
+    WHERE deleted = 0
+      AND tenant_id = #{tenantId}
+      AND create_time &gt;= #{start}
+      AND create_time &lt; #{end}
+    GROUP BY tenant_id, DATE_FORMAT(create_time, '%Y-%m-%d')
+    ORDER BY day ASC
+  </select>
+
+</mapper>
+

src/main/java/com/gxwebsoft/ai/prompt/AiPrompts.java

@@ -0,0 +1,24 @@
+package com.gxwebsoft.ai.prompt;
+
+/**
+ * 统一提示词模板（尽量简短、可控）。
+ */
+public class AiPrompts {
+  private AiPrompts() {
+  }
+
+  public static final String SYSTEM_SUPPORT =
+    "你是 WebSoft 客服AI。规则：\n" +
+      "- 只使用给定的“上下文资料”回答，禁止编造。\n" +
+      "- 如果资料不足，直接说“资料不足”，并列出需要补充的信息。\n" +
+      "- 答案末尾必须给引用，格式：[source:chunk_id]。\n" +
+      "- 输出中文，简洁可执行。\n";
+
+  public static final String SYSTEM_ANALYTICS =
+    "你是商城订单数据分析助手。你将基于提供的按天指标数据给出结论。\n" +
+      "要求：\n" +
+      "- 只基于数据陈述，不要编造不存在的数字。\n" +
+      "- 输出包含：结论、关键指标变化、异常点、建议的下一步核查。\n" +
+      "- 输出中文，简洁。\n";
+}
+

src/main/java/com/gxwebsoft/ai/service/AiAnalyticsService.java

@@ -0,0 +1,82 @@
+package com.gxwebsoft.ai.service;
+
+import cn.hutool.core.util.StrUtil;
+import com.gxwebsoft.ai.dto.*;
+import com.gxwebsoft.ai.prompt.AiPrompts;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import com.gxwebsoft.common.core.utils.JSONUtil;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.time.LocalDate;
+import java.time.format.DateTimeParseException;
+import java.util.Arrays;
+
+@Service
+public class AiAnalyticsService {
+  @Resource
+  private AiShopAnalyticsService shopAnalyticsService;
+  @Resource
+  private AiChatService aiChatService;
+
+  public AiShopMetricsQueryResult queryShopMetrics(Integer tenantId, AiShopMetricsQueryRequest request) {
+    if (tenantId == null) {
+      throw new BusinessException("tenantId 不能为空");
+    }
+    if (request == null) {
+      throw new BusinessException("请求不能为空");
+    }
+    LocalDate start = parseDate(request.getStartDate(), "startDate");
+    LocalDate end = parseDate(request.getEndDate(), "endDate");
+    if (end.isBefore(start)) {
+      throw new BusinessException("endDate 不能早于 startDate");
+    }
+
+    AiShopMetricsQueryResult r = new AiShopMetricsQueryResult();
+    r.setTenantId(tenantId);
+    r.setStartDate(start.toString());
+    r.setEndDate(end.toString());
+    r.setRows(shopAnalyticsService.queryTenantDaily(tenantId, start, end));
+    return r;
+  }
+
+  public AiAnalyticsAskResult askShopAnalytics(Integer tenantId, AiAnalyticsAskRequest request) {
+    if (request == null || StrUtil.isBlank(request.getQuestion())) {
+      throw new BusinessException("question 不能为空");
+    }
+    AiShopMetricsQueryRequest q = new AiShopMetricsQueryRequest();
+    q.setStartDate(request.getStartDate());
+    q.setEndDate(request.getEndDate());
+    q.setGroupByDay(true);
+    AiShopMetricsQueryResult data = queryShopMetrics(tenantId, q);
+
+    String userPrompt =
+      "用户问题：\n" + request.getQuestion() + "\n\n" +
+        "数据（JSON，字段含义：order_cnt=订单数，paid_order_cnt=已支付订单数，gmv=已支付金额，refund_amt=退款金额，pay_user_cnt=支付用户数，aov=客单价，pay_rate=支付率）：\n" +
+        JSONUtil.toJSONString(data, true);
+
+    AiChatRequest chat = new AiChatRequest();
+    chat.setMessages(Arrays.asList(
+      new AiMessage("system", AiPrompts.SYSTEM_ANALYTICS),
+      new AiMessage("user", userPrompt)
+    ));
+
+    AiChatResult resp = aiChatService.chat(chat);
+    AiAnalyticsAskResult r = new AiAnalyticsAskResult();
+    r.setAnalysis(resp.getContent());
+    r.setData(data);
+    return r;
+  }
+
+  private static LocalDate parseDate(String s, String field) {
+    if (StrUtil.isBlank(s)) {
+      throw new BusinessException(field + " 不能为空，格式 YYYY-MM-DD");
+    }
+    try {
+      return LocalDate.parse(s.trim());
+    } catch (DateTimeParseException e) {
+      throw new BusinessException(field + " 格式错误，需 YYYY-MM-DD");
+    }
+  }
+}
+

src/main/java/com/gxwebsoft/ai/service/AiChatService.java

@@ -0,0 +1,94 @@
+package com.gxwebsoft.ai.service;
+
+import cn.hutool.core.util.StrUtil;
+import com.gxwebsoft.ai.client.OllamaClient;
+import com.gxwebsoft.ai.client.dto.OllamaChatRequest;
+import com.gxwebsoft.ai.client.dto.OllamaChatResponse;
+import com.gxwebsoft.ai.client.dto.OllamaMessage;
+import com.gxwebsoft.ai.config.AiOllamaProperties;
+import com.gxwebsoft.ai.dto.AiChatRequest;
+import com.gxwebsoft.ai.dto.AiChatResult;
+import com.gxwebsoft.ai.dto.AiMessage;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.function.Consumer;
+
+@Service
+public class AiChatService {
+  @Resource
+  private AiOllamaProperties props;
+
+  @Resource
+  private OllamaClient ollamaClient;
+
+  public AiChatResult chat(AiChatRequest request) {
+    OllamaChatRequest req = buildChatRequest(request, false);
+    OllamaChatResponse resp = ollamaClient.chat(req);
+    String content = resp != null && resp.getMessage() != null ? resp.getMessage().getContent() : null;
+    return new AiChatResult(content == null ? "" : content);
+  }
+
+  public void chatStream(AiChatRequest request, Consumer<String> onDelta, Consumer<OllamaChatResponse> onFinal) {
+    Objects.requireNonNull(onDelta, "onDelta");
+    OllamaChatRequest req = buildChatRequest(request, true);
+    ollamaClient.chatStream(req, event -> {
+      String delta = event != null && event.getMessage() != null ? event.getMessage().getContent() : null;
+      if (StrUtil.isNotBlank(delta)) {
+        onDelta.accept(delta);
+      }
+      if (Boolean.TRUE.equals(event.getDone()) && onFinal != null) {
+        onFinal.accept(event);
+      }
+    });
+  }
+
+  private OllamaChatRequest buildChatRequest(AiChatRequest request, boolean stream) {
+    if (request == null) {
+      throw new BusinessException("请求不能为空");
+    }
+
+    List<AiMessage> messages = request.getMessages();
+    if ((messages == null || messages.isEmpty()) && StrUtil.isBlank(request.getPrompt())) {
+      throw new BusinessException("prompt 或 messages 不能为空");
+    }
+    if (messages == null || messages.isEmpty()) {
+      messages = Collections.singletonList(new AiMessage("user", request.getPrompt()));
+    }
+
+    List<OllamaMessage> ollamaMessages = new ArrayList<>();
+    for (AiMessage m : messages) {
+      if (m == null || StrUtil.isBlank(m.getRole()) || m.getContent() == null) {
+        continue;
+      }
+      ollamaMessages.add(new OllamaMessage(m.getRole(), m.getContent()));
+    }
+    if (ollamaMessages.isEmpty()) {
+      throw new BusinessException("messages 为空或无有效内容");
+    }
+
+    Map<String, Object> options = new HashMap<>();
+    if (request.getTemperature() != null) {
+      options.put("temperature", request.getTemperature());
+    }
+    if (request.getTopK() != null) {
+      options.put("top_k", request.getTopK());
+    }
+    if (request.getTopP() != null) {
+      options.put("top_p", request.getTopP());
+    }
+    if (request.getNumPredict() != null) {
+      options.put("num_predict", request.getNumPredict());
+    }
+
+    OllamaChatRequest req = new OllamaChatRequest();
+    req.setModel(StrUtil.blankToDefault(request.getModel(), props.getChatModel()));
+    req.setMessages(ollamaMessages);
+    req.setStream(stream);
+    req.setOptions(options.isEmpty() ? null : options);
+    return req;
+  }
+}
+

src/main/java/com/gxwebsoft/ai/service/AiKbChunkService.java

@@ -0,0 +1,8 @@
+package com.gxwebsoft.ai.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.ai.entity.AiKbChunk;
+
+public interface AiKbChunkService extends IService<AiKbChunk> {
+}
+

src/main/java/com/gxwebsoft/ai/service/AiKbDocumentService.java

@@ -0,0 +1,8 @@
+package com.gxwebsoft.ai.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.ai.entity.AiKbDocument;
+
+public interface AiKbDocumentService extends IService<AiKbDocument> {
+}
+

src/main/java/com/gxwebsoft/ai/service/AiKbRagService.java

@@ -0,0 +1,426 @@
+package com.gxwebsoft.ai.service;
+
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.gxwebsoft.ai.client.OllamaClient;
+import com.gxwebsoft.ai.client.dto.OllamaEmbeddingResponse;
+import com.gxwebsoft.ai.config.AiOllamaProperties;
+import com.gxwebsoft.ai.dto.*;
+import com.gxwebsoft.ai.entity.AiKbChunk;
+import com.gxwebsoft.ai.entity.AiKbDocument;
+import com.gxwebsoft.ai.prompt.AiPrompts;
+import com.gxwebsoft.ai.util.AiTextUtil;
+import com.gxwebsoft.cms.entity.CmsArticle;
+import com.gxwebsoft.cms.entity.CmsArticleContent;
+import com.gxwebsoft.cms.service.CmsArticleContentService;
+import com.gxwebsoft.cms.service.CmsArticleService;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import com.gxwebsoft.common.core.utils.JSONUtil;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.tika.Tika;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.stream.Collectors;
+
+@Service
+public class AiKbRagService {
+  @Resource
+  private AiOllamaProperties props;
+  @Resource
+  private OllamaClient ollamaClient;
+  @Resource
+  private AiKbDocumentService documentService;
+  @Resource
+  private AiKbChunkService chunkService;
+  @Resource
+  private CmsArticleService cmsArticleService;
+  @Resource
+  private CmsArticleContentService cmsArticleContentService;
+  @Resource
+  private AiChatService aiChatService;
+  @Resource
+  private ObjectMapper objectMapper;
+
+  private final Tika tika = new Tika();
+  private volatile ExecutorService embedPool;
+
+  private ExecutorService pool() {
+    ExecutorService p = embedPool;
+    if (p != null) {
+      return p;
+    }
+    synchronized (this) {
+      if (embedPool == null) {
+        embedPool = Executors.newFixedThreadPool(Math.max(1, props.getMaxConcurrency()));
+      }
+      return embedPool;
+    }
+  }
+
+  public AiKbIngestResult ingestUpload(Integer tenantId, MultipartFile file) {
+    if (tenantId == null) {
+      throw new BusinessException("tenantId 不能为空");
+    }
+    if (file == null || file.isEmpty()) {
+      throw new BusinessException("文件不能为空");
+    }
+    String title = StrUtil.blankToDefault(file.getOriginalFilename(), "upload");
+    String text = extractText(file);
+    if (StrUtil.isBlank(text)) {
+      throw new BusinessException("无法解析文件内容，请上传 txt/md/html 等可解析文本");
+    }
+
+    String contentHash = AiTextUtil.sha256(text);
+    AiKbDocument doc = new AiKbDocument();
+    doc.setTitle(title);
+    doc.setSourceType("upload");
+    doc.setSourceRef(title);
+    doc.setContentHash(contentHash);
+    doc.setStatus(0);
+    doc.setTenantId(tenantId);
+    doc.setCreateTime(LocalDateTime.now());
+    doc.setUpdateTime(LocalDateTime.now());
+    documentService.save(doc);
+
+    int chunks = ingestChunks(doc, text);
+
+    AiKbIngestResult r = new AiKbIngestResult();
+    r.setDocumentId(doc.getDocumentId());
+    r.setTitle(doc.getTitle());
+    r.setChunks(chunks);
+    r.setUpdatedDocuments(1);
+    r.setSkippedDocuments(0);
+    return r;
+  }
+
+  /**
+   * 同步 CMS（仅当前 tenant）。
+   */
+  public AiKbIngestResult syncCms(Integer tenantId) {
+    if (tenantId == null) {
+      throw new BusinessException("tenantId 不能为空");
+    }
+    // 仅同步“已发布且未删除”的文章
+    List<CmsArticle> articles = cmsArticleService.list(new LambdaQueryWrapper<CmsArticle>()
+      .eq(CmsArticle::getTenantId, tenantId)
+      .eq(CmsArticle::getDeleted, 0)
+      .eq(CmsArticle::getStatus, 0));
+    if (articles == null || articles.isEmpty()) {
+      AiKbIngestResult r = new AiKbIngestResult();
+      r.setUpdatedDocuments(0);
+      r.setSkippedDocuments(0);
+      r.setChunks(0);
+      return r;
+    }
+
+    Set<Integer> articleIds = articles.stream().map(CmsArticle::getArticleId).collect(Collectors.toSet());
+    List<CmsArticleContent> contents = cmsArticleContentService.list(new LambdaQueryWrapper<CmsArticleContent>()
+      .in(CmsArticleContent::getArticleId, articleIds));
+
+    Map<Integer, CmsArticleContent> contentByArticle = contents.stream()
+      .collect(Collectors.toMap(
+        CmsArticleContent::getArticleId,
+        c -> c,
+        (a, b) -> (a.getCreateTime() != null && b.getCreateTime() != null && a.getCreateTime().isAfter(b.getCreateTime())) ? a : b
+      ));
+
+    int updatedDocs = 0;
+    int skippedDocs = 0;
+    int totalChunks = 0;
+
+    for (CmsArticle a : articles) {
+      CmsArticleContent c = contentByArticle.get(a.getArticleId());
+      String raw = "";
+      if (a.getOverview() != null) {
+        raw += a.getOverview() + "\n";
+      }
+      if (c != null && c.getContent() != null) {
+        raw += c.getContent();
+      }
+      String text = a.getTitle() + "\n" + AiTextUtil.stripHtml(raw);
+      text = AiTextUtil.normalizeWhitespace(text);
+      if (StrUtil.isBlank(text)) {
+        continue;
+      }
+      String hash = AiTextUtil.sha256(text);
+
+      AiKbDocument existing = documentService.getOne(new LambdaQueryWrapper<AiKbDocument>()
+        .eq(AiKbDocument::getTenantId, tenantId)
+        .eq(AiKbDocument::getSourceType, "cms")
+        .eq(AiKbDocument::getSourceId, a.getArticleId())
+        .last("limit 1"));
+
+      if (existing != null && StrUtil.equals(existing.getContentHash(), hash)) {
+        skippedDocs++;
+        continue;
+      }
+
+      AiKbDocument doc;
+      if (existing == null) {
+        doc = new AiKbDocument();
+        doc.setTitle(a.getTitle());
+        doc.setSourceType("cms");
+        doc.setSourceId(a.getArticleId());
+        doc.setSourceRef(a.getCode());
+        doc.setContentHash(hash);
+        doc.setStatus(0);
+        doc.setTenantId(tenantId);
+        doc.setCreateTime(LocalDateTime.now());
+        doc.setUpdateTime(LocalDateTime.now());
+        documentService.save(doc);
+      } else {
+        doc = existing;
+        doc.setTitle(a.getTitle());
+        doc.setSourceRef(a.getCode());
+        doc.setContentHash(hash);
+        doc.setUpdateTime(LocalDateTime.now());
+        documentService.updateById(doc);
+        // 重新入库：先删除旧 chunk
+        chunkService.remove(new LambdaQueryWrapper<AiKbChunk>().eq(AiKbChunk::getDocumentId, doc.getDocumentId()));
+      }
+
+      int chunks = ingestChunks(doc, text);
+      totalChunks += chunks;
+      updatedDocs++;
+    }
+
+    AiKbIngestResult r = new AiKbIngestResult();
+    r.setUpdatedDocuments(updatedDocs);
+    r.setSkippedDocuments(skippedDocs);
+    r.setChunks(totalChunks);
+    return r;
+  }
+
+  public AiKbQueryResult query(Integer tenantId, AiKbQueryRequest request) {
+    if (tenantId == null) {
+      throw new BusinessException("tenantId 不能为空");
+    }
+    if (request == null || StrUtil.isBlank(request.getQuery())) {
+      throw new BusinessException("query 不能为空");
+    }
+    int topK = request.getTopK() != null ? request.getTopK() : props.getRagTopK();
+    topK = Math.max(1, Math.min(20, topK));
+
+    float[] qEmb = embedding(request.getQuery());
+    float qNorm = l2(qEmb);
+    if (qNorm == 0f) {
+      throw new BusinessException("query embedding 为空");
+    }
+
+    // MVP：按 tenant 拉取最新 N 条候选 chunk，再做余弦相似度排序
+    List<AiKbChunk> candidates = chunkService.list(new LambdaQueryWrapper<AiKbChunk>()
+      .eq(AiKbChunk::getTenantId, tenantId)
+      .orderByDesc(AiKbChunk::getId)
+      .last("limit " + props.getRagMaxCandidates()));
+
+    PriorityQueue<AiKbHit> pq = new PriorityQueue<>(Comparator.comparingDouble(h -> h.getScore() == null ? -1d : h.getScore()));
+    for (AiKbChunk c : candidates) {
+      if (StrUtil.isBlank(c.getEmbedding())) {
+        continue;
+      }
+      float[] cEmb = parseEmbedding(c.getEmbedding());
+      if (cEmb == null || cEmb.length == 0) {
+        continue;
+      }
+      Double cNormD = c.getEmbeddingNorm();
+      float cNorm = cNormD == null ? l2(cEmb) : cNormD.floatValue();
+      if (cNorm == 0f) {
+        continue;
+      }
+      double score = dot(qEmb, cEmb) / (qNorm * cNorm);
+      AiKbHit hit = new AiKbHit();
+      hit.setChunkId(c.getChunkId());
+      hit.setDocumentId(c.getDocumentId());
+      hit.setTitle(StrUtil.blankToDefault(c.getTitle(), ""));
+      hit.setScore(score);
+      // 返回给前端时避免过长
+      hit.setContent(clip(c.getContent(), 900));
+
+      if (pq.size() < topK) {
+        pq.add(hit);
+      } else if (hit.getScore() != null && hit.getScore() > pq.peek().getScore()) {
+        pq.poll();
+        pq.add(hit);
+      }
+    }
+
+    List<AiKbHit> hits = new ArrayList<>(pq);
+    hits.sort((a, b) -> Double.compare(b.getScore(), a.getScore()));
+    AiKbQueryResult r = new AiKbQueryResult();
+    r.setHits(hits);
+    return r;
+  }
+
+  public AiKbAskResult ask(Integer tenantId, AiKbAskRequest request) {
+    if (request == null || StrUtil.isBlank(request.getQuestion())) {
+      throw new BusinessException("question 不能为空");
+    }
+    AiKbQueryRequest q = new AiKbQueryRequest();
+    q.setQuery(request.getQuestion());
+    q.setTopK(request.getTopK());
+    AiKbQueryResult retrieval = query(tenantId, q);
+
+    String context = buildContext(retrieval);
+    String userPrompt = "上下文资料：\n" + context + "\n\n用户问题：\n" + request.getQuestion();
+
+    AiChatRequest chatReq = new AiChatRequest();
+    chatReq.setMessages(Arrays.asList(
+      new AiMessage("system", AiPrompts.SYSTEM_SUPPORT),
+      new AiMessage("user", userPrompt)
+    ));
+    AiChatResult chat = aiChatService.chat(chatReq);
+
+    AiKbAskResult r = new AiKbAskResult();
+    r.setAnswer(chat.getContent());
+    r.setRetrieval(retrieval);
+    return r;
+  }
+
+  private int ingestChunks(AiKbDocument doc, String text) {
+    List<String> chunks = AiTextUtil.chunkText(text, props.getRagChunkSize(), props.getRagChunkOverlap());
+    if (chunks.isEmpty()) {
+      return 0;
+    }
+    LocalDateTime now = LocalDateTime.now();
+
+    List<CompletableFuture<AiKbChunk>> futures = new ArrayList<>(chunks.size());
+    for (int i = 0; i < chunks.size(); i++) {
+      final int idx = i;
+      final String chunkText = chunks.get(i);
+      futures.add(CompletableFuture.supplyAsync(() -> {
+        OllamaEmbeddingResponse emb = ollamaClient.embedding(chunkText);
+        if (emb == null || emb.getEmbedding() == null || emb.getEmbedding().isEmpty()) {
+          throw new BusinessException("embedding 生成失败");
+        }
+        float[] v = toFloat(emb.getEmbedding());
+        float norm = l2(v);
+        AiKbChunk c = new AiKbChunk();
+        c.setDocumentId(doc.getDocumentId());
+        c.setChunkId(UUID.randomUUID().toString().replace("-", ""));
+        c.setChunkIndex(idx);
+        c.setTitle(doc.getTitle());
+        c.setContent(chunkText);
+        c.setContentHash(AiTextUtil.sha256(chunkText));
+        c.setEmbedding(JSONUtil.toJSONString(emb.getEmbedding()));
+        c.setEmbeddingNorm((double) norm);
+        c.setTenantId(doc.getTenantId());
+        c.setCreateTime(now);
+        c.setDeleted(0);
+        return c;
+      }, pool()));
+    }
+
+    List<AiKbChunk> entities = futures.stream().map(f -> {
+      try {
+        return f.get(10, TimeUnit.MINUTES);
+      } catch (Exception e) {
+        throw new BusinessException("embedding 批处理失败: " + e.getMessage());
+      }
+    }).collect(Collectors.toList());
+
+    chunkService.saveBatch(entities);
+    return entities.size();
+  }
+
+  private String extractText(MultipartFile file) {
+    try {
+      String contentType = file.getContentType();
+      String filename = file.getOriginalFilename();
+
+      // 优先：对纯文本直接读 UTF-8
+      if ((contentType != null && contentType.startsWith("text/"))
+        || (filename != null && (filename.endsWith(".txt") || filename.endsWith(".md") || filename.endsWith(".html") || filename.endsWith(".htm")))) {
+        return AiTextUtil.normalizeWhitespace(new String(file.getBytes(), StandardCharsets.UTF_8));
+      }
+
+      // 尝试用 tika 解析（注意：当前依赖为 tika-core，解析能力有限）
+      String parsed = tika.parseToString(file.getInputStream());
+      return AiTextUtil.normalizeWhitespace(parsed);
+    } catch (Exception e) {
+      return "";
+    }
+  }
+
+  private float[] embedding(String text) {
+    OllamaEmbeddingResponse emb = ollamaClient.embedding(text);
+    if (emb == null || emb.getEmbedding() == null || emb.getEmbedding().isEmpty()) {
+      throw new BusinessException("embedding 生成失败");
+    }
+    return toFloat(emb.getEmbedding());
+  }
+
+  private float[] parseEmbedding(String json) {
+    try {
+      // embedding 是一维数组，存储为 JSON 文本
+      double[] d = ObjectUtil.isEmpty(json) ? null : objectMapper.readValue(json, double[].class);
+      if (d == null || d.length == 0) {
+        return null;
+      }
+      float[] f = new float[d.length];
+      for (int i = 0; i < d.length; i++) {
+        f[i] = (float) d[i];
+      }
+      return f;
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  private static float[] toFloat(List<Double> v) {
+    float[] out = new float[v.size()];
+    for (int i = 0; i < v.size(); i++) {
+      Double d = v.get(i);
+      out[i] = d == null ? 0f : d.floatValue();
+    }
+    return out;
+  }
+
+  private static float dot(float[] a, float[] b) {
+    int n = Math.min(a.length, b.length);
+    double s = 0d;
+    for (int i = 0; i < n; i++) {
+      s += (double) a[i] * (double) b[i];
+    }
+    return (float) s;
+  }
+
+  private static float l2(float[] a) {
+    double s = 0d;
+    for (float v : a) {
+      s += (double) v * (double) v;
+    }
+    return (float) Math.sqrt(s);
+  }
+
+  private static String clip(String s, int max) {
+    if (s == null) {
+      return "";
+    }
+    if (s.length() <= max) {
+      return s;
+    }
+    return s.substring(0, max) + "...";
+  }
+
+  private static String buildContext(AiKbQueryResult retrieval) {
+    if (retrieval == null || retrieval.getHits() == null || retrieval.getHits().isEmpty()) {
+      return "(无)";
+    }
+    StringBuilder sb = new StringBuilder();
+    for (AiKbHit h : retrieval.getHits()) {
+      sb.append("[source:").append(h.getChunkId()).append("] ");
+      if (StrUtil.isNotBlank(h.getTitle())) {
+        sb.append(h.getTitle()).append("\n");
+      }
+      sb.append(h.getContent()).append("\n\n");
+    }
+    return sb.toString();
+  }
+}

src/main/java/com/gxwebsoft/ai/service/AiShopAnalyticsService.java

@@ -0,0 +1,46 @@
+package com.gxwebsoft.ai.service;
+
+import com.gxwebsoft.ai.dto.AiShopMetricsRow;
+import com.gxwebsoft.ai.mapper.AiShopAnalyticsMapper;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+public class AiShopAnalyticsService {
+  @Resource
+  private AiShopAnalyticsMapper mapper;
+
+  public List<AiShopMetricsRow> queryTenantDaily(Integer tenantId, LocalDate startDate, LocalDate endDateInclusive) {
+    LocalDateTime start = startDate.atStartOfDay();
+    LocalDateTime endExclusive = endDateInclusive.plusDays(1).atStartOfDay();
+    List<AiShopMetricsRow> rows = mapper.queryMetrics(tenantId, start, endExclusive);
+    if (rows == null) {
+      return null;
+    }
+    for (AiShopMetricsRow r : rows) {
+      long orderCnt = r.getOrderCnt() == null ? 0L : r.getOrderCnt();
+      long paidCnt = r.getPaidOrderCnt() == null ? 0L : r.getPaidOrderCnt();
+      BigDecimal gmv = r.getGmv() == null ? BigDecimal.ZERO : r.getGmv();
+
+      if (paidCnt > 0) {
+        r.setAov(gmv.divide(BigDecimal.valueOf(paidCnt), 4, RoundingMode.HALF_UP));
+      } else {
+        r.setAov(BigDecimal.ZERO);
+      }
+      if (orderCnt > 0) {
+        r.setPayRate(BigDecimal.valueOf(paidCnt)
+          .divide(BigDecimal.valueOf(orderCnt), 4, RoundingMode.HALF_UP));
+      } else {
+        r.setPayRate(BigDecimal.ZERO);
+      }
+    }
+    return rows;
+  }
+}
+

src/main/java/com/gxwebsoft/ai/service/impl/AiKbChunkServiceImpl.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.ai.entity.AiKbChunk;
+import com.gxwebsoft.ai.mapper.AiKbChunkMapper;
+import com.gxwebsoft.ai.service.AiKbChunkService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AiKbChunkServiceImpl extends ServiceImpl<AiKbChunkMapper, AiKbChunk> implements AiKbChunkService {
+}
+

src/main/java/com/gxwebsoft/ai/service/impl/AiKbDocumentServiceImpl.java

@@ -0,0 +1,12 @@
+package com.gxwebsoft.ai.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.ai.entity.AiKbDocument;
+import com.gxwebsoft.ai.mapper.AiKbDocumentMapper;
+import com.gxwebsoft.ai.service.AiKbDocumentService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AiKbDocumentServiceImpl extends ServiceImpl<AiKbDocumentMapper, AiKbDocument> implements AiKbDocumentService {
+}
+

src/main/java/com/gxwebsoft/ai/util/AiTextUtil.java

@@ -0,0 +1,100 @@
+package com.gxwebsoft.ai.util;
+
+import cn.hutool.core.util.StrUtil;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.List;
+
+public class AiTextUtil {
+  private AiTextUtil() {
+  }
+
+  public static String sha256(String s) {
+    if (s == null) {
+      return null;
+    }
+    try {
+      MessageDigest md = MessageDigest.getInstance("SHA-256");
+      byte[] dig = md.digest(s.getBytes(StandardCharsets.UTF_8));
+      StringBuilder sb = new StringBuilder(dig.length * 2);
+      for (byte b : dig) {
+        sb.append(String.format("%02x", b));
+      }
+      return sb.toString();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 很轻量的 HTML 转纯文本（不追求完美，只用于知识库入库前清洗）。
+   */
+  public static String stripHtml(String html) {
+    if (StrUtil.isBlank(html)) {
+      return "";
+    }
+    String s = html;
+    s = s.replaceAll("(?is)<script[^>]*>.*?</script>", " ");
+    s = s.replaceAll("(?is)<style[^>]*>.*?</style>", " ");
+    s = s.replaceAll("(?is)<br\\s*/?>", "\n");
+    s = s.replaceAll("(?is)</p\\s*>", "\n");
+    s = s.replaceAll("(?is)<[^>]+>", " ");
+    // 常见 HTML 实体最小处理
+    s = s.replace("&nbsp;", " ");
+    s = s.replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&").replace("&quot;", "\"");
+    return normalizeWhitespace(s);
+  }
+
+  public static String normalizeWhitespace(String s) {
+    if (s == null) {
+      return "";
+    }
+    // 合并空白，保留换行用于 chunking
+    String x = s.replace("\r", "\n");
+    x = x.replaceAll("[\\t\\f\\u000B]+", " ");
+    x = x.replaceAll("[ ]{2,}", " ");
+    x = x.replaceAll("\\n{3,}", "\n\n");
+    return x.trim();
+  }
+
+  /**
+   * 按字符数切分，并做固定 overlap。
+   */
+  public static List<String> chunkText(String text, int chunkSize, int overlap) {
+    String s = normalizeWhitespace(text);
+    List<String> out = new ArrayList<>();
+    if (StrUtil.isBlank(s)) {
+      return out;
+    }
+    if (chunkSize <= 0) {
+      chunkSize = 800;
+    }
+    if (overlap < 0) {
+      overlap = 0;
+    }
+    if (overlap >= chunkSize) {
+      overlap = Math.max(0, chunkSize / 5);
+    }
+
+    int n = s.length();
+    int start = 0;
+    while (start < n) {
+      int end = Math.min(n, start + chunkSize);
+      String chunk = s.substring(start, end).trim();
+      if (!chunk.isEmpty()) {
+        out.add(chunk);
+      }
+      if (end >= n) {
+        break;
+      }
+      start = end - overlap;
+      if (start < 0) {
+        start = 0;
+      }
+    }
+    return out;
+  }
+}
+

src/main/java/com/gxwebsoft/cms/controller/CmsNavigationController.java

@@ -1,13 +1,17 @@
 package com.gxwebsoft.cms.controller;
 
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.gxwebsoft.cms.entity.CmsDesign;
 import com.gxwebsoft.cms.entity.CmsModel;
+import com.gxwebsoft.cms.param.CmsNavigationImportParam;
 import com.gxwebsoft.cms.service.CmsDesignService;
 import com.gxwebsoft.cms.service.CmsModelService;
+import com.gxwebsoft.common.core.annotation.OperationLog;
 import com.gxwebsoft.common.core.utils.CommonUtil;
 import com.gxwebsoft.common.core.utils.RedisUtil;
 import com.gxwebsoft.common.core.web.BaseController;
@@ -21,11 +25,18 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.common.system.service.UserService;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import io.swagger.v3.oas.annotations.Operation;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 网站导航记录表控制器
@@ -79,6 +90,7 @@ public class CmsNavigationController extends BaseController {
     return success(cmsNavigationService.getByIdRelByCodeRel(code));
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
   @Operation(summary = "添加网站导航记录表")
   @PostMapping()
   public ApiResult<?> save(@RequestBody CmsNavigation cmsNavigation) {
@@ -99,6 +111,7 @@ public class CmsNavigationController extends BaseController {
     return fail("添加失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:update')")
   @Operation(summary = "修改网站导航记录表")
   @PutMapping()
   public ApiResult<?> update(@RequestBody CmsNavigation cmsNavigation) {
@@ -111,6 +124,7 @@ public class CmsNavigationController extends BaseController {
     return fail("修改失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:remove')")
   @Operation(summary = "删除网站导航记录表")
   @DeleteMapping("/{id}")
   public ApiResult<?> remove(@PathVariable("id") Integer id) {
@@ -121,6 +135,7 @@ public class CmsNavigationController extends BaseController {
     return fail("删除失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
   @Operation(summary = "批量添加网站导航记录表")
   @PostMapping("/batch")
   public ApiResult<?> saveBatch(@RequestBody List<CmsNavigation> list) {
@@ -131,6 +146,7 @@ public class CmsNavigationController extends BaseController {
     return fail("添加失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:update')")
   @Operation(summary = "批量修改网站导航记录表")
   @PutMapping("/batch")
   public ApiResult<?> removeBatch(@RequestBody BatchParam<CmsNavigation> batchParam) {
@@ -141,6 +157,7 @@ public class CmsNavigationController extends BaseController {
     return fail("修改失败");
   }
 
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:remove')")
   @Operation(summary = "批量删除网站导航记录表")
   @DeleteMapping("/batch")
   public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
@@ -151,6 +168,173 @@ public class CmsNavigationController extends BaseController {
     return fail("删除失败");
   }
 
+  /**
+   * excel批量导入网站导航
+   */
+  @PreAuthorize("hasAuthority('cms:cmsNavigation:save')")
+  @OperationLog
+  @Operation(summary = "批量导入网站导航")
+  @Transactional(rollbackFor = {Exception.class})
+  @PostMapping("/import")
+  public ApiResult<?> importBatch(@RequestParam("file") MultipartFile file) {
+    ImportParams importParams = new ImportParams();
+    try {
+      User loginUser = getLoginUser();
+      if (loginUser == null) {
+        return fail("请先登录");
+      }
+      Integer currentUserId = loginUser.getUserId();
+      Integer currentTenantId = loginUser.getTenantId();
+
+      // 1) 清理当前租户的历史数据：先清理 deleted=1，再把 deleted=0 标记为 deleted=1
+      List<CmsNavigation> undeleted = cmsNavigationService.list(new LambdaQueryWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getTenantId, currentTenantId)
+          .eq(CmsNavigation::getDeleted, 0));
+      cmsNavigationService.remove(new LambdaQueryWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getTenantId, currentTenantId)
+          .eq(CmsNavigation::getDeleted, 1));
+      if (!CollectionUtils.isEmpty(undeleted)) {
+        LambdaUpdateWrapper<CmsNavigation> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.eq(CmsNavigation::getTenantId, currentTenantId);
+        updateWrapper.eq(CmsNavigation::getDeleted, 0);
+        updateWrapper.set(CmsNavigation::getDeleted, 1);
+        cmsNavigationService.update(updateWrapper);
+      }
+
+      // 2) 读取Excel
+      List<CmsNavigationImportParam> list = ExcelImportUtil.importExcel(
+          file.getInputStream(), CmsNavigationImportParam.class, importParams);
+      if (CollectionUtils.isEmpty(list)) {
+        return fail("未读取到数据，请确认模板表头与示例格式一致");
+      }
+
+      // 3) 先全部落库（先按根节点保存），再尝试按“导入文件的 parentId -> 导入文件的 navigationId”映射回填层级。
+      // 这样即使 parentId 无法匹配（导入文件缺少导航ID/父节点缺失），也能把数据全部导入，无法还原层级的作为根节点处理。
+      Map<Integer, Integer> newIdByOldId = new HashMap<>();
+      List<Integer> newIds = new ArrayList<>(list.size());
+      List<Integer> oldIds = new ArrayList<>(list.size());
+      List<Integer> oldParentIds = new ArrayList<>(list.size());
+
+      for (CmsNavigationImportParam param : list) {
+        CmsNavigation nav = convertToNavigation(param, currentUserId, currentTenantId);
+        nav.setParentId(0);
+        cmsNavigationService.save(nav);
+        cmsNavigationService.saveAsync(nav);
+
+        Integer oldId = param.getNavigationId();
+        if (oldId != null) {
+          newIdByOldId.put(oldId, nav.getNavigationId());
+        }
+        newIds.add(nav.getNavigationId());
+        oldIds.add(oldId);
+        oldParentIds.add(param.getParentId() != null ? param.getParentId() : 0);
+      }
+
+      int orphanCount = 0;
+      int restoredCount = 0;
+      for (int i = 0; i < newIds.size(); i++) {
+        Integer oldParentId = oldParentIds.get(i);
+        if (oldParentId == null || oldParentId == 0) {
+          continue;
+        }
+        Integer oldId = oldIds.get(i);
+        Integer newId = newIds.get(i);
+        Integer newParentId = newIdByOldId.get(oldParentId);
+        // 无法匹配父节点（或出现自引用）就当作孤儿节点，保持根节点
+        if (newParentId == null || (oldId != null && oldParentId.equals(oldId)) || (newId != null && newParentId.equals(newId))) {
+          orphanCount++;
+          continue;
+        }
+        cmsNavigationService.update(new LambdaUpdateWrapper<CmsNavigation>()
+          .eq(CmsNavigation::getNavigationId, newId)
+          .set(CmsNavigation::getParentId, newParentId));
+        restoredCount++;
+      }
+
+      redisUtil.delete(SITE_INFO_KEY_PREFIX.concat(currentTenantId.toString()));
+      return success("成功导入" + list.size() + "条，恢复层级" + restoredCount + "条，无法还原层级的孤儿节点" + orphanCount + "条（已作为根节点导入）");
+    } catch (Exception e) {
+      e.printStackTrace();
+      return fail("导入失败: " + e.getMessage());
+    }
+  }
+
+  /**
+   * 递归创建子级导航
+   */
+  private void createChildNavigations(Map<Integer, List<CmsNavigationImportParam>> navGroups,
+                                      Map<Integer, CmsNavigation> tempIdMapping,
+                                      Integer originalParentId,
+                                      Integer defaultUserId,
+                                      Integer defaultTenantId) {
+    if (originalParentId == null || originalParentId == 0) {
+      return;
+    }
+    List<CmsNavigationImportParam> children = navGroups.get(originalParentId);
+    if (CollectionUtils.isEmpty(children)) {
+      return;
+    }
+    CmsNavigation parent = tempIdMapping.get(originalParentId);
+    if (parent == null || parent.getNavigationId() == null) {
+      return;
+    }
+    Integer newParentId = parent.getNavigationId();
+    for (CmsNavigationImportParam param : children) {
+      CmsNavigation nav = convertToNavigation(param, defaultUserId, defaultTenantId);
+      nav.setParentId(newParentId);
+      cmsNavigationService.save(nav);
+      cmsNavigationService.saveAsync(nav);
+      if (param.getNavigationId() != null) {
+        tempIdMapping.put(param.getNavigationId(), nav);
+      }
+      createChildNavigations(navGroups, tempIdMapping, param.getNavigationId(), defaultUserId, defaultTenantId);
+    }
+  }
+
+  private CmsNavigation convertToNavigation(CmsNavigationImportParam param, Integer defaultUserId, Integer defaultTenantId) {
+    CmsNavigation nav = new CmsNavigation();
+    nav.setType(param.getType());
+    nav.setTitle(StrUtil.trimStart(param.getTitle()));
+    nav.setParentId(param.getParentId() != null ? param.getParentId() : 0);
+    // saveAsync 依赖 model 生成路由/页面；缺省按 page 处理
+    nav.setModel(StrUtil.isBlank(param.getModel()) ? "page" : param.getModel());
+    nav.setCode(param.getCode());
+    nav.setPath(param.getPath());
+    nav.setComponent(param.getComponent());
+    nav.setTarget(param.getTarget());
+    nav.setIcon(param.getIcon());
+    nav.setColor(param.getColor());
+    nav.setHide(param.getHide());
+    nav.setPermission(param.getPermission());
+    nav.setPassword(param.getPassword());
+    nav.setPosition(param.getPosition());
+    nav.setTop(param.getTop());
+    nav.setBottom(param.getBottom());
+    nav.setActive(param.getActive());
+    nav.setMeta(param.getMeta());
+    nav.setStyle(param.getStyle());
+    nav.setModelName(param.getModelName());
+    nav.setPageId(param.getPageId());
+    nav.setItemId(param.getItemId());
+    nav.setIsMpWeixin(param.getIsMpWeixin());
+    nav.setGutter(param.getGutter());
+    nav.setSpan(param.getSpan());
+    nav.setReadNum(param.getReadNum());
+    nav.setMerchantId(param.getMerchantId());
+    nav.setLang(param.getLang());
+    nav.setHome(param.getHome());
+    nav.setRecommend(param.getRecommend());
+    nav.setSortNumber(param.getSortNumber() != null ? param.getSortNumber() : 0);
+    nav.setComments(param.getComments());
+    nav.setStatus(param.getStatus() != null ? param.getStatus() : 0);
+
+    // 导入时强制落到当前登录用户/租户，避免“导出其他租户 -> 导入”写回原租户导致当前租户数据不全。
+    nav.setUserId(defaultUserId);
+    nav.setTenantId(defaultTenantId);
+    nav.setDeleted(0);
+    return nav;
+  }
+
   @Operation(summary = "获取树形结构的网站导航数据")
   @GetMapping("/tree")
   public ApiResult<List<CmsNavigation>> tree(CmsNavigationParam param) {

src/main/java/com/gxwebsoft/cms/controller/CmsOrderController.java

@@ -0,0 +1,122 @@
+package com.gxwebsoft.cms.controller;
+
+import com.gxwebsoft.common.core.web.BaseController;
+import com.gxwebsoft.cms.service.CmsOrderService;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import com.gxwebsoft.common.core.web.ApiResult;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.BatchParam;
+import com.gxwebsoft.common.core.annotation.OperationLog;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * 网站订单控制器
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:25
+ */
+@Tag(name = "网站订单管理")
+@RestController
+@RequestMapping("/api/cms/cms-order")
+public class CmsOrderController extends BaseController {
+    @Resource
+    private CmsOrderService cmsOrderService;
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "分页查询网站订单")
+    @GetMapping("/page")
+    public ApiResult<PageResult<CmsOrder>> page(CmsOrderParam param) {
+        // 使用关联查询
+        return success(cmsOrderService.pageRel(param));
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "查询全部网站订单")
+    @GetMapping()
+    public ApiResult<List<CmsOrder>> list(CmsOrderParam param) {
+        // 使用关联查询
+        return success(cmsOrderService.listRel(param));
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:list')")
+    @Operation(summary = "根据id查询网站订单")
+    @GetMapping("/{id}")
+    public ApiResult<CmsOrder> get(@PathVariable("id") Integer id) {
+        // 使用关联查询
+        return success(cmsOrderService.getByIdRel(id));
+    }
+
+    @Operation(summary = "添加网站订单")
+    @PostMapping()
+    public ApiResult<?> save(@RequestBody CmsOrder cmsOrder) {
+
+        if (cmsOrderService.save(cmsOrder)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:update')")
+    @OperationLog
+    @Operation(summary = "修改网站订单")
+    @PutMapping()
+    public ApiResult<?> update(@RequestBody CmsOrder cmsOrder) {
+        if (cmsOrderService.updateById(cmsOrder)) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:remove')")
+    @OperationLog
+    @Operation(summary = "删除网站订单")
+    @DeleteMapping("/{id}")
+    public ApiResult<?> remove(@PathVariable("id") Integer id) {
+        if (cmsOrderService.removeById(id)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:save')")
+    @OperationLog
+    @Operation(summary = "批量添加网站订单")
+    @PostMapping("/batch")
+    public ApiResult<?> saveBatch(@RequestBody List<CmsOrder> list) {
+        if (cmsOrderService.saveBatch(list)) {
+            return success("添加成功");
+        }
+        return fail("添加失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:update')")
+    @OperationLog
+    @Operation(summary = "批量修改网站订单")
+    @PutMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody BatchParam<CmsOrder> batchParam) {
+        if (batchParam.update(cmsOrderService, "id")) {
+            return success("修改成功");
+        }
+        return fail("修改失败");
+    }
+
+    @PreAuthorize("hasAuthority('cms:cmsOrder:remove')")
+    @OperationLog
+    @Operation(summary = "批量删除网站订单")
+    @DeleteMapping("/batch")
+    public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
+        if (cmsOrderService.removeByIds(ids)) {
+            return success("删除成功");
+        }
+        return fail("删除失败");
+    }
+
+}

src/main/java/com/gxwebsoft/cms/entity/CmsNavigation.java

@@ -43,6 +43,10 @@ public class CmsNavigation implements Serializable {
     @Schema(description = "模型")
     private String model;
 
+    @Schema(description = "模型名称")
+    @TableField(exist = false)
+    private String modelName;
+
     @Schema(description = "标识")
     private String code;
 
@@ -114,9 +118,6 @@ public class CmsNavigation implements Serializable {
     @TableField(exist = false)
     private Integer parentPosition;
 
-    @Schema(description = "模型名称")
-    private String modelName;
-
     @Schema(description = "绑定的页面（已废弃）")
     private Integer pageId;
 

src/main/java/com/gxwebsoft/cms/entity/CmsOrder.java

@@ -0,0 +1,266 @@
+package com.gxwebsoft.cms.entity;
+
+import java.math.BigDecimal;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import java.io.Serializable;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+/**
+ * 网站订单
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Schema(name = "CmsOrder对象", description = "网站订单")
+public class CmsOrder implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "id")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @Schema(description = "订单类型，0售前咨询 1售后服务 2意见反馈")
+    private Integer type;
+
+    @Schema(description = "订单标题")
+    private String title;
+
+    @Schema(description = "公司/团队名称")
+    private String company;
+
+    @Schema(description = "订单内容")
+    private String content;
+
+    @Schema(description = "订单编号")
+    private String orderNo;
+
+    @Schema(description = "快递/自提")
+    private Integer deliveryType;
+
+    @Schema(description = "下单渠道，0网站 1微信小程序 2其他")
+    private Integer channel;
+
+    @Schema(description = "微信支付交易号号")
+    private String transactionId;
+
+    @Schema(description = "微信退款订单号")
+    private String refundOrder;
+
+    @Schema(description = "商户ID")
+    private Integer merchantId;
+
+    @Schema(description = "商户名称")
+    private String merchantName;
+
+    @Schema(description = "商户编号")
+    private String merchantCode;
+
+    @Schema(description = "使用的优惠券id")
+    private Integer couponId;
+
+    @Schema(description = "使用的会员卡id")
+    private String cardId;
+
+    @Schema(description = "关联管理员id")
+    private Integer adminId;
+
+    @Schema(description = "核销管理员id")
+    private Integer confirmId;
+
+    @Schema(description = "IC卡号")
+    private String icCard;
+
+    @Schema(description = "真实姓名")
+    private String realName;
+
+    @Schema(description = "关联收货地址")
+    private Integer addressId;
+
+    @Schema(description = "收货地址")
+    private String address;
+
+    private String addressLat;
+
+    private String addressLng;
+
+    @Schema(description = "自提店铺id")
+    private Integer selfTakeMerchantId;
+
+    @Schema(description = "自提店铺")
+    private String selfTakeMerchantName;
+
+    @Schema(description = "配送开始时间")
+    private String sendStartTime;
+
+    @Schema(description = "配送结束时间")
+    private String sendEndTime;
+
+    @Schema(description = "发货店铺id")
+    private Integer expressMerchantId;
+
+    @Schema(description = "发货店铺")
+    private String expressMerchantName;
+
+    @Schema(description = "订单总额")
+    private BigDecimal totalPrice;
+
+    @Schema(description = "减少的金额，使用VIP会员折扣、优惠券抵扣、优惠券折扣后减去的价格")
+    private BigDecimal reducePrice;
+
+    @Schema(description = "实际付款")
+    private BigDecimal payPrice;
+
+    @Schema(description = "用于统计")
+    private BigDecimal price;
+
+    @Schema(description = "价钱，用于积分赠送")
+    private BigDecimal money;
+
+    @Schema(description = "取消时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime cancelTime;
+
+    @Schema(description = "取消原因")
+    private String cancelReason;
+
+    @Schema(description = "退款金额")
+    private BigDecimal refundMoney;
+
+    @Schema(description = "教练价格")
+    private BigDecimal coachPrice;
+
+    @Schema(description = "购买数量")
+    private Integer totalNum;
+
+    @Schema(description = "教练id")
+    private Integer coachId;
+
+    @Schema(description = "商品ID")
+    private Integer formId;
+
+    @Schema(description = "支付的用户id")
+    private Integer payUserId;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    private Integer payType;
+
+    @Schema(description = "微信支付子类型：JSAPI小程序支付，NATIVE扫码支付")
+    private String wechatPayType;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    private Integer friendPayType;
+
+    @Schema(description = "0未付款，1已付款")
+    private Integer payStatus;
+
+    @Schema(description = "0未使用，1已完成，2已取消，3取消中，4退款申请中，5退款被拒绝，6退款成功，7客户端申请退款")
+    private Integer orderStatus;
+
+    @Schema(description = "发货状态(10未发货 20已发货 30部分发货)")
+    private Integer deliveryStatus;
+
+    @Schema(description = "无需发货备注")
+    private String deliveryNote;
+
+    @Schema(description = "发货时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime deliveryTime;
+
+    @Schema(description = "评价状态(0未评价 1已评价)")
+    private Integer evaluateStatus;
+
+    @Schema(description = "评价时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime evaluateTime;
+
+    @Schema(description = "优惠类型：0无、1抵扣优惠券、2折扣优惠券、3、VIP月卡、4VIP年卡，5VIP次卡、6VIP会员卡、7IC月卡、8IC年卡、9IC次卡、10IC会员卡、11免费订单、12VIP充值卡、13IC充值卡、14VIP季卡、15IC季卡")
+    private Integer couponType;
+
+    @Schema(description = "优惠说明")
+    private String couponDesc;
+
+    @Schema(description = "二维码地址，保存订单号，支付成功后才生成")
+    private String qrcode;
+
+    @Schema(description = "vip月卡年卡、ic月卡年卡回退次数")
+    private Integer returnNum;
+
+    @Schema(description = "vip充值回退金额")
+    private BigDecimal returnMoney;
+
+    @Schema(description = "预约详情开始时间数组")
+    private String startTime;
+
+    @Schema(description = "是否已开具发票：0未开发票，1已开发票，2不能开具发票")
+    private Integer isInvoice;
+
+    @Schema(description = "发票流水号")
+    private String invoiceNo;
+
+    @Schema(description = "商家留言")
+    private String merchantRemarks;
+
+    @Schema(description = "支付时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime payTime;
+
+    @Schema(description = "退款时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime refundTime;
+
+    @Schema(description = "申请退款时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime refundApplyTime;
+
+    @Schema(description = "过期时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime expirationTime;
+
+    @Schema(description = "自提码")
+    private String selfTakeCode;
+
+    @Schema(description = "是否已收到赠品")
+    private Boolean hasTakeGift;
+
+    @Schema(description = "对账情况：0=未对账；1=已对账；3=已对账，金额对不上；4=未查询到该订单")
+    private Integer checkBill;
+
+    @Schema(description = "订单是否已结算(0未结算 1已结算)")
+    private Integer isSettled;
+
+    @Schema(description = "系统版本号 0当前版本 value=其他版本")
+    private Integer version;
+
+    @Schema(description = "用户id")
+    private Integer userId;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "排序号")
+    private Integer sortNumber;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @TableLogic
+    private Integer deleted;
+
+    @Schema(description = "租户id")
+    private Integer tenantId;
+
+    @Schema(description = "修改时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime updateTime;
+
+    @Schema(description = "创建时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+
+}

src/main/java/com/gxwebsoft/cms/mapper/CmsOrderMapper.java

@@ -0,0 +1,37 @@
+package com.gxwebsoft.cms.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * 网站订单Mapper
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+public interface CmsOrderMapper extends BaseMapper<CmsOrder> {
+
+    /**
+     * 分页查询
+     *
+     * @param page  分页对象
+     * @param param 查询参数
+     * @return List<CmsOrder>
+     */
+    List<CmsOrder> selectPageRel(@Param("page") IPage<CmsOrder> page,
+                             @Param("param") CmsOrderParam param);
+
+    /**
+     * 查询全部
+     *
+     * @param param 查询参数
+     * @return List<User>
+     */
+    List<CmsOrder> selectListRel(@Param("param") CmsOrderParam param);
+
+}

src/main/java/com/gxwebsoft/cms/mapper/xml/CmsNavigationMapper.xml

@@ -4,9 +4,11 @@
 
     <!-- 关联查询sql -->
     <sql id="selectSql">
-        SELECT a.*, b.title as parentName, b.position as parentPosition
+        SELECT a.*, b.title as parentName, b.position as parentPosition, c.name as modelName
         FROM cms_navigation a
-        LEFT JOIN cms_navigation b ON a.parent_id = b.navigation_id
+        LEFT JOIN cms_navigation b ON a.parent_id = b.navigation_id AND b.deleted = 0 AND b.tenant_id = a.tenant_id
+        <!-- c.model = 0 会触发 MySQL 字符串转数字比较，导致几乎所有模型都匹配，从而把导航行成倍放大 -->
+        LEFT JOIN cms_model c ON a.model = c.model AND c.deleted = 0 AND c.tenant_id = a.tenant_id
         <where>
             <if test="param.navigationId != null">
                 AND a.navigation_id = #{param.navigationId}

src/main/java/com/gxwebsoft/cms/mapper/xml/CmsOrderMapper.xml

@@ -0,0 +1,258 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.gxwebsoft.cms.mapper.CmsOrderMapper">
+
+    <!-- 关联查询sql -->
+    <sql id="selectSql">
+        SELECT a.*
+        FROM cms_order a
+        <where>
+            <if test="param.id != null">
+                AND a.id = #{param.id}
+            </if>
+            <if test="param.type != null">
+                AND a.type = #{param.type}
+            </if>
+            <if test="param.title != null">
+                AND a.title LIKE CONCAT('%', #{param.title}, '%')
+            </if>
+            <if test="param.company != null">
+                AND a.company LIKE CONCAT('%', #{param.company}, '%')
+            </if>
+            <if test="param.content != null">
+                AND a.content LIKE CONCAT('%', #{param.content}, '%')
+            </if>
+            <if test="param.orderNo != null">
+                AND a.order_no LIKE CONCAT('%', #{param.orderNo}, '%')
+            </if>
+            <if test="param.deliveryType != null">
+                AND a.delivery_type = #{param.deliveryType}
+            </if>
+            <if test="param.channel != null">
+                AND a.channel = #{param.channel}
+            </if>
+            <if test="param.transactionId != null">
+                AND a.transaction_id LIKE CONCAT('%', #{param.transactionId}, '%')
+            </if>
+            <if test="param.refundOrder != null">
+                AND a.refund_order LIKE CONCAT('%', #{param.refundOrder}, '%')
+            </if>
+            <if test="param.merchantId != null">
+                AND a.merchant_id = #{param.merchantId}
+            </if>
+            <if test="param.merchantName != null">
+                AND a.merchant_name LIKE CONCAT('%', #{param.merchantName}, '%')
+            </if>
+            <if test="param.merchantCode != null">
+                AND a.merchant_code LIKE CONCAT('%', #{param.merchantCode}, '%')
+            </if>
+            <if test="param.couponId != null">
+                AND a.coupon_id = #{param.couponId}
+            </if>
+            <if test="param.cardId != null">
+                AND a.card_id LIKE CONCAT('%', #{param.cardId}, '%')
+            </if>
+            <if test="param.adminId != null">
+                AND a.admin_id = #{param.adminId}
+            </if>
+            <if test="param.confirmId != null">
+                AND a.confirm_id = #{param.confirmId}
+            </if>
+            <if test="param.icCard != null">
+                AND a.ic_card LIKE CONCAT('%', #{param.icCard}, '%')
+            </if>
+            <if test="param.realName != null">
+                AND a.real_name LIKE CONCAT('%', #{param.realName}, '%')
+            </if>
+            <if test="param.addressId != null">
+                AND a.address_id = #{param.addressId}
+            </if>
+            <if test="param.address != null">
+                AND a.address LIKE CONCAT('%', #{param.address}, '%')
+            </if>
+            <if test="param.addressLat != null">
+                AND a.address_lat LIKE CONCAT('%', #{param.addressLat}, '%')
+            </if>
+            <if test="param.addressLng != null">
+                AND a.address_lng LIKE CONCAT('%', #{param.addressLng}, '%')
+            </if>
+            <if test="param.selfTakeMerchantId != null">
+                AND a.self_take_merchant_id = #{param.selfTakeMerchantId}
+            </if>
+            <if test="param.selfTakeMerchantName != null">
+                AND a.self_take_merchant_name LIKE CONCAT('%', #{param.selfTakeMerchantName}, '%')
+            </if>
+            <if test="param.sendStartTime != null">
+                AND a.send_start_time LIKE CONCAT('%', #{param.sendStartTime}, '%')
+            </if>
+            <if test="param.sendEndTime != null">
+                AND a.send_end_time LIKE CONCAT('%', #{param.sendEndTime}, '%')
+            </if>
+            <if test="param.expressMerchantId != null">
+                AND a.express_merchant_id = #{param.expressMerchantId}
+            </if>
+            <if test="param.expressMerchantName != null">
+                AND a.express_merchant_name LIKE CONCAT('%', #{param.expressMerchantName}, '%')
+            </if>
+            <if test="param.totalPrice != null">
+                AND a.total_price = #{param.totalPrice}
+            </if>
+            <if test="param.reducePrice != null">
+                AND a.reduce_price = #{param.reducePrice}
+            </if>
+            <if test="param.payPrice != null">
+                AND a.pay_price = #{param.payPrice}
+            </if>
+            <if test="param.price != null">
+                AND a.price = #{param.price}
+            </if>
+            <if test="param.money != null">
+                AND a.money = #{param.money}
+            </if>
+            <if test="param.cancelTime != null">
+                AND a.cancel_time LIKE CONCAT('%', #{param.cancelTime}, '%')
+            </if>
+            <if test="param.cancelReason != null">
+                AND a.cancel_reason LIKE CONCAT('%', #{param.cancelReason}, '%')
+            </if>
+            <if test="param.refundMoney != null">
+                AND a.refund_money = #{param.refundMoney}
+            </if>
+            <if test="param.coachPrice != null">
+                AND a.coach_price = #{param.coachPrice}
+            </if>
+            <if test="param.totalNum != null">
+                AND a.total_num = #{param.totalNum}
+            </if>
+            <if test="param.coachId != null">
+                AND a.coach_id = #{param.coachId}
+            </if>
+            <if test="param.formId != null">
+                AND a.form_id = #{param.formId}
+            </if>
+            <if test="param.payUserId != null">
+                AND a.pay_user_id = #{param.payUserId}
+            </if>
+            <if test="param.payType != null">
+                AND a.pay_type = #{param.payType}
+            </if>
+            <if test="param.wechatPayType != null">
+                AND a.wechat_pay_type LIKE CONCAT('%', #{param.wechatPayType}, '%')
+            </if>
+            <if test="param.friendPayType != null">
+                AND a.friend_pay_type = #{param.friendPayType}
+            </if>
+            <if test="param.payStatus != null">
+                AND a.pay_status = #{param.payStatus}
+            </if>
+            <if test="param.orderStatus != null">
+                AND a.order_status = #{param.orderStatus}
+            </if>
+            <if test="param.deliveryStatus != null">
+                AND a.delivery_status = #{param.deliveryStatus}
+            </if>
+            <if test="param.deliveryNote != null">
+                AND a.delivery_note LIKE CONCAT('%', #{param.deliveryNote}, '%')
+            </if>
+            <if test="param.deliveryTime != null">
+                AND a.delivery_time LIKE CONCAT('%', #{param.deliveryTime}, '%')
+            </if>
+            <if test="param.evaluateStatus != null">
+                AND a.evaluate_status = #{param.evaluateStatus}
+            </if>
+            <if test="param.evaluateTime != null">
+                AND a.evaluate_time LIKE CONCAT('%', #{param.evaluateTime}, '%')
+            </if>
+            <if test="param.couponType != null">
+                AND a.coupon_type = #{param.couponType}
+            </if>
+            <if test="param.couponDesc != null">
+                AND a.coupon_desc LIKE CONCAT('%', #{param.couponDesc}, '%')
+            </if>
+            <if test="param.qrcode != null">
+                AND a.qrcode LIKE CONCAT('%', #{param.qrcode}, '%')
+            </if>
+            <if test="param.returnNum != null">
+                AND a.return_num = #{param.returnNum}
+            </if>
+            <if test="param.returnMoney != null">
+                AND a.return_money = #{param.returnMoney}
+            </if>
+            <if test="param.startTime != null">
+                AND a.start_time LIKE CONCAT('%', #{param.startTime}, '%')
+            </if>
+            <if test="param.isInvoice != null">
+                AND a.is_invoice = #{param.isInvoice}
+            </if>
+            <if test="param.invoiceNo != null">
+                AND a.invoice_no LIKE CONCAT('%', #{param.invoiceNo}, '%')
+            </if>
+            <if test="param.merchantRemarks != null">
+                AND a.merchant_remarks LIKE CONCAT('%', #{param.merchantRemarks}, '%')
+            </if>
+            <if test="param.payTime != null">
+                AND a.pay_time LIKE CONCAT('%', #{param.payTime}, '%')
+            </if>
+            <if test="param.refundTime != null">
+                AND a.refund_time LIKE CONCAT('%', #{param.refundTime}, '%')
+            </if>
+            <if test="param.refundApplyTime != null">
+                AND a.refund_apply_time LIKE CONCAT('%', #{param.refundApplyTime}, '%')
+            </if>
+            <if test="param.expirationTime != null">
+                AND a.expiration_time LIKE CONCAT('%', #{param.expirationTime}, '%')
+            </if>
+            <if test="param.selfTakeCode != null">
+                AND a.self_take_code LIKE CONCAT('%', #{param.selfTakeCode}, '%')
+            </if>
+            <if test="param.hasTakeGift != null">
+                AND a.has_take_gift = #{param.hasTakeGift}
+            </if>
+            <if test="param.checkBill != null">
+                AND a.check_bill = #{param.checkBill}
+            </if>
+            <if test="param.isSettled != null">
+                AND a.is_settled = #{param.isSettled}
+            </if>
+            <if test="param.version != null">
+                AND a.version = #{param.version}
+            </if>
+            <if test="param.userId != null">
+                AND a.user_id = #{param.userId}
+            </if>
+            <if test="param.comments != null">
+                AND a.comments LIKE CONCAT('%', #{param.comments}, '%')
+            </if>
+            <if test="param.sortNumber != null">
+                AND a.sort_number = #{param.sortNumber}
+            </if>
+            <if test="param.deleted != null">
+                AND a.deleted = #{param.deleted}
+            </if>
+            <if test="param.deleted == null">
+                AND a.deleted = 0
+            </if>
+            <if test="param.createTimeStart != null">
+                AND a.create_time &gt;= #{param.createTimeStart}
+            </if>
+            <if test="param.createTimeEnd != null">
+                AND a.create_time &lt;= #{param.createTimeEnd}
+            </if>
+            <if test="param.keywords != null">
+                AND (a.comments LIKE CONCAT('%', #{param.keywords}, '%')
+                )
+              </if>
+        </where>
+    </sql>
+
+    <!-- 分页查询 -->
+    <select id="selectPageRel" resultType="com.gxwebsoft.cms.entity.CmsOrder">
+        <include refid="selectSql"></include>
+    </select>
+
+    <!-- 查询全部 -->
+    <select id="selectListRel" resultType="com.gxwebsoft.cms.entity.CmsOrder">
+        <include refid="selectSql"></include>
+    </select>
+
+</mapper>

src/main/java/com/gxwebsoft/cms/param/CmsNavigationImportParam.java

@@ -0,0 +1,123 @@
+package com.gxwebsoft.cms.param;
+
+import cn.afterturn.easypoi.excel.annotation.Excel;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 网站导航导入参数（Excel 批量导入）
+ */
+@Data
+public class CmsNavigationImportParam implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Excel(name = "导航ID")
+    private Integer navigationId;
+
+    @Excel(name = "类型")
+    private Integer type;
+
+    @Excel(name = "菜单名称")
+    private String title;
+
+    @Excel(name = "上级id")
+    private Integer parentId;
+
+    @Excel(name = "模型")
+    private String model;
+
+    @Excel(name = "标识")
+    private String code;
+
+    @Excel(name = "菜单路由地址")
+    private String path;
+
+    @Excel(name = "菜单组件地址")
+    private String component;
+
+    @Excel(name = "打开位置")
+    private String target;
+
+    @Excel(name = "菜单图标")
+    private String icon;
+
+    @Excel(name = "图标颜色")
+    private String color;
+
+    @Excel(name = "是否隐藏")
+    private Integer hide;
+
+    @Excel(name = "可见类型")
+    private Integer permission;
+
+    @Excel(name = "访问密码")
+    private String password;
+
+    @Excel(name = "位置")
+    private Integer position;
+
+    @Excel(name = "仅在顶部显示")
+    private Integer top;
+
+    @Excel(name = "仅在底部显示")
+    private Integer bottom;
+
+    @Excel(name = "选中path")
+    private String active;
+
+    @Excel(name = "其它路由元信息")
+    private String meta;
+
+    @Excel(name = "css样式")
+    private String style;
+
+    @Excel(name = "模型名称")
+    private String modelName;
+
+    @Excel(name = "页面ID")
+    private Integer pageId;
+
+    @Excel(name = "详情页ID")
+    private Integer itemId;
+
+    @Excel(name = "是否微信小程序菜单")
+    private Boolean isMpWeixin;
+
+    @Excel(name = "菜单间距")
+    private Integer gutter;
+
+    @Excel(name = "菜单宽度")
+    private Integer span;
+
+    @Excel(name = "阅读量")
+    private Integer readNum;
+
+    @Excel(name = "商户ID")
+    private Long merchantId;
+
+    @Excel(name = "国际化语言")
+    private String lang;
+
+    @Excel(name = "设为首页")
+    private Integer home;
+
+    @Excel(name = "是否推荐")
+    private Boolean recommend;
+
+    @Excel(name = "排序")
+    private Integer sortNumber;
+
+    @Excel(name = "备注")
+    private String comments;
+
+    @Excel(name = "状态")
+    private Integer status;
+
+    @Excel(name = "用户ID")
+    private Integer userId;
+
+    @Excel(name = "租户ID")
+    private Integer tenantId;
+}
+

src/main/java/com/gxwebsoft/cms/param/CmsOrderParam.java

@@ -0,0 +1,284 @@
+package com.gxwebsoft.cms.param;
+
+import java.math.BigDecimal;
+import com.gxwebsoft.common.core.annotation.QueryField;
+import com.gxwebsoft.common.core.annotation.QueryType;
+import com.gxwebsoft.common.core.web.BaseParam;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 网站订单查询参数
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "CmsOrderParam对象", description = "网站订单查询参数")
+public class CmsOrderParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "id")
+    @QueryField(type = QueryType.EQ)
+    private Integer id;
+
+    @Schema(description = "订单类型，0售前咨询 1售后服务 2意见反馈")
+    @QueryField(type = QueryType.EQ)
+    private Integer type;
+
+    @Schema(description = "订单标题")
+    private String title;
+
+    @Schema(description = "公司/团队名称")
+    private String company;
+
+    @Schema(description = "订单内容")
+    private String content;
+
+    @Schema(description = "订单编号")
+    private String orderNo;
+
+    @Schema(description = "快递/自提")
+    @QueryField(type = QueryType.EQ)
+    private Integer deliveryType;
+
+    @Schema(description = "下单渠道，0网站 1微信小程序 2其他")
+    @QueryField(type = QueryType.EQ)
+    private Integer channel;
+
+    @Schema(description = "微信支付交易号号")
+    private String transactionId;
+
+    @Schema(description = "微信退款订单号")
+    private String refundOrder;
+
+    @Schema(description = "商户ID")
+    @QueryField(type = QueryType.EQ)
+    private Long merchantId;
+
+    @Schema(description = "商户名称")
+    private String merchantName;
+
+    @Schema(description = "商户编号")
+    private String merchantCode;
+
+    @Schema(description = "使用的优惠券id")
+    @QueryField(type = QueryType.EQ)
+    private Integer couponId;
+
+    @Schema(description = "使用的会员卡id")
+    private String cardId;
+
+    @Schema(description = "关联管理员id")
+    @QueryField(type = QueryType.EQ)
+    private Integer adminId;
+
+    @Schema(description = "核销管理员id")
+    @QueryField(type = QueryType.EQ)
+    private Integer confirmId;
+
+    @Schema(description = "IC卡号")
+    private String icCard;
+
+    @Schema(description = "真实姓名")
+    private String realName;
+
+    @Schema(description = "关联收货地址")
+    @QueryField(type = QueryType.EQ)
+    private Integer addressId;
+
+    @Schema(description = "收货地址")
+    private String address;
+
+    private String addressLat;
+
+    private String addressLng;
+
+    @Schema(description = "自提店铺id")
+    @QueryField(type = QueryType.EQ)
+    private Integer selfTakeMerchantId;
+
+    @Schema(description = "自提店铺")
+    private String selfTakeMerchantName;
+
+    @Schema(description = "配送开始时间")
+    private String sendStartTime;
+
+    @Schema(description = "配送结束时间")
+    private String sendEndTime;
+
+    @Schema(description = "发货店铺id")
+    @QueryField(type = QueryType.EQ)
+    private Integer expressMerchantId;
+
+    @Schema(description = "发货店铺")
+    private String expressMerchantName;
+
+    @Schema(description = "订单总额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal totalPrice;
+
+    @Schema(description = "减少的金额，使用VIP会员折扣、优惠券抵扣、优惠券折扣后减去的价格")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal reducePrice;
+
+    @Schema(description = "实际付款")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal payPrice;
+
+    @Schema(description = "用于统计")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal price;
+
+    @Schema(description = "价钱，用于积分赠送")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal money;
+
+    @Schema(description = "取消时间")
+    private String cancelTime;
+
+    @Schema(description = "取消原因")
+    private String cancelReason;
+
+    @Schema(description = "退款金额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal refundMoney;
+
+    @Schema(description = "教练价格")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal coachPrice;
+
+    @Schema(description = "购买数量")
+    @QueryField(type = QueryType.EQ)
+    private Integer totalNum;
+
+    @Schema(description = "教练id")
+    @QueryField(type = QueryType.EQ)
+    private Integer coachId;
+
+    @Schema(description = "商品ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer formId;
+
+    @Schema(description = "支付的用户id")
+    @QueryField(type = QueryType.EQ)
+    private Integer payUserId;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    @QueryField(type = QueryType.EQ)
+    private Integer payType;
+
+    @Schema(description = "微信支付子类型：JSAPI小程序支付，NATIVE扫码支付")
+    private String wechatPayType;
+
+    @Schema(description = "0余额支付，1微信支付，2支付宝支付，3银联支付，4现金支付，5POS机支付，6免费，7积分支付")
+    @QueryField(type = QueryType.EQ)
+    private Integer friendPayType;
+
+    @Schema(description = "0未付款，1已付款")
+    @QueryField(type = QueryType.EQ)
+    private Integer payStatus;
+
+    @Schema(description = "0未使用，1已完成，2已取消，3取消中，4退款申请中，5退款被拒绝，6退款成功，7客户端申请退款")
+    @QueryField(type = QueryType.EQ)
+    private Integer orderStatus;
+
+    @Schema(description = "发货状态(10未发货 20已发货 30部分发货)")
+    @QueryField(type = QueryType.EQ)
+    private Integer deliveryStatus;
+
+    @Schema(description = "无需发货备注")
+    private String deliveryNote;
+
+    @Schema(description = "发货时间")
+    private String deliveryTime;
+
+    @Schema(description = "评价状态(0未评价 1已评价)")
+    @QueryField(type = QueryType.EQ)
+    private Integer evaluateStatus;
+
+    @Schema(description = "评价时间")
+    private String evaluateTime;
+
+    @Schema(description = "优惠类型：0无、1抵扣优惠券、2折扣优惠券、3、VIP月卡、4VIP年卡，5VIP次卡、6VIP会员卡、7IC月卡、8IC年卡、9IC次卡、10IC会员卡、11免费订单、12VIP充值卡、13IC充值卡、14VIP季卡、15IC季卡")
+    @QueryField(type = QueryType.EQ)
+    private Integer couponType;
+
+    @Schema(description = "优惠说明")
+    private String couponDesc;
+
+    @Schema(description = "二维码地址，保存订单号，支付成功后才生成")
+    private String qrcode;
+
+    @Schema(description = "vip月卡年卡、ic月卡年卡回退次数")
+    @QueryField(type = QueryType.EQ)
+    private Integer returnNum;
+
+    @Schema(description = "vip充值回退金额")
+    @QueryField(type = QueryType.EQ)
+    private BigDecimal returnMoney;
+
+    @Schema(description = "预约详情开始时间数组")
+    private String startTime;
+
+    @Schema(description = "是否已开具发票：0未开发票，1已开发票，2不能开具发票")
+    @QueryField(type = QueryType.EQ)
+    private Integer isInvoice;
+
+    @Schema(description = "发票流水号")
+    private String invoiceNo;
+
+    @Schema(description = "商家留言")
+    private String merchantRemarks;
+
+    @Schema(description = "支付时间")
+    private String payTime;
+
+    @Schema(description = "退款时间")
+    private String refundTime;
+
+    @Schema(description = "申请退款时间")
+    private String refundApplyTime;
+
+    @Schema(description = "过期时间")
+    private String expirationTime;
+
+    @Schema(description = "自提码")
+    private String selfTakeCode;
+
+    @Schema(description = "是否已收到赠品")
+    @QueryField(type = QueryType.EQ)
+    private Boolean hasTakeGift;
+
+    @Schema(description = "对账情况：0=未对账；1=已对账；3=已对账，金额对不上；4=未查询到该订单")
+    @QueryField(type = QueryType.EQ)
+    private Integer checkBill;
+
+    @Schema(description = "订单是否已结算(0未结算 1已结算)")
+    @QueryField(type = QueryType.EQ)
+    private Integer isSettled;
+
+    @Schema(description = "系统版本号 0当前版本 value=其他版本")
+    @QueryField(type = QueryType.EQ)
+    private Integer version;
+
+    @Schema(description = "用户id")
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "排序号")
+    @QueryField(type = QueryType.EQ)
+    private Integer sortNumber;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @QueryField(type = QueryType.EQ)
+    private Integer deleted;
+
+}

src/main/java/com/gxwebsoft/cms/service/CmsOrderService.java

@@ -0,0 +1,42 @@
+package com.gxwebsoft.cms.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.gxwebsoft.common.core.web.PageResult;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+
+import java.util.List;
+
+/**
+ * 网站订单Service
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+public interface CmsOrderService extends IService<CmsOrder> {
+
+    /**
+     * 分页关联查询
+     *
+     * @param param 查询参数
+     * @return PageResult<CmsOrder>
+     */
+    PageResult<CmsOrder> pageRel(CmsOrderParam param);
+
+    /**
+     * 关联查询全部
+     *
+     * @param param 查询参数
+     * @return List<CmsOrder>
+     */
+    List<CmsOrder> listRel(CmsOrderParam param);
+
+    /**
+     * 根据id查询
+     *
+     * @param id id
+     * @return CmsOrder
+     */
+    CmsOrder getByIdRel(Integer id);
+
+}

src/main/java/com/gxwebsoft/cms/service/impl/CmsOrderServiceImpl.java

@@ -0,0 +1,47 @@
+package com.gxwebsoft.cms.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gxwebsoft.cms.mapper.CmsOrderMapper;
+import com.gxwebsoft.cms.service.CmsOrderService;
+import com.gxwebsoft.cms.entity.CmsOrder;
+import com.gxwebsoft.cms.param.CmsOrderParam;
+import com.gxwebsoft.common.core.web.PageParam;
+import com.gxwebsoft.common.core.web.PageResult;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * 网站订单Service实现
+ *
+ * @author 科技小王子
+ * @since 2026-01-27 13:03:24
+ */
+@Service
+public class CmsOrderServiceImpl extends ServiceImpl<CmsOrderMapper, CmsOrder> implements CmsOrderService {
+
+    @Override
+    public PageResult<CmsOrder> pageRel(CmsOrderParam param) {
+        PageParam<CmsOrder, CmsOrderParam> page = new PageParam<>(param);
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        List<CmsOrder> list = baseMapper.selectPageRel(page, param);
+        return new PageResult<>(list, page.getTotal());
+    }
+
+    @Override
+    public List<CmsOrder> listRel(CmsOrderParam param) {
+        List<CmsOrder> list = baseMapper.selectListRel(param);
+        // 排序
+        PageParam<CmsOrder, CmsOrderParam> page = new PageParam<>();
+        page.setDefaultOrder("sort_number asc, create_time desc");
+        return page.sortRecords(list);
+    }
+
+    @Override
+    public CmsOrder getByIdRel(Integer id) {
+        CmsOrderParam param = new CmsOrderParam();
+        param.setId(id);
+        return param.getOne(baseMapper.selectListRel(param));
+    }
+
+}

src/main/java/com/gxwebsoft/cms/service/impl/CmsWebsiteServiceImpl.java

@@ -337,9 +337,16 @@ public class CmsWebsiteServiceImpl extends ServiceImpl<CmsWebsiteMapper, CmsWebs
     if (StrUtil.isNotBlank(siteInfo)) {
       log.info("从缓存获取网站信息，租户ID: {}", tenantId);
       try {
-        return JSONUtil.parseObject(siteInfo, ShopVo.class);
+        // 兼容历史缓存：JSON "null" 会被解析为 null；此时应视为未命中并回源数据库。
+        ShopVo cacheVo = JSONUtil.parseObject(siteInfo, ShopVo.class);
+        if (cacheVo != null) {
+          return cacheVo;
+        }
+        log.warn("网站信息缓存命中但内容为空(null)，清理缓存后回源数据库，租户ID: {}", tenantId);
+        redisUtil.delete(cacheKey);
       } catch (Exception e) {
-        log.warn("缓存解析失败，从数据库重新获取: {}", e.getMessage());
+        log.warn("缓存解析失败，清理缓存后从数据库重新获取: {}", e.getMessage());
+        redisUtil.delete(cacheKey);
       }
     }
 

src/main/java/com/gxwebsoft/common/core/Constants.java

@@ -65,16 +65,6 @@ public class Constants {
      */
     public static final String BAD_CREDENTIALS_MSG = "请退出重新登录";
 
-    /**
-     * 服务暂不可用错误码（Redis 连接被重置、核心实例不可达等基础设施故障，不是用户凭据问题）
-     */
-    public static final int SERVICE_UNAVAILABLE_CODE = 503;
-
-    /**
-     * 服务暂不可用提示信息
-     */
-    public static final String SERVICE_UNAVAILABLE_MSG = "服务暂不可用，请稍后重试";
-
     /**
      * 表示升序的值
      */

src/main/java/com/gxwebsoft/common/core/config/ConfigProperties.java

@@ -92,6 +92,11 @@ public class ConfigProperties {
    */
   private String serverUrl;
 
+  /**
+   * API网关地址
+   */
+  private String apiUrl;
+
   /**
    * 阿里云存储 OSS
    * Endpoint

src/main/java/com/gxwebsoft/common/core/config/JacksonConfig.java

@@ -4,7 +4,6 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
 import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;

src/main/java/com/gxwebsoft/common/core/config/LocalDateTimeDeserializer.java

@@ -1,11 +1,14 @@
 package com.gxwebsoft.common.core.config;
 
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonToken;
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.JsonDeserializer;
 
 import java.io.IOException;
+import java.time.Instant;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 
 /**
@@ -16,14 +19,43 @@ import java.time.format.DateTimeFormatter;
  */
 public class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
 
-    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+    private final DateTimeFormatter formatter;
+
+    public LocalDateTimeDeserializer() {
+        this(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+    }
+
+    public LocalDateTimeDeserializer(DateTimeFormatter formatter) {
+        this.formatter = formatter;
+    }
 
     @Override
     public LocalDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
-        String value = p.getValueAsString();
-        if (value != null && !value.isEmpty()) {
-            return LocalDateTime.parse(value, FORMATTER);
+        JsonToken t = p.currentToken();
+        ZoneId zoneId = ctxt.getTimeZone() != null ? ctxt.getTimeZone().toZoneId() : ZoneId.systemDefault();
+
+        // Accept epoch timestamps (seconds or millis) for compatibility with frontends that send numbers.
+        if (t == JsonToken.VALUE_NUMBER_INT) {
+            long ts = p.getLongValue();
+            // Heuristic: 10+ digits is seconds; 13+ digits is millis (most common in JS).
+            Instant instant = (String.valueOf(Math.abs(ts)).length() >= 13)
+                    ? Instant.ofEpochMilli(ts)
+                    : Instant.ofEpochSecond(ts);
+            return LocalDateTime.ofInstant(instant, zoneId);
         }
-        return null;
+
+        String value = p.getValueAsString();
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+
+        // Handle numeric timestamps passed as strings, e.g. "1769618486000"
+        if (value.chars().allMatch(Character::isDigit)) {
+            long ts = Long.parseLong(value);
+            Instant instant = (value.length() >= 13) ? Instant.ofEpochMilli(ts) : Instant.ofEpochSecond(ts);
+            return LocalDateTime.ofInstant(instant, zoneId);
+        }
+
+        return LocalDateTime.parse(value, formatter);
     }
 }

src/main/java/com/gxwebsoft/common/core/config/SwaggerConfig.java

@@ -80,7 +80,8 @@ public class SwaggerConfig {
     public GroupedOpenApi shopApi() {
         return GroupedOpenApi.builder()
                 .group("shop")
-                .pathsToMatch("/api/shop/**")
+                // 订单等用户侧接口在 shop 包内，但路径使用 /api/user/**（前端统一 user 侧 API 前缀）
+                .pathsToMatch("/api/shop/**", "/api/user/**")
                 .packagesToScan("com.gxwebsoft.shop")
                 .build();
     }

src/main/java/com/gxwebsoft/common/core/controller/TestController.java

@@ -5,7 +5,6 @@ import com.gxwebsoft.common.system.entity.Payment;
 import com.gxwebsoft.common.system.service.PaymentService;
 import com.gxwebsoft.common.system.param.PaymentParam;
 import com.gxwebsoft.common.core.web.ApiResult;
-import com.gxwebsoft.payment.service.WxPayConfigService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -40,9 +39,6 @@ public class TestController extends BaseController {
     @Autowired
     private PaymentService paymentService;
 
-    @Autowired
-    private WxPayConfigService wxPayConfigService;
-
     @Operation(summary = "测试LocalDateTime序列化")
     @GetMapping("/datetime")
     public ApiResult<Map<String, Object>> testDateTime() {
@@ -237,8 +233,6 @@ public class TestController extends BaseController {
             // 清理可能的缓存键
             paymentCacheService.removePaymentConfig("0", tenantId);  // 微信支付
             paymentCacheService.removePaymentConfig("wechat", tenantId);  // 可能的其他格式
-            // 清理实际生效的缓存键：Payment:1:{tenantId} 与内存中的微信支付配置
-            wxPayConfigService.clearConfigCache(tenantId);
 
             String result = "✅ 缓存已清理，租户ID: " + tenantId;
             System.out.println(result);

src/main/java/com/gxwebsoft/common/core/security/AuthFailureUtil.java

@@ -1,64 +0,0 @@
-package com.gxwebsoft.common.core.security;
-
-import io.lettuce.core.RedisException;
-import org.springframework.data.redis.RedisConnectionFailureException;
-import org.springframework.data.redis.RedisSystemException;
-
-import java.io.IOException;
-
-/**
- * 鉴权链路上的失败分类：这次失败是<b>用户凭据问题</b>，还是<b>基础设施抖了一下</b>？
- *
- * <p><b>为什么必须分开</b>：鉴权过滤器里除了「token 无效」，还有两次外部依赖调用——
- * 核心实例的 {@code /auth/user} 与 Redis 的域名白名单读。此前它们抛出的异常与「token 无效」
- * 一起被兜底成 {@code 401 请退出重新登录}，于是线上出现这样一条报文：</p>
- *
- * <pre>
- * {"code":401,"message":"请退出重新登录",
- *  "error":"org.springframework.data.redis.RedisSystemException: Redis exception;
- *           nested exception is io.lettuce.core.RedisException:
- *           java.net.SocketException: Connection reset"}
- * </pre>
- *
- * <p>用户照着这句话去重新登录，什么也解决不了——Redis 连接被重置跟他手里的 token 毫无关系；
- * 而真正的故障（Redis / 核心实例）被「登录态异常」这层皮盖住了，排查方向从一开始就被带偏。
- * 重新登录还会把一份<b>完全有效</b>的凭据丢掉，把一次秒级抖动放大成用户的重复劳动。</p>
- *
- * <p><b>判定方式</b>：沿 cause 链找基础设施异常。之所以要沿链找，是因为真实抛出的异常是套娃的——
- * {@code RedisSystemException → io.lettuce.core.RedisException → java.net.SocketException}、
- * {@code cn.hutool.core.io.IORuntimeException → java.net.ConnectException}，
- * 只看最外层的类型会漏判。凭据类异常（{@code MalformedJwtException} / {@code SignatureException} /
- * {@code UsernameNotFoundException}）的 cause 链里不会出现这些类型。</p>
- */
-public final class AuthFailureUtil {
-
-    /** cause 链的遍历深度上限，防御自引用或异常实现里的环 */
-    private static final int MAX_CAUSE_DEPTH = 16;
-
-    private AuthFailureUtil() {
-    }
-
-    /**
-     * 是否为基础设施故障（Redis 连接被重置/超时、核心实例不可达等）。
-     *
-     * <p>这类失败<b>不该</b>报「请退出重新登录」，应报
-     * {@link com.gxwebsoft.common.core.Constants#SERVICE_UNAVAILABLE_MSG}，让用户稍后重试即可。</p>
-     *
-     * @param e 鉴权过程中抛出的异常
-     * @return true 表示与用户凭据无关，是基础设施的问题
-     */
-    public static boolean isInfrastructureFailure(Throwable e) {
-        Throwable t = e;
-        for (int depth = 0; t != null && depth < MAX_CAUSE_DEPTH; depth++) {
-            if (t instanceof RedisConnectionFailureException
-                    || t instanceof RedisSystemException
-                    || t instanceof RedisException
-                    || t instanceof IOException) {
-                return true;
-            }
-            Throwable cause = t.getCause();
-            t = (cause == t) ? null : cause;
-        }
-        return false;
-    }
-}

src/main/java/com/gxwebsoft/common/core/security/JwtAuthenticationFilter.java

@@ -107,13 +107,6 @@ public class JwtAuthenticationFilter extends OncePerRequestFilter {
           e.getMessage());
         return;
       } catch (Exception e) {
-        // Redis 连接被重置、核心实例不可达属于基础设施抖动，与用户凭据无关：
-        // 报「请退出重新登录」既解决不了问题，又把真正的故障掩盖成一次登录态异常。
-        if (AuthFailureUtil.isInfrastructureFailure(e)) {
-          CommonUtil.responseError(response, Constants.SERVICE_UNAVAILABLE_CODE,
-            Constants.SERVICE_UNAVAILABLE_MSG, e.toString());
-          return;
-        }
         CommonUtil.responseError(response, Constants.BAD_CREDENTIALS_CODE, Constants.BAD_CREDENTIALS_MSG,
           e.toString());
         return;

src/main/java/com/gxwebsoft/common/core/security/SecurityConfig.java

@@ -67,6 +67,7 @@ public class SecurityConfig {
                         "/api/shop/wx-login/**",
                         "/api/shop/wx-native-pay/**",
                         "/api/shop/wx-pay/**",
+                        "/api/system/wx-pay/**",
                         "/api/bszx/bszx-pay/notify/**",
                         "/api/wxWorkQrConnect",
                         "/WW_verify_QMv7HoblYU6z63bb.txt",
@@ -79,25 +80,7 @@ public class SecurityConfig {
                         "/api/shop/getShopInfo",
                         "/api/shop/shop-order/test",
                         "/api/qr-code/**",
-                        "/api/shop/order-delivery/notify",
-                        "/api/hjc/push/project",
-                        // 汇吉采买家端：注册/登录/验证码/退出都由 mp-java 代理核心实例，
-                        // 必须在登录前可访问；未登录的客户端本来也没有平台 token。
-                        "/api/hjc/auth/register",
-                        "/api/hjc/auth/login",
-                        "/api/hjc/auth/logout",
-                        "/api/hjc/auth/captcha",
-                        "/api/hjc/auth/sms",
-                        // 注册页专用：证件上传与 OCR 识别在登录前发生
-                        "/api/hjc/auth/upload",
-                        "/api/hjc/ocr/recognize",
-                        // 小程序端登录：用 uni.login 的 code 换 openid，发生在业务请求之前，
-                        // 小程序侧此时还没有平台 token
-                        "/api/hjc/wechat/mp-login",
-                        // 密码找回：企业未登录时提交材料申请（进度查询走
-                        // GET /api/hjc/auth/password/apply/status，已被上面的 GET /** 放行）。
-                        // 「修改密码」的两个端点必须保持需要登录态，故刻意不在此列。
-                        "/api/hjc/auth/password/apply"
+                        "/api/shop/order-delivery/notify"
                 )
                 .permitAll()
                 .anyRequest()

src/main/java/com/gxwebsoft/common/core/service/EnvironmentAwarePaymentService.java

@@ -50,15 +50,26 @@ public class EnvironmentAwarePaymentService {
             return null;
         }
 
-        // 根据环境调整回调地址
+        // 开发/测试环境允许强制覆盖，方便本地联调。
+        if (isDevelopmentEnvironment()) {
+            Payment envPayment = clonePayment(payment);
+            String notifyUrl = getEnvironmentNotifyUrl();
+            log.info("环境感知支付配置(开发/测试) - 环境: {}, 原始回调: {}, 覆盖后回调: {}",
+                activeProfile, payment.getNotifyUrl(), notifyUrl);
+            envPayment.setNotifyUrl(notifyUrl);
+            return envPayment;
+        }
+
+        // 生产/其它环境：优先使用数据库中的 notifyUrl（多租户域名可能不同）。
+        if (payment.getNotifyUrl() != null && !payment.getNotifyUrl().trim().isEmpty()) {
+            return payment;
+        }
+
+        // 数据库未配置时才兜底使用环境配置。
         Payment envPayment = clonePayment(payment);
         String notifyUrl = getEnvironmentNotifyUrl();
-        
-        log.info("环境感知支付配置 - 环境: {}, 原始回调: {}, 调整后回调: {}", 
-                activeProfile, payment.getNotifyUrl(), notifyUrl);
-        
+        log.info("环境感知支付配置(兜底) - 环境: {}, 原始回调为空，兜底回调: {}", activeProfile, notifyUrl);
         envPayment.setNotifyUrl(notifyUrl);
-        
         return envPayment;
     }
 

src/main/java/com/gxwebsoft/common/core/utils/JSONUtil.java

@@ -1,8 +1,13 @@
 package com.gxwebsoft.common.core.utils;
 
 import cn.hutool.core.util.StrUtil;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
+import java.util.TimeZone;
 
 /**
  * JSON解析工具类
@@ -11,8 +16,21 @@ import com.fasterxml.jackson.databind.ObjectWriter;
  * @since 2017-06-10 10:10:39
  */
 public class JSONUtil {
-    private static final ObjectMapper objectMapper = new ObjectMapper();
-    private static final ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
+    /**
+     * 注意：不要直接 new ObjectMapper() 否则不支持 Java8 时间类型（LocalDateTime 等）。
+     * 这里做最小可用配置，避免在 Redis/日志/签名等场景序列化失败。
+     */
+    private static final ObjectMapper objectMapper;
+    private static final ObjectWriter objectWriter;
+
+    static {
+        objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
+        objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
+    }
 
     /**
      * 对象转json字符串

src/main/java/com/gxwebsoft/common/core/web/ImportParams.java

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2013-2015 JueYue (qrb.jueyue@gmail.com)
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.gxwebsoft.common.core.web;
+
+import cn.afterturn.easypoi.excel.entity.ExcelBaseParams;
+import cn.afterturn.easypoi.handler.inter.IExcelVerifyHandler;
+import lombok.Data;
+
+/**
+ * 导入参数设置
+ *
+ * @author JueYue
+ *  2013-9-24
+ * @version 1.0
+ */
+@Data
+public class ImportParams extends ExcelBaseParams {
+
+    public static final String SAVE_URL = "/excel/upload/excelUpload";
+
+    /**
+     * 表格标题行数,默认0
+     */
+    private int                 titleRows        = 0;
+    /**
+     * 表头行数,默认1
+     */
+    private int                 headRows         = 1;
+    /**
+     * 字段真正值和列标题之间的距离 默认0
+     */
+    private int                 startRows        = 0;
+
+    /**
+     * 主键设置,如何这个cell没有值,就跳过 或者认为这个是list的下面的值
+     * 大家不理解，去掉这个
+     */
+
+    private Integer             keyIndex         = null;
+    /**
+     * 开始读取的sheet位置,默认为0
+     */
+    private int                 startSheetIndex  = 0;
+    /**
+     * 上传表格需要读取的sheet 数量,默认为1
+     */
+    private int                 sheetNum         = 1;
+    /**
+     * 是否需要保存上传的Excel,默认为false
+     */
+    private boolean             needSave         = false;
+    /**
+     * 校验组
+     */
+    private Class[]             verifyGroup = null;
+    /**
+     * 是否需要校验上传的Excel,默认为false
+     */
+    private boolean             needVerify = false;
+    /**
+     * 返回文件是否分割,默认是分割
+     */
+    private boolean             verifyFileSplit = true;
+    /**
+     * 校验处理接口
+     */
+    private IExcelVerifyHandler verifyHandler;
+    /**
+     * 保存上传的Excel目录,默认是 如 TestEntity这个类保存路径就是
+     * upload/excelUpload/Test/yyyyMMddHHmss_***** 保存名称上传时间_五位随机数
+     */
+    private String              saveUrl          = SAVE_URL;
+    /**
+     * 最后的无效行数
+     */
+    private int                 lastOfInvalidRow = 0;
+    /**
+     * 手动控制读取的行数
+     */
+    private int                 readRows = 0;
+    /**
+     * 导入时校验数据模板,是不是正确的Excel
+     */
+    private String[]            importFields;
+    /**
+     * 导入时校验excel的标题列顺序。依赖于importFields的配置顺序
+    */
+    private boolean             needCheckOrder = false;
+    /**
+     * Key-Value 读取标记,以这个为Key,后面一个Cell 为Value,多个改为ArrayList
+     */
+    private String              keyMark = ":";
+    /**
+     * 按照Key-Value 规则读取全局扫描Excel,但是跳过List读取范围提升性能
+     * 仅仅支持titleRows + headRows + startRows 以及 lastOfInvalidRow
+     */
+    private boolean             readSingleCell = false;
+    /**
+     * 是否并行计算
+     */
+    private boolean             concurrentTask = false;
+    /**
+     * 最小截取大小
+     */
+    private Integer             critical = 1000;
+}

src/main/java/com/gxwebsoft/common/core/websocket/WebSocketServer.java

@@ -35,7 +35,13 @@ public class WebSocketServer {
     public void onOpen(Session session, @PathParam("userId") String userId) {
         this.session = session;
         this.userId = userId;
-        webSocketMap.put(userId, this);
+        if (webSocketMap.containsKey(userId)) {
+            webSocketMap.remove(userId);
+            webSocketMap.put(userId, this);
+            //加入set中
+        } else {
+            webSocketMap.put(userId, this);
+        }
 
         try {
             sendMessage(userId, "连接成功");
@@ -49,24 +55,20 @@ public class WebSocketServer {
      */
     @OnClose
     public void onClose() {
-        webSocketMap.remove(userId, this);
+        if (webSocketMap.containsKey(userId)) {
+            webSocketMap.remove(userId);
+        }
     }
 
 
     /**
      * 实现服务器主动推送
      */
-    public boolean sendMessage(String userId, String message) throws IOException {
-        WebSocketServer webSocketServer = webSocketMap.get(userId);
-        if (webSocketServer == null || webSocketServer.session == null
-            || !webSocketServer.session.isOpen()) {
-            if (webSocketServer != null) {
-                webSocketMap.remove(userId, webSocketServer);
-            }
-            return false;
+    public void sendMessage(String userId, String message) throws IOException {
+        if (webSocketMap.containsKey(userId)) {
+            Session session1 = webSocketMap.get(userId).session;
+            if (session1 != null) session1.getBasicRemote().sendText(message);
         }
-        webSocketServer.session.getBasicRemote().sendText(message);
-        return true;
     }
 
 

src/main/java/com/gxwebsoft/common/system/controller/MenuController.java

@@ -1,20 +1,29 @@
 package com.gxwebsoft.common.system.controller;
 
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.gxwebsoft.common.core.annotation.OperationLog;
 import com.gxwebsoft.common.core.web.*;
-import com.gxwebsoft.common.system.entity.Menu;
-import com.gxwebsoft.common.system.entity.Plug;
+import com.gxwebsoft.common.system.entity.*;
+import com.gxwebsoft.common.system.param.MenuImportParam;
 import com.gxwebsoft.common.system.param.MenuParam;
-import com.gxwebsoft.common.system.service.MenuService;
-import com.gxwebsoft.common.system.service.PlugService;
-import io.swagger.v3.oas.annotations.tags.Tag;
+import com.gxwebsoft.common.system.param.VersionParam;
+import com.gxwebsoft.common.system.service.*;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 import javax.annotation.Resource;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 菜单控制器
@@ -22,21 +31,27 @@ import java.util.List;
  * @author WebSoft
  * @since 2018-12-24 16:10:23
  */
-@Tag(name = "菜单管理")
+@Tag(name = "菜单")
 @RestController
 @RequestMapping("/api/system/menu")
 public class MenuController extends BaseController {
     @Resource
     private MenuService menuService;
     @Resource
-    private PlugService plugService;
+    private CompanyService companyService;
+    @Resource
+    private UserService userService;
+    @Resource
+    private RoleService roleService;
+    @Resource
+    private RoleMenuService roleMenuService;
 
     @PreAuthorize("hasAuthority('sys:menu:list')")
     @Operation(summary = "分页查询菜单")
     @GetMapping("/page")
     public ApiResult<PageResult<Menu>> page(MenuParam param) {
         PageParam<Menu, MenuParam> page = new PageParam<>(param);
-        page.setDefaultOrder("sort_number");
+        page.setDefaultOrder("sort_number asc, create_time desc");
         return success(menuService.page(page, page.getWrapper()));
     }
 
@@ -45,7 +60,7 @@ public class MenuController extends BaseController {
     @GetMapping()
     public ApiResult<List<Menu>> list(MenuParam param) {
         PageParam<Menu, MenuParam> page = new PageParam<>(param);
-        page.setDefaultOrder("sort_number");
+        page.setDefaultOrder("sort_number asc, create_time desc");
         return success(menuService.list(page.getOrderWrapper()));
     }
 
@@ -57,12 +72,18 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:save')")
+    @OperationLog
     @Operation(summary = "添加菜单")
     @PostMapping()
     public ApiResult<?> add(@RequestBody Menu menu) {
         if (menu.getParentId() == null) {
             menu.setParentId(0);
         }
+        // 去除字符串前面的空格
+        menu.setTitle(StrUtil.trimStart(menu.getTitle()));
+        menu.setPath(StrUtil.trimStart(menu.getPath()));
+        menu.setComponent(StrUtil.trimStart(menu.getComponent()));
+        menu.setAuthority(StrUtil.trimStart(menu.getAuthority()));
         if (menuService.save(menu)) {
             return success("添加成功");
         }
@@ -70,9 +91,15 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
+    @OperationLog
     @Operation(summary = "修改菜单")
     @PutMapping()
     public ApiResult<?> update(@RequestBody Menu menu) {
+        // 去除字符串前面的空格
+        menu.setTitle(StrUtil.trimStart(menu.getTitle()));
+        menu.setPath(StrUtil.trimStart(menu.getPath()));
+        menu.setComponent(StrUtil.trimStart(menu.getComponent()));
+        menu.setAuthority(StrUtil.trimStart(menu.getAuthority()));
         if (menuService.updateById(menu)) {
             return success("修改成功");
         }
@@ -80,6 +107,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @OperationLog
     @Operation(summary = "删除菜单")
     @DeleteMapping("/{id}")
     public ApiResult<?> remove(@PathVariable("id") Integer id) {
@@ -90,6 +118,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:save')")
+    @OperationLog
     @Operation(summary = "批量添加菜单")
     @PostMapping("/batch")
     public ApiResult<?> saveBatch(@RequestBody List<Menu> menus) {
@@ -100,6 +129,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
+    @OperationLog
     @Operation(summary = "批量修改菜单")
     @PutMapping("/batch")
     public ApiResult<?> updateBatch(@RequestBody BatchParam<Menu> batchParam) {
@@ -110,6 +140,7 @@ public class MenuController extends BaseController {
     }
 
     @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @OperationLog
     @Operation(summary = "批量删除菜单")
     @DeleteMapping("/batch")
     public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
@@ -119,14 +150,35 @@ public class MenuController extends BaseController {
         return fail("删除失败");
     }
 
-    @PreAuthorize("hasAuthority('sys:menu:update')")
-    @Operation(summary = "菜单克隆")
-    @PostMapping("/clone")
-    public ApiResult<?> onClone(@RequestBody MenuParam param){
-      if(menuService.cloneMenu(param)){
-        return success("克隆成功,请刷新");
+    @PreAuthorize("hasAuthority('sys:menu:remove')")
+    @Operation(summary = "删除父级以下菜单")
+    @DeleteMapping("/deleteParentMenu/{id}")
+    public ApiResult<?> deleteParentMenu(@PathVariable("id") Integer id) {
+      final List<Menu> list = menuService.list(new LambdaQueryWrapper<Menu>().eq(Menu::getParentId, id));
+      if (CollectionUtils.isEmpty(list)) {
+        menuService.removeById(id);
+        return success("删除成功");
       }
-      return fail("克隆失败");
+      final Set<Integer> ids = list.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+      final List<Menu> list2 = menuService.list(new LambdaUpdateWrapper<Menu>().in(Menu::getParentId, ids));
+      final Set<Integer> collect = list2.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+      if (!CollectionUtils.isEmpty(list2)) {
+        ids.addAll(collect);
+        final List<Menu> list3 = menuService.list(new LambdaUpdateWrapper<Menu>().in(Menu::getParentId, ids));
+        final Set<Integer> collect1 = list3.stream().map(Menu::getMenuId).collect(Collectors.toSet());
+        if (!CollectionUtils.isEmpty(collect1)) {
+          ids.addAll(collect1);
+        }
+        ids.add(id);
+        if (menuService.removeByIds(ids)) {
+          return success("删除成功");
+        }
+      }
+      ids.add(id);
+      if (menuService.removeByIds(ids)) {
+        return success("删除成功");
+      }
+      return fail("删除失败");
     }
 
     @PreAuthorize("hasAuthority('sys:menu:update')")
@@ -135,11 +187,271 @@ public class MenuController extends BaseController {
     public ApiResult<?> install(@PathVariable("id") Integer id){
       if(menuService.install(id)){
         // 更新安装次数
-        final Plug plug = plugService.getOne(new LambdaQueryWrapper<Plug>().eq(Plug::getMenuId, id));
-        plug.setInstalls(plug.getInstalls() + 1);
-        plugService.updateById(plug);
+//        final Plug plug = plugService.getOne(new LambdaQueryWrapper<Plug>().eq(Plug::getMenuId, id));
+//        plug.setInstalls(plug.getInstalls() + 1);
+//        plugService.updateById(plug);
         return success("安装成功");
       }
       return fail("安装失败",id);
     }
+
+    /**
+     * excel批量导入菜单
+     */
+    @PreAuthorize("hasAuthority('sys:menu:save')")
+    @Operation(summary = "批量导入菜单")
+    @Transactional(rollbackFor = {Exception.class})
+    @PostMapping("/import")
+    public ApiResult<?> importBatch(MultipartFile file) {
+        ImportParams importParams = new ImportParams();
+        try {
+            System.out.println("=== 开始菜单导入流程 ===");
+
+            // 检查导入前的菜单数据
+            long beforeCount = menuService.count();
+            System.out.println("导入前菜单总数: " + beforeCount);
+
+            // 检查当前未删除的菜单
+            List<Menu> undeletedMenus = menuService.list(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 0));
+            System.out.println("当前未删除的菜单数: " + undeletedMenus.size());
+            if (!undeletedMenus.isEmpty()) {
+                System.out.println("未删除菜单列表:");
+                for (Menu menu : undeletedMenus) {
+                    System.out.println("  ID: " + menu.getMenuId() + ", 名称: " + menu.getTitle() +
+                        ", 父级ID: " + menu.getParentId() + ", deleted: " + menu.getDeleted());
+                }
+            }
+
+            // 第一步：永久删除已标记为 deleted=1 的记录
+            boolean deleteResult = menuService.remove(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 1));
+            System.out.println("已永久删除标记为deleted=1的菜单记录，结果: " + deleteResult);
+
+            // 第二步：将现有未删除的记录（deleted=0）标记为 deleted=1
+            if (!undeletedMenus.isEmpty()) {
+                LambdaUpdateWrapper<Menu> updateWrapper = new LambdaUpdateWrapper<>();
+                updateWrapper.eq(Menu::getDeleted, 0);
+                updateWrapper.set(Menu::getDeleted, 1);
+                boolean updateResult = menuService.update(updateWrapper);
+                System.out.println("更新未删除菜单记录的结果: " + updateResult);
+            }
+
+            // 检查更新后的菜单数据
+            long afterCleanupCount = menuService.count(new LambdaQueryWrapper<Menu>().eq(Menu::getDeleted, 0));
+            System.out.println("清理后未标记删除的菜单数: " + afterCleanupCount);
+
+            // 第三步：导入XLS文件的内容
+            List<MenuImportParam> list = ExcelImportUtil.importExcel(file.getInputStream(), MenuImportParam.class, importParams);
+            System.out.println("从Excel文件中读取到" + list.size() + "条菜单记录");
+
+            // 存储原始parentId到菜单列表的映射关系
+            Map<Integer, List<MenuImportParam>> menuGroups = new HashMap<>();
+            // 存储原始ID到新菜单对象的映射关系（用于后续设置正确的parentId）
+            Map<Integer, Menu> tempIdMapping = new HashMap<>();
+
+            // 按parentId分组（处理null值）
+            for (MenuImportParam param : list) {
+                Integer parentId = param.getParentId() != null ? param.getParentId() : 0;
+                menuGroups.computeIfAbsent(parentId, k -> new ArrayList<>()).add(param);
+            }
+
+            System.out.println("菜单分组情况:");
+            for (Map.Entry<Integer, List<MenuImportParam>> entry : menuGroups.entrySet()) {
+                System.out.println("  parentId=" + entry.getKey() + " 的菜单数: " + entry.getValue().size());
+            }
+
+            // 先创建所有父级菜单（parentId为0的菜单）
+            List<MenuImportParam> rootMenus = menuGroups.getOrDefault(0, new ArrayList<>());
+            List<Menu> createdRootMenus = new ArrayList<>();
+
+            System.out.println("开始创建" + rootMenus.size() + "个根菜单");
+            for (MenuImportParam param : rootMenus) {
+                Menu menu = convertToMenu(param);
+                menu.setParentId(0); // 根菜单的parentId为0
+                menuService.save(menu);
+                createdRootMenus.add(menu);
+                System.out.println("创建根菜单: " + menu.getTitle() + ", ID: " + menu.getMenuId() + ", 原始ID: " + param.getMenuId());
+
+                // 记录原始ID到新菜单的映射关系
+                if (param.getMenuId() != null) {
+                    tempIdMapping.put(param.getMenuId(), menu);
+                }
+            }
+
+            // 递归创建子级菜单（注意：这里不再处理parentId=0的菜单，因为已经在上面处理过了）
+            System.out.println("开始创建子级菜单（跳过根菜单）");
+            // 只处理非根菜单的子级菜单
+            for (Map.Entry<Integer, List<MenuImportParam>> entry : menuGroups.entrySet()) {
+                Integer parentId = entry.getKey();
+                if (parentId != 0) {  // 跳过根菜单（parentId=0）
+                    System.out.println("处理parentId=" + parentId + "的子菜单");
+                    createChildMenus(menuGroups, tempIdMapping, parentId);
+                }
+            }
+
+            // 获取所有导入的菜单ID
+            List<Integer> allImportedMenuIds = new ArrayList<>();
+            for (Menu menu : tempIdMapping.values()) {
+                allImportedMenuIds.add(menu.getMenuId());
+            }
+
+            System.out.println("总共导入了" + allImportedMenuIds.size() + "个菜单");
+
+            // 显示导入的菜单详情
+            if (!allImportedMenuIds.isEmpty()) {
+                List<Menu> allImportedMenus = menuService.list(new LambdaQueryWrapper<Menu>()
+                    .in(Menu::getMenuId, allImportedMenuIds)
+                    .orderByAsc(Menu::getParentId, Menu::getSortNumber));
+                System.out.println("导入的菜单详情:");
+                for (Menu menu : allImportedMenus) {
+                    System.out.println("  ID: " + menu.getMenuId() + ", 名称: " + menu.getTitle() +
+                        ", 父级ID: " + menu.getParentId() + ", 类型: " + menu.getMenuType());
+                }
+            }
+
+            // 为超级管理员配置菜单权限
+            if (!allImportedMenuIds.isEmpty()) {
+                List<Menu> allImportedMenus = menuService.list(new LambdaQueryWrapper<Menu>()
+                    .in(Menu::getMenuId, allImportedMenuIds));
+                System.out.println("为" + allImportedMenus.size() + "个菜单配置超级管理员权限");
+                configureSuperAdminPermissionsForImportedMenus(allImportedMenus);
+            }
+
+            // 最终检查
+            long finalCount = menuService.count();
+            System.out.println("导入后菜单总数: " + finalCount);
+            System.out.println("=== 菜单导入流程结束 ===");
+
+            return success("成功导入" + list.size() + "条");
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 递归创建子级菜单
+     * @param menuGroups 菜单分组
+     * @param tempIdMapping 临时ID映射关系
+     * @param originalParentId 原始父级ID
+     */
+    private void createChildMenus(Map<Integer, List<MenuImportParam>> menuGroups,
+                                  Map<Integer, Menu> tempIdMapping,
+                                  Integer originalParentId) {
+        System.out.println(">>> 进入createChildMenus方法，处理originalParentId=" + originalParentId);
+
+        // 特殊处理：originalParentId=0的情况已经在主方法中处理过了，这里不应该再处理
+        if (originalParentId == 0) {
+            System.out.println("  跳过originalParentId=0的处理（已在主方法中处理）");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        List<MenuImportParam> childMenus = menuGroups.get(originalParentId);
+        if (childMenus == null || childMenus.isEmpty()) {
+            System.out.println("  没有找到originalParentId=" + originalParentId + "的子菜单");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        // 获取新的父级菜单对象
+        Menu parentMenu = tempIdMapping.get(originalParentId);
+        if (parentMenu == null) {
+            System.out.println("  未找到原始ID为" + originalParentId + "的父级菜单，跳过处理");
+            System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+            return;
+        }
+
+        Integer newParentId = parentMenu.getMenuId();
+
+        System.out.println("  创建父级ID为" + originalParentId + "(新ID:" + newParentId + ")的子菜单，共" + childMenus.size() + "个");
+
+        // 创建所有子菜单
+        for (int i = 0; i < childMenus.size(); i++) {
+            MenuImportParam param = childMenus.get(i);
+            System.out.println("    处理第" + (i+1) + "个子菜单，原始ID: " + param.getMenuId() + ", 原始ParentId: " + param.getParentId());
+
+            Menu menu = convertToMenu(param);
+            menu.setParentId(newParentId);
+            menuService.save(menu);
+
+            System.out.println("    创建子菜单: " + menu.getTitle() + ", ID: " + menu.getMenuId() +
+                ", 父级ID: " + menu.getParentId() + ", 原始ID: " + param.getMenuId());
+
+            // 记录原始ID到新菜单的映射关系
+            if (param.getMenuId() != null) {
+                tempIdMapping.put(param.getMenuId(), menu);
+            }
+
+            // 递归创建当前菜单的子级菜单（使用原始ID作为下一个递归的父级ID）
+            System.out.println("    递归调用createChildMenus，处理原始ID=" + param.getMenuId() + "的子菜单");
+            createChildMenus(menuGroups, tempIdMapping, param.getMenuId());
+        }
+
+        System.out.println("<<< 退出createChildMenus方法，处理originalParentId=" + originalParentId);
+    }
+
+    /**
+     * 将MenuImportParam转换为Menu实体
+     * @param param MenuImportParam对象
+     * @return Menu实体
+     */
+    private Menu convertToMenu(MenuImportParam param) {
+        Menu menu = new Menu();
+        menu.setParentId(param.getParentId());
+        menu.setTitle(param.getTitle());
+        menu.setPath(param.getPath());
+        menu.setComponent(param.getComponent());
+        menu.setModules(param.getModules());
+        menu.setModulesUrl(param.getModulesUrl());
+        menu.setMenuType(param.getMenuType());
+        menu.setSortNumber(param.getSortNumber() != null ? param.getSortNumber() : 0);
+        menu.setAuthority(param.getAuthority());
+        menu.setIcon(param.getIcon());
+        menu.setHide(param.getHide());
+        menu.setAppId(param.getAppId());
+        menu.setTenantId(param.getTenantId());
+        menu.setDeleted(0); // 新导入的数据deleted设为0
+        return menu;
+    }
+
+    /**
+     * 为超级管理员配置导入菜单的权限
+     * @param importedMenus 导入的菜单列表
+     */
+    private void configureSuperAdminPermissionsForImportedMenus(List<Menu> importedMenus) {
+        try {
+            // 1.查找当前租户的超管权限的roleId
+            final Role superAdmin = roleService.getOne(new LambdaQueryWrapper<Role>().eq(Role::getRoleCode, "superAdmin"));
+            if (superAdmin == null) {
+                System.out.println("未找到superAdmin角色");
+                return;
+            }
+
+            final Integer roleId = superAdmin.getRoleId();
+            final Integer tenantId = superAdmin.getTenantId();
+
+            // 为所有导入的菜单配置权限
+            for (Menu menu : importedMenus) {
+                RoleMenu roleMenu = new RoleMenu();
+                roleMenu.setRoleId(roleId);
+                roleMenu.setMenuId(menu.getMenuId());
+                roleMenu.setTenantId(tenantId);
+                roleMenuService.save(roleMenu);
+            }
+
+            // 调整根菜单的排序（如果有根菜单的话）
+            for (Menu menu : importedMenus) {
+                if (menu.getParentId() == 0) {
+                    menu.setSortNumber(0);
+                    menuService.updateById(menu);
+                    break;
+                }
+            }
+
+            System.out.println("为超级管理员配置菜单权限成功，共配置了" + importedMenus.size() + "个菜单");
+        } catch (Exception e) {
+            System.err.println("为超级管理员配置菜单权限失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
 }

src/main/java/com/gxwebsoft/common/system/controller/WxLoginController.java

@@ -10,6 +10,8 @@ import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.gxwebsoft.cms.entity.CmsWebsite;
+import com.gxwebsoft.cms.service.CmsWebsiteService;
 import com.gxwebsoft.common.core.config.ConfigProperties;
 import com.gxwebsoft.common.core.exception.BusinessException;
 import com.gxwebsoft.common.core.security.JwtSubject;
@@ -52,7 +54,7 @@ import static com.gxwebsoft.common.core.constants.RedisConstants.MP_WX_KEY;
 public class WxLoginController extends BaseController {
   private final StringRedisTemplate redisTemplate;
   private final OkHttpClient http = new OkHttpClient();
-  private final ObjectMapper om = new ObjectMapper();
+  private final ObjectMapper om;
   private volatile long tokenExpireEpoch = 0L; // 过期的 epoch 秒
   @Resource
   private SettingService settingService;
@@ -74,10 +76,13 @@ public class WxLoginController extends BaseController {
   private ConfigProperties config;
   @Resource
   private UserRefereeService userRefereeService;
+  @Resource
+  private CmsWebsiteService cmsWebsiteService;
 
 
-  public WxLoginController(StringRedisTemplate redisTemplate) {
+  public WxLoginController(StringRedisTemplate redisTemplate, ObjectMapper objectMapper) {
     this.redisTemplate = redisTemplate;
+    this.om = objectMapper;
   }
 
   @Operation(summary = "获取微信AccessToken")
@@ -442,6 +447,13 @@ public class WxLoginController extends BaseController {
       map.put("page", "pages/index/index");
       map.put("env_version", "release");
 
+      // 判断应用运行状态
+      final CmsWebsite website = cmsWebsiteService.getByTenantId(tenantId);
+      if(website.getRunning().equals(2)){
+        map.put("check_path",false);
+        map.put("env_version","trial");
+      }
+
       String jsonBody = JSON.toJSONString(map);
       System.out.println("请求的 JSON body = " + jsonBody);
 

src/main/java/com/gxwebsoft/common/system/entity/Menu.java

@@ -1,13 +1,12 @@
 package com.gxwebsoft.common.system.entity;
 
 import com.baomidou.mybatisplus.annotation.*;
-import io.swagger.v3.oas.annotations.media.Schema;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import org.springframework.security.core.GrantedAuthority;
 
-import java.time.LocalDateTime;
-import com.fasterxml.jackson.annotation.JsonFormat;
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -19,6 +18,7 @@ import java.util.List;
 @Data
 @Schema(description = "菜单")
 @TableName("sys_menu")
+@JsonIgnoreProperties(ignoreUnknown = true)
 public class Menu implements GrantedAuthority {
     private static final long serialVersionUID = 1L;
     public static final int TYPE_MENU = 0;  // 菜单类型
@@ -40,9 +40,19 @@ public class Menu implements GrantedAuthority {
     @Schema(description = "菜单组件地址")
     private String component;
 
+    @Schema(description = "模块ID")
+    private String modules;
+
+    @Schema(description = "模块API")
+    private String modulesUrl;
+
     @Schema(description = "菜单类型, 0菜单, 1按钮")
     private Integer menuType;
 
+    @Schema(description = "打开方式, 0当前页, 1新窗口")
+    @TableField(exist = false)
+    private Integer openType;
+
     @Schema(description = "排序号")
     private Integer sortNumber;
 
@@ -69,12 +79,10 @@ public class Menu implements GrantedAuthority {
     private Integer tenantId;
 
     @Schema(description = "创建时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime createTime;
+    private Date createTime;
 
     @Schema(description = "修改时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private LocalDateTime updateTime;
+    private Date updateTime;
 
     @Schema(description = "子菜单")
     @TableField(exist = false)

src/main/java/com/gxwebsoft/common/system/mapper/xml/UserRoleMapper.xml

@@ -3,7 +3,7 @@
 <mapper namespace="com.gxwebsoft.common.system.mapper.UserRoleMapper">
 
     <insert id="insertBatch">
-        INSERT INTO sys_user_role(user_id, role_id) VALUES
+        INSERT INTO gxwebsoft_core.sys_user_role(user_id, role_id) VALUES
         <foreach collection="roleIds" item="roleId" separator=",">
             (#{userId}, #{roleId})
         </foreach>
@@ -11,10 +11,10 @@
 
     <select id="selectByUserId" resultType="com.gxwebsoft.common.system.entity.Role">
         SELECT *
-        FROM sys_role
+        FROM gxwebsoft_core.sys_role
         WHERE role_id IN (
             SELECT role_id
-            FROM sys_user_role
+            FROM gxwebsoft_core.sys_user_role
             WHERE user_id = #{userId}
         )
           AND deleted = 0
@@ -23,7 +23,7 @@
 
     <select id="selectByUserIds" resultType="com.gxwebsoft.common.system.entity.Role">
         SELECT a.user_id, b.*
-        FROM sys_user_role a
+        FROM gxwebsoft_core.sys_user_role a
         LEFT JOIN gxwebsoft_core.sys_role b ON a.role_id = b.role_id
         WHERE a.user_id IN
         <foreach collection="userIds" open="(" close=")" separator="," item="userId">

src/main/java/com/gxwebsoft/common/system/param/MenuImportParam.java

@@ -0,0 +1,60 @@
+package com.gxwebsoft.common.system.param;
+
+import cn.afterturn.easypoi.excel.annotation.Excel;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 菜单导入参数
+ *
+ * @author WebSoft
+ * @since 2025-09-30
+ */
+@Data
+public class MenuImportParam implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Excel(name = "菜单ID")
+    private Integer menuId;
+
+    @Excel(name = "父级ID")
+    private Integer parentId;
+
+    @Excel(name = "菜单名称")
+    private String title;
+
+    @Excel(name = "路由地址")
+    private String path;
+
+    @Excel(name = "组件路径")
+    private String component;
+
+    @Excel(name = "模块ID")
+    private String modules;
+
+    @Excel(name = "模块API")
+    private String modulesUrl;
+
+    @Excel(name = "菜单类型")
+    private Integer menuType;
+
+    @Excel(name = "排序号")
+    private Integer sortNumber;
+
+    @Excel(name = "权限标识")
+    private String authority;
+
+    @Excel(name = "图标")
+    private String icon;
+
+    @Excel(name = "是否隐藏")
+    private Integer hide;
+
+    @Excel(name = "关联应用")
+    private Integer appId;
+
+    @Excel(name = "租户id")
+    private Integer tenantId;
+
+}

src/main/java/com/gxwebsoft/common/system/param/MenuParam.java

@@ -1,11 +1,11 @@
 package com.gxwebsoft.common.system.param;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.fasterxml.jackson.annotation.JsonInclude;
 import com.gxwebsoft.common.core.annotation.QueryField;
 import com.gxwebsoft.common.core.annotation.QueryType;
 import com.gxwebsoft.common.core.web.BaseParam;
-import com.fasterxml.jackson.annotation.JsonInclude;
-import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -40,10 +40,17 @@ public class MenuParam extends BaseParam {
     @Schema(description = "菜单组件地址")
     private String component;
 
+    @Schema(description = "模块ID")
+    private String modules;
+
     @Schema(description = "菜单类型, 0菜单, 1按钮")
     @QueryField(type = QueryType.EQ)
     private Integer menuType;
 
+    @Schema(description = "打开方式, 0当前页, 1新窗口")
+    @TableField(exist = false)
+    private Integer openType;
+
     @Schema(description = "权限标识")
     private String authority;
 
@@ -65,4 +72,12 @@ public class MenuParam extends BaseParam {
     @QueryField(type = QueryType.EQ)
     private Integer tenantId;
 
+    @Schema(description = "企业ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer companyId;
+
+    @Schema(description = "租户名称")
+    @TableField(exist = false)
+    private String tenantName;
+
 }

src/main/java/com/gxwebsoft/common/system/param/VersionParam.java

@@ -0,0 +1,70 @@
+package com.gxwebsoft.common.system.param;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.gxwebsoft.common.core.annotation.QueryField;
+import com.gxwebsoft.common.core.annotation.QueryType;
+import com.gxwebsoft.common.core.web.BaseParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 版本更新查询参数
+ *
+ * @author 科技小王子
+ * @since 2024-01-15 18:52:24
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@Schema(name = "VersionParam对象", description = "版本更新查询参数")
+public class VersionParam extends BaseParam {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "ID")
+    @QueryField(type = QueryType.EQ)
+    private Integer id;
+
+    @Schema(description = "版本名")
+    private String versionName;
+
+    @Schema(description = "版本号")
+    @QueryField(type = QueryType.EQ)
+    private Integer versionCode;
+
+    @Schema(description = "下载链接")
+    private String androidDownloadUrl;
+
+    @Schema(description = "下载链接")
+    private String iosDownloadUrl;
+
+    @Schema(description = "更新日志")
+    private String updateInfo;
+
+    @Schema(description = "强制更新")
+    @QueryField(type = QueryType.EQ)
+    private Integer isHard;
+
+    @Schema(description = "热更")
+    @QueryField(type = QueryType.EQ)
+    private Integer isHot;
+
+    @Schema(description = "备注")
+    private String comments;
+
+    @Schema(description = "文章排序(数字越小越靠前)")
+    @QueryField(type = QueryType.EQ)
+    private Integer sortNumber;
+
+    @QueryField(type = QueryType.EQ)
+    private Integer userId;
+
+    @Schema(description = "状态, 0正常, 1冻结")
+    @QueryField(type = QueryType.EQ)
+    private Integer status;
+
+    @Schema(description = "是否删除, 0否, 1是")
+    @QueryField(type = QueryType.EQ)
+    private Integer deleted;
+
+}

src/main/java/com/gxwebsoft/common/system/service/WxMiniappAccessTokenService.java

@@ -0,0 +1,18 @@
+package com.gxwebsoft.common.system.service;
+
+/**
+ * 微信小程序 access_token 获取服务（按租户）。
+ *
+ * <p>用于调用微信小程序开放接口（例如：上传发货信息）。</p>
+ */
+public interface WxMiniappAccessTokenService {
+
+    /**
+     * 获取指定租户的小程序 access_token（内部带缓存）。
+     *
+     * @param tenantId 租户ID
+     * @return access_token
+     */
+    String getAccessToken(Integer tenantId);
+}
+

src/main/java/com/gxwebsoft/common/system/service/impl/WxMiniappAccessTokenServiceImpl.java

@@ -0,0 +1,108 @@
+package com.gxwebsoft.common.system.service.impl;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.gxwebsoft.common.core.exception.BusinessException;
+import com.gxwebsoft.common.core.utils.RedisUtil;
+import com.gxwebsoft.common.system.service.WxMiniappAccessTokenService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.concurrent.TimeUnit;
+
+import static com.gxwebsoft.common.core.constants.RedisConstants.ACCESS_TOKEN_KEY;
+import static com.gxwebsoft.common.core.constants.RedisConstants.MP_WX_KEY;
+
+/**
+ * 微信小程序 access_token 获取实现（按租户）。
+ *
+ * <p>复用现有缓存结构：
+ * <ul>
+ *   <li>小程序配置：Redis key = {@code mp-weixin:{tenantId}}，value 为 JSON，包含 appId/appSecret</li>
+ *   <li>access_token：Redis key = {@code access-token:{tenantId}}，value 为微信返回的 JSON 字符串</li>
+ * </ul>
+ * </p>
+ */
+@Slf4j
+@Service
+public class WxMiniappAccessTokenServiceImpl implements WxMiniappAccessTokenService {
+
+    @Resource
+    private RedisUtil redisUtil;
+
+    @Override
+    public String getAccessToken(Integer tenantId) {
+        if (tenantId == null) {
+            throw new BusinessException("tenantId 不能为空");
+        }
+
+        final String tokenCacheKey = ACCESS_TOKEN_KEY + ":" + tenantId;
+
+        // 1) 优先从缓存取（兼容 JSON 或纯字符串 token 的历史格式）
+        String cachedValue = redisUtil.get(tokenCacheKey);
+        if (StrUtil.isNotBlank(cachedValue)) {
+            try {
+                JSONObject cachedJson = JSON.parseObject(cachedValue);
+                String accessToken = cachedJson.getString("access_token");
+                if (StrUtil.isNotBlank(accessToken)) {
+                    return accessToken;
+                }
+            } catch (Exception ignore) {
+                // 旧格式：直接存 token
+                return cachedValue;
+            }
+        }
+
+        // 2) 缓存没有则从租户配置获取 appId/appSecret
+        final String wxConfigKey = MP_WX_KEY + tenantId;
+        final String wxConfigValue = redisUtil.get(wxConfigKey);
+        if (StrUtil.isBlank(wxConfigValue)) {
+            throw new BusinessException("未找到微信小程序配置，请检查缓存key: " + wxConfigKey);
+        }
+
+        JSONObject wxConfig;
+        try {
+            wxConfig = JSON.parseObject(wxConfigValue);
+        } catch (Exception e) {
+            throw new BusinessException("微信小程序配置格式错误: " + e.getMessage());
+        }
+
+        final String appId = wxConfig.getString("appId");
+        final String appSecret = wxConfig.getString("appSecret");
+        if (StrUtil.isBlank(appId) || StrUtil.isBlank(appSecret)) {
+            throw new BusinessException("微信小程序配置不完整(appId/appSecret)");
+        }
+
+        // 3) 调用微信接口获取 token
+        final String apiUrl = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential"
+                + "&appid=" + appId + "&secret=" + appSecret;
+        String result = HttpUtil.get(apiUrl);
+
+        JSONObject json = JSON.parseObject(result);
+        if (json.containsKey("errcode") && json.getIntValue("errcode") != 0) {
+            Integer errcode = json.getInteger("errcode");
+            String errmsg = json.getString("errmsg");
+            throw new BusinessException("获取小程序access_token失败: " + errmsg + " (errcode: " + errcode + ")");
+        }
+
+        String accessToken = json.getString("access_token");
+        Integer expiresIn = json.getInteger("expires_in");
+        if (StrUtil.isBlank(accessToken)) {
+            throw new BusinessException("获取小程序access_token失败: access_token为空");
+        }
+
+        // 4) 缓存微信原始 JSON（与现有实现保持一致），提前5分钟过期
+        long ttlSeconds = 7000L;
+        if (expiresIn != null && expiresIn > 300) {
+            ttlSeconds = expiresIn - 300L;
+        }
+        redisUtil.set(tokenCacheKey, result, ttlSeconds, TimeUnit.SECONDS);
+
+        log.info("获取小程序access_token成功 - tenantId={}, ttlSeconds={}", tenantId, ttlSeconds);
+        return accessToken;
+    }
+}
+

src/main/java/com/gxwebsoft/credit/controller/CreditAdministrativeLicenseController.java

@@ -6,9 +6,12 @@ import com.gxwebsoft.common.core.web.BaseController;
 import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
+import com.gxwebsoft.credit.entity.CreditCompany;
 import com.gxwebsoft.credit.entity.CreditAdministrativeLicense;
 import com.gxwebsoft.credit.param.CreditAdministrativeLicenseImportParam;
 import com.gxwebsoft.credit.param.CreditAdministrativeLicenseParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditAdministrativeLicenseService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +25,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 行政许可控制器
@@ -41,6 +46,12 @@ public class CreditAdministrativeLicenseController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询行政许可")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditAdministrativeLicense>> page(CreditAdministrativeLicenseParam param) {
@@ -94,7 +105,7 @@ public class CreditAdministrativeLicenseController extends BaseController {
     @Operation(summary = "删除行政许可")
     @DeleteMapping("/{id}")
     public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (creditAdministrativeLicenseService.removeById(id)) {
+        if (batchImportSupport.hardRemoveById(CreditAdministrativeLicense.class, id)) {
             return success("删除成功");
         }
         return fail("删除失败");
@@ -127,12 +138,52 @@ public class CreditAdministrativeLicenseController extends BaseController {
     @Operation(summary = "批量删除行政许可")
     @DeleteMapping("/batch")
     public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (creditAdministrativeLicenseService.removeByIds(ids)) {
+        if (batchImportSupport.hardRemoveByIds(CreditAdministrativeLicense.class, ids)) {
             return success("删除成功");
         }
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditAdministrativeLicense:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditAdministrativeLicenseService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditAdministrativeLicense::getId,
+            CreditAdministrativeLicense::setId,
+            CreditAdministrativeLicense::getName,
+            CreditAdministrativeLicense::getCompanyId,
+            CreditAdministrativeLicense::setCompanyId,
+            CreditAdministrativeLicense::setCompanyName,
+            CreditAdministrativeLicense::getHasData,
+            CreditAdministrativeLicense::setHasData,
+            CreditAdministrativeLicense::getTenantId,
+            CreditAdministrativeLicense::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入行政许可
      */
@@ -143,6 +194,7 @@ public class CreditAdministrativeLicenseController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditAdministrativeLicenseImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -161,6 +213,11 @@ public class CreditAdministrativeLicenseController extends BaseController {
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
             Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可编号");
             Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可证名称");
+            String fixedCompanyName = null;
+            if (companyId != null && companyId > 0) {
+                CreditCompany fixedCompany = creditCompanyService.getById(companyId);
+                fixedCompanyName = fixedCompany != null ? fixedCompany.getName() : null;
+            }
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -184,6 +241,12 @@ public class CreditAdministrativeLicenseController extends BaseController {
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
+                        if (ImportHelper.isBlank(item.getCompanyName()) && !ImportHelper.isBlank(fixedCompanyName)) {
+                            item.setCompanyName(fixedCompanyName);
+                        }
+                    }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
                     }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
@@ -207,51 +270,20 @@ public class CreditAdministrativeLicenseController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
-                        successCount += batchImportSupport.persistChunkWithFallback(
+                        successCount += batchImportSupport.persistInsertOnlyChunk(
+                            creditAdministrativeLicenseService,
                             chunkItems,
                             chunkRowNumbers,
-                            () -> batchImportSupport.upsertByCodeOrName(
-                                creditAdministrativeLicenseService,
-                                chunkItems,
-                                CreditAdministrativeLicense::getId,
-                                CreditAdministrativeLicense::setId,
-                                CreditAdministrativeLicense::getCode,
-                                CreditAdministrativeLicense::getCode,
-                                CreditAdministrativeLicense::getName,
-                                CreditAdministrativeLicense::getName,
-                                null,
-                                mpBatchSize
-                            ),
-                            (rowItem, rowNumber) -> {
-                                boolean saved = creditAdministrativeLicenseService.save(rowItem);
-                                if (!saved) {
-                                    CreditAdministrativeLicense existing = null;
-                                    if (!ImportHelper.isBlank(rowItem.getCode())) {
-                                        existing = creditAdministrativeLicenseService.lambdaQuery()
-                                            .eq(CreditAdministrativeLicense::getCode, rowItem.getCode())
-                                            .one();
-                                    }
-                                    if (existing == null) {
-                                        existing = creditAdministrativeLicenseService.lambdaQuery()
-                                            .eq(CreditAdministrativeLicense::getName, rowItem.getName())
-                                            .one();
-                                    }
-                                    if (existing != null) {
-                                        rowItem.setId(existing.getId());
-                                        if (creditAdministrativeLicenseService.updateById(rowItem)) {
-                                            return true;
-                                        }
-                                    }
-                                } else {
-                                    return true;
-                                }
-                                String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                                errorMessages.add(prefix + "保存失败");
-                                return false;
-                            },
+                            mpBatchSize,
+                            CreditAdministrativeLicense::getName,
+                            "",
                             errorMessages
                         );
                         chunkItems.clear();
@@ -265,52 +297,19 @@ public class CreditAdministrativeLicenseController extends BaseController {
             }
 
             if (!chunkItems.isEmpty()) {
-                successCount += batchImportSupport.persistChunkWithFallback(
+                successCount += batchImportSupport.persistInsertOnlyChunk(
+                    creditAdministrativeLicenseService,
                     chunkItems,
                     chunkRowNumbers,
-                    () -> batchImportSupport.upsertByCodeOrName(
-                        creditAdministrativeLicenseService,
-                        chunkItems,
-                        CreditAdministrativeLicense::getId,
-                        CreditAdministrativeLicense::setId,
-                        CreditAdministrativeLicense::getCode,
-                        CreditAdministrativeLicense::getCode,
-                        CreditAdministrativeLicense::getName,
-                        CreditAdministrativeLicense::getName,
-                        null,
-                        mpBatchSize
-                    ),
-                    (rowItem, rowNumber) -> {
-                        boolean saved = creditAdministrativeLicenseService.save(rowItem);
-                        if (!saved) {
-                            CreditAdministrativeLicense existing = null;
-                            if (!ImportHelper.isBlank(rowItem.getCode())) {
-                                existing = creditAdministrativeLicenseService.lambdaQuery()
-                                    .eq(CreditAdministrativeLicense::getCode, rowItem.getCode())
-                                    .one();
-                            }
-                            if (existing == null) {
-                                existing = creditAdministrativeLicenseService.lambdaQuery()
-                                    .eq(CreditAdministrativeLicense::getName, rowItem.getName())
-                                    .one();
-                            }
-                            if (existing != null) {
-                                rowItem.setId(existing.getId());
-                                if (creditAdministrativeLicenseService.updateById(rowItem)) {
-                                    return true;
-                                }
-                            }
-                        } else {
-                            return true;
-                        }
-                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                        errorMessages.add(prefix + "保存失败");
-                        return false;
-                    },
+                    mpBatchSize,
+                    CreditAdministrativeLicense::getName,
+                    "",
                     errorMessages
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.ADMINISTRATIVE_LICENSE, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -322,6 +321,153 @@ public class CreditAdministrativeLicenseController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史行政许可（仅解析“历史行政许可”选项卡）
+     * 规则：使用数据库唯一索引约束，重复数据不导入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditAdministrativeLicense:save')")
+    @Operation(summary = "批量导入历史行政许可")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史行政许可");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史行政许可”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditAdministrativeLicenseImportParam> importResult = ExcelImportSupport.read(
+                file, CreditAdministrativeLicenseImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditAdministrativeLicenseImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可编号");
+            Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "决定文书/许可证名称");
+            String fixedCompanyName = null;
+            if (companyId != null && companyId > 0) {
+                CreditCompany fixedCompany = creditCompanyService.getById(companyId);
+                fixedCompanyName = fixedCompany != null ? fixedCompany.getName() : null;
+            }
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditAdministrativeLicense> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditAdministrativeLicenseImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditAdministrativeLicense item = convertImportParamToEntity(param);
+                    if (item.getCode() != null) {
+                        item.setCode(item.getCode().trim());
+                    }
+                    if (item.getName() != null) {
+                        item.setName(item.getName().trim());
+                    }
+
+                    if (ImportHelper.isBlank(item.getName())) {
+                        errorMessages.add("第" + excelRowNumber + "行：决定文书/许可证名称不能为空");
+                        continue;
+                    }
+
+                    String link = null;
+                    if (!ImportHelper.isBlank(item.getCode())) {
+                        link = urlByCode.get(item.getCode());
+                    }
+                    if ((link == null || link.isEmpty()) && !ImportHelper.isBlank(item.getName())) {
+                        link = urlByName.get(item.getName());
+                    }
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                        if (ImportHelper.isBlank(item.getCompanyName()) && !ImportHelper.isBlank(fixedCompanyName)) {
+                            item.setCompanyName(fixedCompanyName);
+                        }
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+                    // 历史导入的数据统一标记为“失效”
+                    item.setDataStatus("失效");
+
+                    if (item.getRecommend() == null) {
+                        item.setRecommend(0);
+                    }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
+                    chunkItems.add(item);
+                    chunkRowNumbers.add(excelRowNumber);
+                    if (chunkItems.size() >= chunkSize) {
+                        successCount += batchImportSupport.persistInsertOnlyChunk(
+                            creditAdministrativeLicenseService,
+                            chunkItems,
+                            chunkRowNumbers,
+                            mpBatchSize,
+                            CreditAdministrativeLicense::getName,
+                            "",
+                            errorMessages
+                        );
+                        chunkItems.clear();
+                        chunkRowNumbers.clear();
+                    }
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistInsertOnlyChunk(
+                    creditAdministrativeLicenseService,
+                    chunkItems,
+                    chunkRowNumbers,
+                    mpBatchSize,
+                    CreditAdministrativeLicense::getName,
+                    "",
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.ADMINISTRATIVE_LICENSE, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载行政许可导入模板
      */

src/main/java/com/gxwebsoft/credit/controller/CreditBankruptcyController.java

@@ -9,6 +9,8 @@ import com.gxwebsoft.common.system.entity.User;
 import com.gxwebsoft.credit.entity.CreditBankruptcy;
 import com.gxwebsoft.credit.param.CreditBankruptcyImportParam;
 import com.gxwebsoft.credit.param.CreditBankruptcyParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditBankruptcyService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +24,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 破产重整控制器
@@ -41,6 +45,12 @@ public class CreditBankruptcyController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询破产重整")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditBankruptcy>> page(CreditBankruptcyParam param) {
@@ -94,7 +104,7 @@ public class CreditBankruptcyController extends BaseController {
     @Operation(summary = "删除破产重整")
     @DeleteMapping("/{id}")
     public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (creditBankruptcyService.removeById(id)) {
+        if (batchImportSupport.hardRemoveById(CreditBankruptcy.class, id)) {
             return success("删除成功");
         }
         return fail("删除失败");
@@ -127,12 +137,51 @@ public class CreditBankruptcyController extends BaseController {
     @Operation(summary = "批量删除破产重整")
     @DeleteMapping("/batch")
     public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (creditBankruptcyService.removeByIds(ids)) {
+        if (batchImportSupport.hardRemoveByIds(CreditBankruptcy.class, ids)) {
             return success("删除成功");
         }
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditBankruptcy:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditBankruptcyService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditBankruptcy::getId,
+            CreditBankruptcy::setId,
+            CreditBankruptcy::getParty,
+            CreditBankruptcy::getCompanyId,
+            CreditBankruptcy::setCompanyId,
+            CreditBankruptcy::getHasData,
+            CreditBankruptcy::setHasData,
+            CreditBankruptcy::getTenantId,
+            CreditBankruptcy::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入破产重整
      */
@@ -143,6 +192,7 @@ public class CreditBankruptcyController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditBankruptcyImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -180,6 +230,9 @@ public class CreditBankruptcyController extends BaseController {
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
                     }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
                     }
@@ -202,41 +255,20 @@ public class CreditBankruptcyController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
-                        successCount += batchImportSupport.persistChunkWithFallback(
+                        successCount += batchImportSupport.persistInsertOnlyChunk(
+                            creditBankruptcyService,
                             chunkItems,
                             chunkRowNumbers,
-                            () -> batchImportSupport.upsertBySingleKey(
-                                creditBankruptcyService,
-                                chunkItems,
-                                CreditBankruptcy::getId,
-                                CreditBankruptcy::setId,
-                                CreditBankruptcy::getCode,
-                                CreditBankruptcy::getCode,
-                                null,
-                                mpBatchSize
-                            ),
-                            (rowItem, rowNumber) -> {
-                                boolean saved = creditBankruptcyService.save(rowItem);
-                                if (!saved) {
-                                    CreditBankruptcy existing = creditBankruptcyService.lambdaQuery()
-                                        .eq(CreditBankruptcy::getCode, rowItem.getCode())
-                                        .one();
-                                    if (existing != null) {
-                                        rowItem.setId(existing.getId());
-                                        if (creditBankruptcyService.updateById(rowItem)) {
-                                            return true;
-                                        }
-                                    }
-                                } else {
-                                    return true;
-                                }
-                                String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                                errorMessages.add(prefix + "保存失败");
-                                return false;
-                            },
+                            mpBatchSize,
+                            CreditBankruptcy::getCode,
+                            "",
                             errorMessages
                         );
                         chunkItems.clear();
@@ -250,42 +282,19 @@ public class CreditBankruptcyController extends BaseController {
             }
 
             if (!chunkItems.isEmpty()) {
-                successCount += batchImportSupport.persistChunkWithFallback(
+                successCount += batchImportSupport.persistInsertOnlyChunk(
+                    creditBankruptcyService,
                     chunkItems,
                     chunkRowNumbers,
-                    () -> batchImportSupport.upsertBySingleKey(
-                        creditBankruptcyService,
-                        chunkItems,
-                        CreditBankruptcy::getId,
-                        CreditBankruptcy::setId,
-                        CreditBankruptcy::getCode,
-                        CreditBankruptcy::getCode,
-                        null,
-                        mpBatchSize
-                    ),
-                    (rowItem, rowNumber) -> {
-                        boolean saved = creditBankruptcyService.save(rowItem);
-                        if (!saved) {
-                            CreditBankruptcy existing = creditBankruptcyService.lambdaQuery()
-                                .eq(CreditBankruptcy::getCode, rowItem.getCode())
-                                .one();
-                            if (existing != null) {
-                                rowItem.setId(existing.getId());
-                                if (creditBankruptcyService.updateById(rowItem)) {
-                                    return true;
-                                }
-                            }
-                        } else {
-                            return true;
-                        }
-                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                        errorMessages.add(prefix + "保存失败");
-                        return false;
-                    },
+                    mpBatchSize,
+                    CreditBankruptcy::getCode,
+                    "",
                     errorMessages
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BANKRUPTCY, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {
@@ -297,6 +306,132 @@ public class CreditBankruptcyController extends BaseController {
         }
     }
 
+    /**
+     * 批量导入历史破产重整（仅解析“历史破产重整”选项卡）
+     * 规则：使用数据库唯一索引约束，重复数据不导入。
+     */
+    @PreAuthorize("hasAuthority('credit:creditBankruptcy:save')")
+    @Operation(summary = "批量导入历史破产重整")
+    @PostMapping("/import/history")
+    public ApiResult<List<String>> importHistoryBatch(@RequestParam("file") MultipartFile file,
+                                                      @RequestParam(value = "companyId", required = false) Integer companyId) {
+        List<String> errorMessages = new ArrayList<>();
+        int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
+
+        try {
+            int sheetIndex = ExcelImportSupport.findSheetIndex(file, "历史破产重整");
+            if (sheetIndex < 0) {
+                return fail("未读取到数据，请确认文件中存在“历史破产重整”选项卡且表头与示例格式一致", null);
+            }
+
+            ExcelImportSupport.ImportResult<CreditBankruptcyImportParam> importResult = ExcelImportSupport.read(
+                file, CreditBankruptcyImportParam.class, this::isEmptyImportRow, sheetIndex);
+            List<CreditBankruptcyImportParam> list = importResult.getData();
+            int usedTitleRows = importResult.getTitleRows();
+            int usedHeadRows = importResult.getHeadRows();
+            int usedSheetIndex = importResult.getSheetIndex();
+
+            if (CollectionUtils.isEmpty(list)) {
+                return fail("未读取到数据，请确认模板表头与示例格式一致", null);
+            }
+
+            User loginUser = getLoginUser();
+            Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
+            Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+            Map<String, String> urlByCode = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "案号");
+
+            final int chunkSize = 500;
+            final int mpBatchSize = 500;
+            List<CreditBankruptcy> chunkItems = new ArrayList<>(chunkSize);
+            List<Integer> chunkRowNumbers = new ArrayList<>(chunkSize);
+
+            for (int i = 0; i < list.size(); i++) {
+                CreditBankruptcyImportParam param = list.get(i);
+                int excelRowNumber = i + 1 + usedTitleRows + usedHeadRows;
+                try {
+                    CreditBankruptcy item = convertImportParamToEntity(param);
+                    if (item.getCode() != null) {
+                        item.setCode(item.getCode().trim());
+                    }
+                    if (ImportHelper.isBlank(item.getCode())) {
+                        errorMessages.add("第" + excelRowNumber + "行：案号不能为空");
+                        continue;
+                    }
+
+                    String link = urlByCode.get(item.getCode());
+                    if (!ImportHelper.isBlank(link)) {
+                        item.setUrl(link.trim());
+                    }
+
+                    if (item.getCompanyId() == null && companyId != null) {
+                        item.setCompanyId(companyId);
+                    }
+                    if (item.getUserId() == null && currentUserId != null) {
+                        item.setUserId(currentUserId);
+                    }
+                    if (item.getTenantId() == null && currentTenantId != null) {
+                        item.setTenantId(currentTenantId);
+                    }
+                    if (item.getStatus() == null) {
+                        item.setStatus(0);
+                    }
+                    if (item.getDeleted() == null) {
+                        item.setDeleted(0);
+                    }
+
+                    if (item.getRecommend() == null) {
+                        item.setRecommend(0);
+                    }
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
+                    chunkItems.add(item);
+                    chunkRowNumbers.add(excelRowNumber);
+                    if (chunkItems.size() >= chunkSize) {
+                        successCount += batchImportSupport.persistInsertOnlyChunk(
+                            creditBankruptcyService,
+                            chunkItems,
+                            chunkRowNumbers,
+                            mpBatchSize,
+                            CreditBankruptcy::getCode,
+                            "",
+                            errorMessages
+                        );
+                        chunkItems.clear();
+                        chunkRowNumbers.clear();
+                    }
+                } catch (Exception e) {
+                    errorMessages.add("第" + excelRowNumber + "行：" + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            if (!chunkItems.isEmpty()) {
+                successCount += batchImportSupport.persistInsertOnlyChunk(
+                    creditBankruptcyService,
+                    chunkItems,
+                    chunkRowNumbers,
+                    mpBatchSize,
+                    CreditBankruptcy::getCode,
+                    "",
+                    errorMessages
+                );
+            }
+
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BANKRUPTCY, touchedCompanyIds);
+
+            if (errorMessages.isEmpty()) {
+                return success("成功导入" + successCount + "条数据", null);
+            }
+            return success("导入完成，成功" + successCount + "条，失败" + errorMessages.size() + "条", errorMessages);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return fail("导入失败：" + e.getMessage(), null);
+        }
+    }
+
     /**
      * 下载破产重整导入模板
      */

src/main/java/com/gxwebsoft/credit/controller/CreditBranchController.java

@@ -6,9 +6,12 @@ import com.gxwebsoft.common.core.web.BaseController;
 import com.gxwebsoft.common.core.web.BatchParam;
 import com.gxwebsoft.common.core.web.PageResult;
 import com.gxwebsoft.common.system.entity.User;
+import com.gxwebsoft.credit.entity.CreditCompany;
 import com.gxwebsoft.credit.entity.CreditBranch;
 import com.gxwebsoft.credit.param.CreditBranchImportParam;
 import com.gxwebsoft.credit.param.CreditBranchParam;
+import com.gxwebsoft.credit.service.CreditCompanyService;
+import com.gxwebsoft.credit.service.CreditCompanyRecordCountService;
 import com.gxwebsoft.credit.service.CreditBranchService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -22,8 +25,10 @@ import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * 分支机构控制器
@@ -41,6 +46,12 @@ public class CreditBranchController extends BaseController {
     @Resource
     private BatchImportSupport batchImportSupport;
 
+    @Resource
+    private CreditCompanyService creditCompanyService;
+
+    @Resource
+    private CreditCompanyRecordCountService creditCompanyRecordCountService;
+
     @Operation(summary = "分页查询分支机构")
     @GetMapping("/page")
     public ApiResult<PageResult<CreditBranch>> page(CreditBranchParam param) {
@@ -94,7 +105,7 @@ public class CreditBranchController extends BaseController {
     @Operation(summary = "删除分支机构")
     @DeleteMapping("/{id}")
     public ApiResult<?> remove(@PathVariable("id") Integer id) {
-        if (creditBranchService.removeById(id)) {
+        if (batchImportSupport.hardRemoveById(CreditBranch.class, id)) {
             return success("删除成功");
         }
         return fail("删除失败");
@@ -127,12 +138,52 @@ public class CreditBranchController extends BaseController {
     @Operation(summary = "批量删除分支机构")
     @DeleteMapping("/batch")
     public ApiResult<?> removeBatch(@RequestBody List<Integer> ids) {
-        if (creditBranchService.removeByIds(ids)) {
+        if (batchImportSupport.hardRemoveByIds(CreditBranch.class, ids)) {
             return success("删除成功");
         }
         return fail("删除失败");
     }
 
+    /**
+     * 根据企业名称匹配企业并更新 companyId（匹配 CreditCompany.name / CreditCompany.matchName）
+     *
+     * <p>默认仅更新 companyId=0 的记录；如需覆盖更新，传 onlyNull=false。</p>
+     */
+    @PreAuthorize("hasAuthority('credit:creditBranch:update')")
+    @OperationLog
+    @Operation(summary = "根据企业名称匹配并更新companyId")
+    @PostMapping("/company-id/refresh")
+    public ApiResult<Map<String, Object>> refreshCompanyIdByCompanyName(
+        @RequestParam(value = "onlyNull", required = false, defaultValue = "true") Boolean onlyNull,
+        @RequestParam(value = "limit", required = false) Integer limit
+    ) {
+        User loginUser = getLoginUser();
+        Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
+
+        BatchImportSupport.CompanyIdRefreshStats stats = batchImportSupport.refreshCompanyIdByCompanyName(
+            creditBranchService,
+            creditCompanyService,
+            currentTenantId,
+            onlyNull,
+            limit,
+            CreditBranch::getId,
+            CreditBranch::setId,
+            CreditBranch::getName,
+            CreditBranch::getCompanyId,
+            CreditBranch::setCompanyId,
+            CreditBranch::setCompanyName,
+            CreditBranch::getHasData,
+            CreditBranch::setHasData,
+            CreditBranch::getTenantId,
+            CreditBranch::new
+        );
+
+        if (!stats.anyDataRead) {
+            return success("无可更新数据", stats.toMap());
+        }
+        return success("更新完成，更新" + stats.updated + "条", stats.toMap());
+    }
+
     /**
      * 批量导入分支机构
      */
@@ -143,6 +194,7 @@ public class CreditBranchController extends BaseController {
                                                @RequestParam(value = "companyId", required = false) Integer companyId) {
         List<String> errorMessages = new ArrayList<>();
         int successCount = 0;
+        Set<Integer> touchedCompanyIds = new HashSet<>();
 
         try {
             ExcelImportSupport.ImportResult<CreditBranchImportParam> importResult = ExcelImportSupport.readAnySheet(
@@ -160,6 +212,11 @@ public class CreditBranchController extends BaseController {
             Integer currentUserId = loginUser != null ? loginUser.getUserId() : null;
             Integer currentTenantId = loginUser != null ? loginUser.getTenantId() : null;
             Map<String, String> urlByName = ExcelImportSupport.readHyperlinksByHeaderKey(file, usedSheetIndex, usedTitleRows, usedHeadRows, "分支机构名称");
+            String fixedCompanyName = null;
+            if (companyId != null && companyId > 0) {
+                CreditCompany fixedCompany = creditCompanyService.getById(companyId);
+                fixedCompanyName = fixedCompany != null ? fixedCompany.getName() : null;
+            }
 
             final int chunkSize = 500;
             final int mpBatchSize = 500;
@@ -179,6 +236,9 @@ public class CreditBranchController extends BaseController {
 
                     if (item.getCompanyId() == null && companyId != null) {
                         item.setCompanyId(companyId);
+                        if (ImportHelper.isBlank(item.getCompanyName()) && !ImportHelper.isBlank(fixedCompanyName)) {
+                            item.setCompanyName(fixedCompanyName);
+                        }
                     }
                     if (item.getUserId() == null && currentUserId != null) {
                         item.setUserId(currentUserId);
@@ -202,41 +262,20 @@ public class CreditBranchController extends BaseController {
                         continue;
                     }
 
+                    if (item.getCompanyId() != null && item.getCompanyId() > 0) {
+                        touchedCompanyIds.add(item.getCompanyId());
+                    }
+
                     chunkItems.add(item);
                     chunkRowNumbers.add(excelRowNumber);
                     if (chunkItems.size() >= chunkSize) {
-                        successCount += batchImportSupport.persistChunkWithFallback(
+                        successCount += batchImportSupport.persistInsertOnlyChunk(
+                            creditBranchService,
                             chunkItems,
                             chunkRowNumbers,
-                            () -> batchImportSupport.upsertBySingleKey(
-                                creditBranchService,
-                                chunkItems,
-                                CreditBranch::getId,
-                                CreditBranch::setId,
-                                CreditBranch::getName,
-                                CreditBranch::getName,
-                                null,
-                                mpBatchSize
-                            ),
-                            (rowItem, rowNumber) -> {
-                                boolean saved = creditBranchService.save(rowItem);
-                                if (!saved) {
-                                    CreditBranch existing = creditBranchService.lambdaQuery()
-                                        .eq(CreditBranch::getName, rowItem.getName())
-                                        .one();
-                                    if (existing != null) {
-                                        rowItem.setId(existing.getId());
-                                        if (creditBranchService.updateById(rowItem)) {
-                                            return true;
-                                        }
-                                    }
-                                } else {
-                                    return true;
-                                }
-                                String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                                errorMessages.add(prefix + "保存失败");
-                                return false;
-                            },
+                            mpBatchSize,
+                            CreditBranch::getName,
+                            "",
                             errorMessages
                         );
                         chunkItems.clear();
@@ -250,42 +289,19 @@ public class CreditBranchController extends BaseController {
             }
 
             if (!chunkItems.isEmpty()) {
-                successCount += batchImportSupport.persistChunkWithFallback(
+                successCount += batchImportSupport.persistInsertOnlyChunk(
+                    creditBranchService,
                     chunkItems,
                     chunkRowNumbers,
-                    () -> batchImportSupport.upsertBySingleKey(
-                        creditBranchService,
-                        chunkItems,
-                        CreditBranch::getId,
-                        CreditBranch::setId,
-                        CreditBranch::getName,
-                        CreditBranch::getName,
-                        null,
-                        mpBatchSize
-                    ),
-                    (rowItem, rowNumber) -> {
-                        boolean saved = creditBranchService.save(rowItem);
-                        if (!saved) {
-                            CreditBranch existing = creditBranchService.lambdaQuery()
-                                .eq(CreditBranch::getName, rowItem.getName())
-                                .one();
-                            if (existing != null) {
-                                rowItem.setId(existing.getId());
-                                if (creditBranchService.updateById(rowItem)) {
-                                    return true;
-                                }
-                            }
-                        } else {
-                            return true;
-                        }
-                        String prefix = rowNumber > 0 ? ("第" + rowNumber + "行：") : "";
-                        errorMessages.add(prefix + "保存失败");
-                        return false;
-                    },
+                    mpBatchSize,
+                    CreditBranch::getName,
+                    "",
                     errorMessages
                 );
             }
 
+            creditCompanyRecordCountService.refresh(CreditCompanyRecordCountService.CountType.BRANCH, touchedCompanyIds);
+
             if (errorMessages.isEmpty()) {
                 return success("成功导入" + successCount + "条数据", null);
             } else {